Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 9 additions & 37 deletions src/inline-engine.ts
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,6 @@ export const INLINE_ORIGIN = "http://billion-context.inline";
const INLINE_HOSTNAME = new URL(INLINE_ORIGIN).hostname;

type FetchInput = string | URL | Request;
type BodyLike = string | URLSearchParams | Blob | ArrayBuffer | ArrayBufferView | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;

export interface InlineEngine {
origin: string;
Expand Down Expand Up @@ -69,22 +68,6 @@ function normalizeHeaderPairs(value: Record<string, string | number | string[]>
* undici recomputes length and framing from the actual stream. */
const HOP_HEADERS = new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade", "host", "content-length"]);

async function bodyToBuffer(body: BodyLike | null | undefined): Promise<Buffer> {
if (body === null || body === undefined) return Buffer.alloc(0);
if (typeof body === "string") return Buffer.from(body);
if (body instanceof URLSearchParams) return Buffer.from(body.toString());
if (body instanceof Blob) return Buffer.from(await body.arrayBuffer());
if (body instanceof ArrayBuffer) return Buffer.from(body);
if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
const iterator = (body as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator];
if (typeof iterator === "function") {
const parts: Buffer[] = [];
for await (const chunk of body as AsyncIterable<Uint8Array>) parts.push(Buffer.from(chunk));
return Buffer.concat(parts);
}
throw new Error(`inline engine: unsupported request body type ${Object.prototype.toString.call(body)}`);
}

/** Minimal duck-type of http.IncomingMessage covering everything the pipeline
* reads: url/method/headers/socket identity plus the readBody event surface.
* Body delivery is LAZY (microtask after listener registration) — readBody
Expand Down Expand Up @@ -224,38 +207,27 @@ class InlineRes extends EventEmitter {
}

async function toInlineReq(input: FetchInput, init?: RequestInit): Promise<InlineReq> {
let url: string;
let baseHeaders: Headers | [string, string][] | Record<string, string> | undefined;
let requestMethod: string | undefined;
let requestBody: BodyLike | null | undefined;
if (typeof input === "string") url = input;
else if (input instanceof URL) url = input.href;
else {
url = input.url;
baseHeaders = input.headers;
requestMethod = input.method;
requestBody = await input.arrayBuffer().catch(() => null);
}
const headers = new Headers(baseHeaders);
if (init?.headers !== undefined) new Headers(init.headers).forEach((v, k) => headers.set(k, v));
// Only normalize body/header semantics here; the dispatcher owns and
// detaches the caller's cancellation listener. A dependent Request signal
// would leave a second listener behind. Inherit dictionary members so
// prototype and non-enumerable RequestInit fields retain Fetch semantics.
const request = new Request(input, Object.create(init ?? null, { signal: { value: null } }) as RequestInit);
const headerMap: Record<string, string | string[] | undefined> = {};
headers.forEach((value, key) => {
request.headers.forEach((value, key) => {
const existing = headerMap[key];
headerMap[key] = existing === undefined ? value : Array.isArray(existing) ? [...existing, value] : [existing, value];
});
const method = (init?.method ?? requestMethod ?? "GET").toUpperCase();
const bodySource = init?.body !== undefined ? init.body as BodyLike | null : requestBody;
const body = await bodyToBuffer(bodySource);
const body = Buffer.from(await request.arrayBuffer());
// The pipeline reads req.url as an ORIGIN-FORM request target ("/bili/…" —
// what node:http hands a server for a normal connection). An absolute-form
// URL would fall into resolveUpstream's forward-proxy branch and be routed
// to its own authority — the pseudo-origin — instead of the embedded host.
const parsed = new URL(url);
const parsed = new URL(request.url);
// Pseudo-origin traffic is same-process by definition — present the
// loopback identity so the admin surface's DNS-rebinding Host gate passes
// without weakening the gate itself. Other origins keep their real host.
if (headerMap["host"] === undefined) headerMap["host"] = parsed.hostname === INLINE_HOSTNAME ? "127.0.0.1" : parsed.host;
return new InlineReq(parsed.pathname + parsed.search, method, headerMap, body);
return new InlineReq(parsed.pathname + parsed.search, request.method, headerMap, body);
}

function responseFrom(res: InlineRes): Response {
Expand Down
5 changes: 5 additions & 0 deletions tests/e2e/e2e-update-state.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -299,6 +299,11 @@ test("self-update keeps live compression state: folds survive the OLD→NEW hop
envBase.BILI_UPDATE_POLICY_URL = "http://127.0.0.1:1/no-policy.json";
envBase.BILI_PERSIST_DEBOUNCE_MS = "200";
envBase.BILI_SESSIONS_DIR = sessionsDir;
// Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope
// writer OFF, but this lane asserts on the on-disk .json session file
// (state survival across the update). Pin the writer ON so the
// envelope this test was written for is still produced.
envBase.BILI_STORAGE_JSON_WRITER = "on";

const port = await freePort();
proxy = spawnProxy(installDir, port, envBase);
Expand Down
274 changes: 274 additions & 0 deletions tests/inline-request-init.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,274 @@
import { after, test } from "node:test";
import assert from "node:assert/strict";
import { getEventListeners } from "node:events";
import http from "node:http";
import type { AddressInfo } from "node:net";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";

const root = fs.mkdtempSync(path.join(os.tmpdir(), "bili-inline-request-init-"));
const previous = new Map<string, string | undefined>();
for (const name of ["XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_CONFIG_HOME"]) {
previous.set(name, process.env[name]);
process.env[name] = path.join(root, name);
}
const { getInlineEngine, INLINE_ORIGIN, _resetInlineEngineForTest } = await import("../src/inline-engine.ts");
const engine = await getInlineEngine();
let hits = 0;
const streamResponses: http.ServerResponse[] = [];
const upstream = http.createServer((req, res) => {
const chunks: Buffer[] = [];
req.on("data", chunk => chunks.push(Buffer.from(chunk)));
req.on("end", () => {
hits++;
if (req.url === "/signal-stream") {
streamResponses.push(res);
res.writeHead(200, { "content-type": "text/plain" });
res.write("first");
return;
}
res.writeHead(200, { "content-type": "application/json" });
res.end(JSON.stringify({ method: req.method, headers: req.headers, body: Buffer.concat(chunks).toString() }));
});
});
await new Promise<void>(resolve => upstream.listen(0, "127.0.0.1", resolve));
const target = `${INLINE_ORIGIN}/bili/http://127.0.0.1:${(upstream.address() as AddressInfo).port}/echo`;
const streamTarget = target.replace(/\/echo$/, "/signal-stream");
after(async () => {
upstream.closeAllConnections();
await new Promise<void>(resolve => upstream.close(() => resolve()));
_resetInlineEngineForTest();
for (const [name, value] of previous) {
if (value === undefined) delete process.env[name];
else process.env[name] = value;
}
fs.rmSync(root, { recursive: true, force: true });
});

interface Echo { method: string; headers: Record<string, string | undefined>; body: string }
async function dispatch(input: string | URL | Request, init?: RequestInit): Promise<Echo> {
const response = await engine.dispatch(input, init, globalThis.fetch);
assert.equal(response.status, 200);
return await response.json() as Echo;
}
function original(): Request {
return new Request(target, { method: "POST", headers: { authorization: "Bearer original", "x-original": "old", "content-type": "application/custom" }, body: "original" });
}

const headerCases: [string, NonNullable<RequestInit["headers"]>][] = [
["empty object", {}],
["object", { "x-replacement": "new" }],
["Headers", new Headers({ "x-replacement": "new" })],
["tuples", [["x-replacement", "new"]]],
];
for (const [name, headers] of headerCases) {
test(`RequestInit headers replace Request headers (${name})`, async () => {
const result = await dispatch(original(), { headers });
assert.equal(result.headers.authorization, undefined);
assert.equal(result.headers["x-original"], undefined);
assert.equal(result.headers["content-type"], undefined);
assert.equal(result.headers["x-replacement"], new Headers(headers).get("x-replacement") ?? undefined);
assert.equal(result.body, "original");
});
}

for (const body of [undefined, null]) {
test(`a ${body} body override inherits the Request body`, async () => {
const input = original();
const result = await dispatch(input, { body });
assert.equal(result.body, "original");
assert.equal(result.headers.authorization, "Bearer original");
assert.equal(input.bodyUsed, true);
});
}

for (const body of ["replacement", ""]) {
test(`an explicit ${body ? "nonempty" : "empty"} body override does not consume the original`, async () => {
const input = original();
const result = await dispatch(input, { body });
assert.equal(result.body, body);
assert.equal(await input.text(), "original");
});
}

test("a body override does not wait for an unused original stream", { timeout: 10_000 }, async () => {
let finish!: () => void;
const body = new ReadableStream<Uint8Array>({ start(controller) { finish = () => controller.close(); } });
const input = new Request(target, { method: "POST", body, duplex: "half" } as RequestInit);
const request = dispatch(input, { body: "replacement" });
let timedOut = false;
const timeout = setTimeout(() => { timedOut = true; finish(); }, 1000);
try {
assert.equal((await request).body, "replacement");
assert.equal(timedOut, false, "the overridden body must never delay dispatch");
assert.equal(input.bodyUsed, false);
} finally {
clearTimeout(timeout);
if (!timedOut) finish();
}
});

test("a consumed Request body fails before any upstream call", async () => {
const input = original();
await input.text();
const before = hits;
await assert.rejects(dispatch(input), TypeError);
assert.equal(hits, before);
});

test("a failing Request body propagates its error without sending an empty request", async () => {
const failure = new Error("source stream failed");
const body = new ReadableStream<Uint8Array>({ start(controller) { controller.error(failure); } });
const input = new Request(target, { method: "POST", body, duplex: "half" } as RequestInit);
const before = hits;
await assert.rejects(dispatch(input), error => error === failure);
assert.equal(hits, before);
});

test("explicit body replacement permits a previously consumed Request", async () => {
const input = original();
await input.text();
assert.equal((await dispatch(input, { body: "replacement" })).body, "replacement");
});

test("string and URL inputs retain fetch body encoding and inferred content types", async () => {
for (const input of [target, new URL(target)]) {
const text = await dispatch(input, { method: "POST", body: "hello" });
assert.equal(text.body, "hello");
assert.equal(text.headers["content-type"], "text/plain;charset=UTF-8");
const form = await dispatch(input, { method: "POST", body: new URLSearchParams({ query: "中文 & hello" }) });
assert.equal(form.body, "query=%E4%B8%AD%E6%96%87+%26+hello");
assert.equal(form.headers["content-type"], "application/x-www-form-urlencoded;charset=UTF-8");
}
});

test("FormData receives the matching multipart boundary", async () => {
const form = new FormData();
form.set("prompt", "hello");
form.set("file", new Blob(["content"], { type: "text/plain" }), "notes.txt");
const result = await dispatch(target, { method: "POST", body: form });
const boundary = result.headers["content-type"]?.match(/^multipart\/form-data; boundary=(.+)$/)?.[1];
assert.ok(boundary);
assert.ok(result.body.startsWith(`--${boundary}\r\n`));
assert.ok(result.body.includes('name="file"; filename="notes.txt"'));
assert.ok(result.body.includes("content\r\n"));
});

test("GET body validation rejects before reaching the upstream", async () => {
const before = hits;
await assert.rejects(dispatch(target, { method: "GET", body: "invalid" }), TypeError);
assert.equal(hits, before);
});

async function openStream(input: string | URL | Request, init?: RequestInit) {
const response = await engine.dispatch(input, init, globalThis.fetch);
const reader = response.body!.getReader();
assert.equal(Buffer.from((await reader.read()).value!).toString(), "first");
return { reader, source: streamResponses.at(-1)! };
}

async function finishStream(stream: Awaited<ReturnType<typeof openStream>>): Promise<void> {
stream.source.end("last");
let tail = "";
for (;;) {
const chunk = await stream.reader.read();
if (chunk.done) break;
tail += Buffer.from(chunk.value).toString();
}
assert.equal(tail, "last");
}

async function closeStream(stream: Awaited<ReturnType<typeof openStream>>): Promise<void> {
if (!stream.source.writableEnded) stream.source.end();
await stream.reader.cancel().catch(() => {});
}

for (const kind of ["string", "URL"] as const) {
test(`normalizing a ${kind} input leaves cancellation with the dispatcher`, async () => {
const controller = new AbortController();
const ownListener = (): void => {};
controller.signal.addEventListener("abort", ownListener);
const stream = await openStream(kind === "string" ? streamTarget : new URL(streamTarget), { signal: controller.signal });
try {
assert.equal(getEventListeners(controller.signal, "abort").length, 2, "only the caller and dispatcher own listeners");
await finishStream(stream);
assert.deepEqual(getEventListeners(controller.signal, "abort"), [ownListener]);
} finally {
controller.abort();
await closeStream(stream);
}
});
}

test("normalizing a Request does not retain a dependency on its signal", async () => {
const controller = new AbortController();
const input = new Request(streamTarget, { signal: controller.signal });
const before = getEventListeners(input.signal, "abort");
const stream = await openStream(input);
try {
// Request-only dispatch signal inheritance is a separate transport
// concern; the temporary body/header normalizer must not own it.
await finishStream(stream);
assert.deepEqual(getEventListeners(input.signal, "abort"), before);
} finally {
controller.abort();
await closeStream(stream);
}
});

test("an explicit init signal owns cancellation instead of the Request signal", async () => {
const original = new AbortController();
const replacement = new AbortController();
const input = new Request(streamTarget, { signal: original.signal });
const stream = await openStream(input, { signal: replacement.signal });
try {
assert.equal(getEventListeners(input.signal, "abort").length, 0);
assert.equal(getEventListeners(replacement.signal, "abort").length, 1);
original.abort(new Error("original request cancelled"));
assert.equal(replacement.signal.aborted, false);
replacement.abort(new Error("effective signal cancelled"));
await assert.rejects(stream.reader.read(), /client aborted/);
assert.equal(getEventListeners(replacement.signal, "abort").length, 0);
} finally {
original.abort();
replacement.abort();
await closeStream(stream);
}
});

test("an explicit null signal keeps an aborted Request override independent", async () => {
const original = new AbortController();
const input = new Request(streamTarget, { signal: original.signal });
original.abort(new Error("overridden request cancellation"));
const stream = await openStream(input, { signal: null });
try {
await finishStream(stream);
assert.equal(getEventListeners(input.signal, "abort").length, 0);
} finally { await closeStream(stream); }
});

test("a body read failure does not retain the init signal before dispatch starts", async () => {
const controller = new AbortController();
const failure = new Error("normalization body failed");
const body = new ReadableStream<Uint8Array>({ start(stream) { stream.error(failure); } });
const before = hits;
try {
await assert.rejects(dispatch(target, { method: "POST", body, duplex: "half", signal: controller.signal } as RequestInit), error => error === failure);
assert.equal(hits, before);
assert.equal(getEventListeners(controller.signal, "abort").length, 0);
} finally { controller.abort(); }
});

for (const kind of ["inherited", "non-enumerable"] as const) {
test(`RequestInit keeps ${kind} body, method, and header members`, async () => {
const fields: RequestInit = { method: "POST", body: "dictionary body", headers: { "x-dictionary": kind } };
const init: RequestInit = kind === "inherited"
? Object.create(fields) as RequestInit
: Object.create(null, Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, { value }]))) as RequestInit;
const result = await dispatch(target, init);
assert.equal(result.method, "POST");
assert.equal(result.body, "dictionary body");
assert.equal(result.headers["x-dictionary"], kind);
});
}
Loading