From 1bd117e4f75f9119d917017c1dc7292153bc17c2 Mon Sep 17 00:00:00 2001 From: Afloat Date: Thu, 12 Nov 2026 18:11:01 +0800 Subject: [PATCH 01/13] fix: decode zstd requests asynchronously when supported --- scripts/bench-zstd-decode.mjs | 30 +++++++++ src/content-encoding.ts | 13 ++-- tests/content-encoding-zstd.test.ts | 97 +++++++++++++++++++++++++++++ 3 files changed, 135 insertions(+), 5 deletions(-) create mode 100644 scripts/bench-zstd-decode.mjs create mode 100644 tests/content-encoding-zstd.test.ts diff --git a/scripts/bench-zstd-decode.mjs b/scripts/bench-zstd-decode.mjs new file mode 100644 index 0000000000..b645e8050c --- /dev/null +++ b/scripts/bench-zstd-decode.mjs @@ -0,0 +1,30 @@ +import assert from "node:assert/strict"; +import * as zlib from "node:zlib"; +import { decodeRequestBody } from "../src/content-encoding.ts"; + +if (typeof zlib.zstdCompressSync !== "function") { + throw new Error("This benchmark requires a Node version with native zstd compression"); +} +const input = Buffer.alloc(16 * 1024 * 1024); +input.fill("a representative repeated conversation entry; 中文 content.\n"); +const encoded = zlib.zstdCompressSync(input); +const synchronousMs = [], totalMs = []; +for (let iteration = 0; iteration < 6; iteration++) { + const started = performance.now(); + const pending = decodeRequestBody("zstd", encoded, input.length); + const returned = performance.now(); + const decoded = await pending; + const completed = performance.now(); + assert.deepEqual(decoded.body, input); + if (iteration > 0) { + synchronousMs.push(returned - started); + totalMs.push(completed - started); + } +} +const median = (values) => values.toSorted((a, b) => a - b)[Math.floor(values.length / 2)]; +console.log(JSON.stringify({ + node: process.version, bytes: input.length, compressed: encoded.length, + warmup: 1, samples: 5, + medianSynchronousMs: median(synchronousMs), medianTotalMs: median(totalMs), + synchronousMs, totalMs, +})); diff --git a/src/content-encoding.ts b/src/content-encoding.ts index 848856e47a..0289964080 100644 --- a/src/content-encoding.ts +++ b/src/content-encoding.ts @@ -1,4 +1,4 @@ -import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from "node:zlib"; +import * as zlib from "node:zlib"; import { DecodedRequestBusyError } from "./request-body-budget.js"; import type { Duplex } from "node:stream"; import { Decompress as ZstdDecompress } from "fzstd"; @@ -69,6 +69,9 @@ function streamDecode(factory: () => Duplex, input: Buffer, max: number, options } async function decodeZstd(input: Buffer, max: number, options?: DecodeOptions): Promise { + if (typeof zlib.createZstdDecompress === "function") { + return streamDecode(zlib.createZstdDecompress, input, max, options); + } const chunks: Buffer[] = []; let size = 0; const decoder = new ZstdDecompress((chunk) => { @@ -83,15 +86,15 @@ async function decodeZstd(input: Buffer, max: number, options?: DecodeOptions): } async function decodeOne(coding: string, input: Buffer, max: number, options?: DecodeOptions): Promise { - if (coding === "gzip" || coding === "x-gzip") return streamDecode(createGunzip, input, max, options); - if (coding === "br") return streamDecode(createBrotliDecompress, input, max, options); + if (coding === "gzip" || coding === "x-gzip") return streamDecode(zlib.createGunzip, input, max, options); + if (coding === "br") return streamDecode(zlib.createBrotliDecompress, input, max, options); if (coding === "zstd") return decodeZstd(input, max, options); if (coding === "deflate") { try { - return await streamDecode(createInflate, input, max, options); + return await streamDecode(zlib.createInflate, input, max, options); } catch (err) { if (err instanceof DecompressedTooLargeError || err instanceof DecodedRequestBusyError || options?.signal?.aborted) throw err; - return streamDecode(createInflateRaw, input, max, options); + return streamDecode(zlib.createInflateRaw, input, max, options); } } throw new Error(`unsupported request content-encoding: ${coding}`); diff --git a/tests/content-encoding-zstd.test.ts b/tests/content-encoding-zstd.test.ts new file mode 100644 index 0000000000..2543cb1d36 --- /dev/null +++ b/tests/content-encoding-zstd.test.ts @@ -0,0 +1,97 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import * as zlib from "node:zlib"; +import { spawnSync } from "node:child_process"; +import { decodeRequestBody, DecompressedTooLargeError } from "../src/content-encoding.ts"; +import { DecodedRequestBusyError } from "../src/request-body-budget.ts"; + +const hasNativeZstd = typeof zlib.createZstdDecompress === "function"; +const plain = Buffer.from('{"model":"gpt-5","input":"hello"}'); +const encoded = Buffer.from("KLUv/SAhCQEAeyJtb2RlbCI6ImdwdC01IiwiaW5wdXQiOiJoZWxsbyJ9", "base64"); + +test("zstd decoding can be cancelled after starting without processing the whole body", { skip: !hasNativeZstd }, async () => { + const raw = Buffer.alloc(4 * 1024 * 1024, 65); + const input = zlib.zstdCompressSync(raw); + const controller = new AbortController(); + const reason = new Error("client disconnected"); + let bytes = 0; + const pending = decodeRequestBody("zstd", input, raw.length, { + signal: controller.signal, + onBytes: (count) => { bytes = count; }, + }); + controller.abort(reason); + await assert.rejects(pending, (error) => error === reason); + assert.ok(bytes < raw.length); +}); + +test("cancelling one zstd decode does not cancel a concurrent request", { skip: !hasNativeZstd }, async () => { + const controller = new AbortController(); + const cancelled = decodeRequestBody("zstd", encoded, 1024, { signal: controller.signal }); + const completed = decodeRequestBody("zstd", encoded, 1024); + controller.abort(); + await assert.rejects(cancelled, { name: "AbortError" }); + assert.deepEqual((await completed).body, plain); +}); + +test("zstd decoding stops if the byte observer cancels the final output chunk", { skip: !hasNativeZstd }, async () => { + const controller = new AbortController(); + let chunks = 0; + await assert.rejects(decodeRequestBody("zstd", encoded, 1024, { + signal: controller.signal, + onBytes: () => { chunks++; controller.abort(); }, + }), { name: "AbortError" }); + assert.equal(chunks, 1); +}); + +test("zstd decoding preserves exact byte limits and the resource-admission error", async () => { + assert.deepEqual((await decodeRequestBody("zstd", encoded, plain.length)).body, plain); + await assert.rejects(decodeRequestBody("zstd", encoded, plain.length - 1), DecompressedTooLargeError); + const busy = new DecodedRequestBusyError(); + await assert.rejects(decodeRequestBody("zstd", encoded, 1024, { + onBytes: () => { throw busy; }, + }), (error) => error === busy); +}); + +test("zstd decoding supports concatenated frames and stacked content encodings", async () => { + assert.deepEqual((await decodeRequestBody("zstd", Buffer.concat([encoded, encoded]), 1024)).body, + Buffer.concat([plain, plain])); + assert.deepEqual((await decodeRequestBody("zstd, gzip", zlib.gzipSync(encoded), 1024)).body, plain); + await assert.rejects(decodeRequestBody("zstd, gzip", zlib.gzipSync(encoded), plain.length - 1), + DecompressedTooLargeError); +}); + +test("zstd decoding rejects truncated input and respects pre-aborted requests", async () => { + await assert.rejects(decodeRequestBody("zstd", encoded.subarray(0, -1), 1024)); + await assert.rejects(decodeRequestBody("zstd", Buffer.from("not a zstd frame"), 1024)); + const controller = new AbortController(); + const reason = new Error("already disconnected"); + controller.abort(reason); + await assert.rejects(decodeRequestBody("zstd", encoded, 1024, { signal: controller.signal }), + (error) => error === reason); +}); + +test("zstd decoding still works when node:zlib has no native zstd factory", () => { + const contentEncoding = new URL("../src/content-encoding.ts", import.meta.url).href; + const budget = new URL("../src/request-body-budget.ts", import.meta.url).href; + const child = spawnSync(process.execPath, ["--import", "tsx", "--input-type=module", "--eval", ` + import assert from "node:assert/strict"; + import zlib from "node:zlib"; + import { syncBuiltinESMExports } from "node:module"; + Reflect.set(zlib, "createZstdDecompress", undefined); + syncBuiltinESMExports(); + const { decodeRequestBody, DecompressedTooLargeError } = await import(${JSON.stringify(contentEncoding)}); + const { DecodedRequestBusyError } = await import(${JSON.stringify(budget)}); + const input = Buffer.from(${JSON.stringify(encoded.toString("base64"))}, "base64"); + const expected = Buffer.from(${JSON.stringify(plain.toString())}); + assert.deepEqual((await decodeRequestBody("zstd", input, expected.length)).body, expected); + await assert.rejects(decodeRequestBody("zstd", input, expected.length - 1), DecompressedTooLargeError); + await assert.rejects(decodeRequestBody("zstd", input, 1024, { + onBytes: () => { throw new DecodedRequestBusyError(); }, + }), DecodedRequestBusyError); + const controller = new AbortController(); + controller.abort(); + await assert.rejects(decodeRequestBody("zstd", input, 1024, { signal: controller.signal }), { name: "AbortError" }); + `], { encoding: "utf8", timeout: 20_000 }); + assert.ifError(child.error); + assert.equal(child.status, 0, child.stderr); +}); From 829a7853bc20f77291e958885f40d497a0a477b2 Mon Sep 17 00:00:00 2001 From: Afloat Date: Fri, 13 Nov 2026 12:44:21 +0800 Subject: [PATCH 02/13] test: register zstd fallback process coverage Register the process-spawning zstd regression in LIVE_FILES so the CI runner can start the test matrix. Append the entry to preserve existing zone slots; the child changes only its own zlib exports and binds no sockets. The actual CI runner's global registration check and all 7 zstd cases pass locally. Typecheck, build and diff checks also pass. --- scripts/live-files.mjs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/scripts/live-files.mjs b/scripts/live-files.mjs index 014f5c22d4..37f74cf9db 100644 --- a/scripts/live-files.mjs +++ b/scripts/live-files.mjs @@ -134,6 +134,9 @@ export const LIVE_FILES = [ // child binds no port and does no network I/O, so no zone band is needed — // the entry is for the tripwire alone, like #3890/#5114 "tests/integrity-worker-stderr.test.ts", + // Native-zstd absence is simulated in an isolated Node child; it binds + // no sockets and changes only that child's built-in module exports. + "tests/content-encoding-zstd.test.ts", ]; /** Band width per live file: the zone ladder drifts +1 per EADDRINUSE retry; From 7341f7d1194762097dbc266e524a1c1886d82ae7 Mon Sep 17 00:00:00 2001 From: Afloat Date: Fri, 13 Nov 2026 14:00:17 +0800 Subject: [PATCH 03/13] fix: preserve complete zstd frames on Node 22 --- src/content-encoding.ts | 71 ++++++++++++++++++++++++++++- tests/content-encoding-zstd.test.ts | 59 +++++++++++++++++++++++- 2 files changed, 128 insertions(+), 2 deletions(-) diff --git a/src/content-encoding.ts b/src/content-encoding.ts index 0289964080..bccd5d2fd1 100644 --- a/src/content-encoding.ts +++ b/src/content-encoding.ts @@ -68,9 +68,78 @@ function streamDecode(factory: () => Duplex, input: Buffer, max: number, options }); } +/** Frame boundaries from RFC 8878 section 3.1, without decompressing blocks. + * Node 22's native decoder drops later frames in one input buffer and accepts + * truncated frames (nodejs/node#64741, #64592). Validate their extent first, + * then decode complete frames separately; native zstd still checks contents. */ +function* zstdFrames(input: Buffer): Generator { + let offset = 0; + const requireBytes = (count: number): void => { + if (count > input.length - offset) throw new Error("truncated zstd frame"); + }; + do { + const start = offset; + requireBytes(4); + const magic = input.readUInt32LE(offset); + if ((magic & 0xfffffff0) === 0x184d2a50) { + requireBytes(8); + const size = input.readUInt32LE(offset + 4); + offset += 8; + requireBytes(size); + offset += size; + } else { + if (magic !== 0xfd2fb528) throw new Error("invalid zstd frame magic"); + requireBytes(5); + const descriptor = input[offset + 4]; + if (descriptor & 8) throw new Error("reserved zstd frame bit"); + const singleSegment = (descriptor & 32) !== 0; + const dictionaryFlag = descriptor & 3; + const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag; + const sizeFlag = descriptor >>> 6; + const sizeBytes = sizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << sizeFlag; + offset += 5; + const remainingHeader = (singleSegment ? 0 : 1) + dictionaryBytes + sizeBytes; + requireBytes(remainingHeader); + offset += remainingHeader; + let lastBlock: boolean; + do { + requireBytes(3); + const header = input.readUIntLE(offset, 3); + offset += 3; + lastBlock = (header & 1) !== 0; + const blockType = (header >>> 1) & 3; + if (blockType === 3) throw new Error("reserved zstd block type"); + const size = blockType === 1 ? 1 : header >>> 3; + requireBytes(size); + offset += size; + } while (!lastBlock); + if (descriptor & 4) { + requireBytes(4); + offset += 4; + } + } + yield input.subarray(start, offset); + } while (offset < input.length); +} + async function decodeZstd(input: Buffer, max: number, options?: DecodeOptions): Promise { if (typeof zlib.createZstdDecompress === "function") { - return streamDecode(zlib.createZstdDecompress, input, max, options); + const chunks: Buffer[] = []; + let size = 0; + for (const frame of zstdFrames(input)) { + options?.signal?.throwIfAborted(); + const body = await streamDecode(zlib.createZstdDecompress, frame, max, { + signal: options?.signal, + onBytes: (bytes) => { + const total = size + bytes; + if (total > max) throw new DecompressedTooLargeError(max); + options?.onBytes?.(total); + }, + }); + chunks.push(body); + size += body.length; + } + return chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, size); } const chunks: Buffer[] = []; let size = 0; diff --git a/tests/content-encoding-zstd.test.ts b/tests/content-encoding-zstd.test.ts index 2543cb1d36..be7d78ebb4 100644 --- a/tests/content-encoding-zstd.test.ts +++ b/tests/content-encoding-zstd.test.ts @@ -8,6 +8,9 @@ import { DecodedRequestBusyError } from "../src/request-body-budget.ts"; const hasNativeZstd = typeof zlib.createZstdDecompress === "function"; const plain = Buffer.from('{"model":"gpt-5","input":"hello"}'); const encoded = Buffer.from("KLUv/SAhCQEAeyJtb2RlbCI6ImdwdC01IiwiaW5wdXQiOiJoZWxsbyJ9", "base64"); +const unknownSize = Buffer.from("KLUv/QAACQEAeyJtb2RlbCI6ImdwdC01IiwiaW5wdXQiOiJoZWxsbyJ9", "base64"); +const checksummed = Buffer.from("KLUv/SQhCQEAeyJtb2RlbCI6ImdwdC01IiwiaW5wdXQiOiJoZWxsbyJ9TTP3+Q==", "base64"); +const skippable = Buffer.from("5f2a4d1803000000010203", "hex"); test("zstd decoding can be cancelled after starting without processing the whole body", { skip: !hasNativeZstd }, async () => { const raw = Buffer.alloc(4 * 1024 * 1024, 65); @@ -53,13 +56,67 @@ test("zstd decoding preserves exact byte limits and the resource-admission error }); test("zstd decoding supports concatenated frames and stacked content encodings", async () => { - assert.deepEqual((await decodeRequestBody("zstd", Buffer.concat([encoded, encoded]), 1024)).body, + const input = Buffer.concat([encoded, encoded]); + const observed: number[] = []; + assert.deepEqual((await decodeRequestBody("zstd", input, plain.length * 2, { + onBytes: (count) => observed.push(count), + })).body, Buffer.concat([plain, plain])); + assert.equal(observed.at(-1), plain.length * 2); + assert.ok(observed.every((count, i) => i === 0 || count >= observed[i - 1])); + await assert.rejects(decodeRequestBody("zstd", input, plain.length * 2 - 1), + (error) => error instanceof DecompressedTooLargeError && error.limit === plain.length * 2 - 1); + const busy = new DecodedRequestBusyError(); + await assert.rejects(decodeRequestBody("zstd", input, 1024, { + onBytes: (count) => { if (count > plain.length) throw busy; }, + }), (error) => error === busy); + const controller = new AbortController(); + const reason = new Error("cancelled in the second frame"); + await assert.rejects(decodeRequestBody("zstd", input, 1024, { + signal: controller.signal, + onBytes: (count) => { if (count > plain.length) controller.abort(reason); }, + }), (error) => error === reason); assert.deepEqual((await decodeRequestBody("zstd, gzip", zlib.gzipSync(encoded), 1024)).body, plain); await assert.rejects(decodeRequestBody("zstd, gzip", zlib.gzipSync(encoded), plain.length - 1), DecompressedTooLargeError); }); +test("zstd decoding accepts unknown-size and checksummed frames with interleaved skippable data", async () => { + assert.deepEqual((await decodeRequestBody("zstd", unknownSize, plain.length)).body, plain); + assert.deepEqual((await decodeRequestBody("zstd", checksummed, plain.length)).body, plain); + const input = Buffer.concat([skippable, unknownSize, skippable, checksummed, skippable]); + assert.deepEqual((await decodeRequestBody("zstd", input, plain.length * 2)).body, + Buffer.concat([plain, plain])); + assert.deepEqual((await decodeRequestBody("zstd", skippable, 0)).body, Buffer.alloc(0)); +}); + +test("zstd decoding accepts RLE and compressed blocks", async () => { + const rle = Buffer.from("28b52ffd20210b010041", "hex"); + assert.deepEqual((await decodeRequestBody("zstd", rle, 33)).body, Buffer.alloc(33, 65)); + const compressed = Buffer.from("KLUv/WDoAk0AABBBQQEA4yuABQ==", "base64"); + assert.deepEqual((await decodeRequestBody("zstd", compressed, 1000)).body, Buffer.alloc(1000, 65)); +}); + +for (const [name, input] of [ + ["unknown-size block", unknownSize.subarray(0, -1)], + ["checksum", checksummed.subarray(0, -1)], + ["second frame", Buffer.concat([encoded, encoded.subarray(0, -1)])], + ["skippable payload", skippable.subarray(0, -1)], + ["trailing skippable payload", Buffer.concat([encoded, skippable.subarray(0, -1)])], + ["frame header", encoded.subarray(0, 5)], + ["block header", encoded.subarray(0, 8)], +] as const) { + test(`zstd decoding rejects a truncated ${name}`, async () => { + await assert.rejects(decodeRequestBody("zstd", input, 1024)); + }); +} + +test("zstd decoding keeps native checksum validation for later frames", { skip: !hasNativeZstd }, async () => { + const corrupt = Buffer.from(checksummed); + corrupt[corrupt.length - 1] ^= 1; + await assert.rejects(decodeRequestBody("zstd", Buffer.concat([encoded, corrupt]), 1024)); +}); + test("zstd decoding rejects truncated input and respects pre-aborted requests", async () => { await assert.rejects(decodeRequestBody("zstd", encoded.subarray(0, -1), 1024)); await assert.rejects(decodeRequestBody("zstd", Buffer.from("not a zstd frame"), 1024)); From c6369fb6a195fbd1e8794c911adaff87d4dba0f0 Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 04:35:44 +0800 Subject: [PATCH 04/13] fix(tests): pin pure-sqlite selection in notice-registry suite MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The suite baseline preload (preload-storage-baseline.mjs) pins BILI_STORAGE_UNIFIED="legacy" for the broad corpus. After #6480 flipped the storage default to pure-sqlite, the notice-registry suite's visibleNotices assertions expect the pure-sqlite default notice, which is gated on unifiedSelectionIsSqlite (unified "sqlite" or absent) — the preload's "legacy" made the notice silent, so the suite was born-red on master. Pin the selection explicitly (#4011 lesson: a test that depends on the production default passes locally but fails in CI). --- tests/notice-registry.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/notice-registry.test.ts b/tests/notice-registry.test.ts index 6d3b60edb4..b3b0d0e8a4 100644 --- a/tests/notice-registry.test.ts +++ b/tests/notice-registry.test.ts @@ -17,6 +17,11 @@ const cfgPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "notice-reg-cfg- process.env.DSH_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "notice-reg-dsh-")); process.env.XDG_STATE_HOME = stateDir; process.env.BILI_CONFIG_FILE = cfgPath; +// #4011 lesson: this suite asserts the pure-sqlite default notice is visible, +// which requires the pure-sqlite SELECTION (unified "sqlite" or absent — the +// gate is unifiedSelectionIsSqlite, not the resolved mode). The suite baseline +// preload pins "legacy" for the broad corpus, so pin the selection explicitly. +process.env.BILI_STORAGE_UNIFIED = "sqlite"; const { NOTICES, visibleNotices, SQLITE_DEFAULT_NOTICE_ID } = await import("../src/notices.ts"); const { IOT_INCOMPAT_NOTICE_ID, PCK_NOTICE_ID, WM_FASTPATH_INTRO_ID, dismissUpgradeNotice } = await import("../src/pck-notice.ts"); From b1bc17b40454480c7204c2d2e7b44afb5216e367 Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 10:20:31 +0800 Subject: [PATCH 05/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in CCR cold-disk-restore test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The dsh plugin lane (ci-e2e-dsh.yml) runs node --import tsx --test WITHOUT the preload-storage-baseline.mjs preload, so BILI_STORAGE_UNIFIED is unset and the storage mode defaults to 'full'. Under the pure-sqlite default flip (5a80e2b8e, #6480), 'full' mode turns the JSON envelope writer OFF — so the .content-store.json sidecar is never written, and the test's readdirSync(namespace) hits ENOENT. Pin BILI_STORAGE_JSON_WRITER=on in the test so the content-store sidecar is written regardless of the storage mode. This keeps the corrupted-store detection path exercised in both full and legacy modes. Closes: dsh plugin lane red on master (run 43532980164, job 132255459726) --- tests/plugin-fork.test.ts | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/tests/plugin-fork.test.ts b/tests/plugin-fork.test.ts index 2763aa2f4e..4bd98e328f 100644 --- a/tests/plugin-fork.test.ts +++ b/tests/plugin-fork.test.ts @@ -909,6 +909,12 @@ test("HTTP CCR shared payload deletion fails closed before persistence", { timeo for (const corruption of ["missing-ref", "missing-payload", "orphan-payload", "wrong-raw-alias", "changed-payload"] as const) { test(`HTTP CCR ${corruption} fails closed after cold disk restore`, async () => { + // The corrupted-store detection path needs the JSON content-store + // sidecar on disk. Under the pure-sqlite default (5a80e2b8e) the + // JSON writer is OFF, so pin it ON to keep exercising the envelope + // corruption path this test was written for. + const oldJsonWriter = process.env.BILI_STORAGE_JSON_WRITER; + process.env.BILI_STORAGE_JSON_WRITER = "on"; const h = await harness(true); try { const parent = resolveConversation("parent").session!; @@ -966,7 +972,11 @@ for (const corruption of ["missing-ref", "missing-payload", "orphan-payload", "w assert.equal(parentState(), before); assert.equal(readFileSync(path, "utf8"), JSON.stringify(disk)); store2.closeQuietly(); - } finally { await h.close(); } + } finally { + if (oldJsonWriter === undefined) delete process.env.BILI_STORAGE_JSON_WRITER; + else process.env.BILI_STORAGE_JSON_WRITER = oldJsonWriter; + await h.close(); + } }); } From 7492c35c2ad980560c3289c4cdb73e9f32af9dfe Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 12:11:32 +0800 Subject: [PATCH 06/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in native opencode e2e lane The pure-sqlite default flip (5a80e2b8e, #6480) turns the JSON envelope writer OFF, so the .json session file this lane asserts on is never written and 'proxy must persist the session' / 'no persisted session carried compressed blocks' fail after the 20s wait. Pin the writer ON in the spawned client's env (the bootstrapped proxy inherits it) so the envelope this test was written for is still produced. Closes: native opencode lane red on master (run 43547593803, job 132302438610) --- tests/e2e/e2e-native-opencode.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/e2e/e2e-native-opencode.test.ts b/tests/e2e/e2e-native-opencode.test.ts index 8b5578020d..78975d418d 100644 --- a/tests/e2e/e2e-native-opencode.test.ts +++ b/tests/e2e/e2e-native-opencode.test.ts @@ -421,6 +421,11 @@ async function ocRun( cwd: ctx.ocCwd, env: { ...cleanEnv(), + // Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope + // writer OFF, but this lane asserts on the on-disk .json session + // file. Pin the writer ON so the envelope this test was written for + // is still produced regardless of the storage-mode default. + BILI_STORAGE_JSON_WRITER: "on", HOME: ctx.homeDir, TMPDIR: ctx.tmdir, XDG_CONFIG_HOME: ctx.xdg.config, From 45f93dbb8fc88523e3015a413ea7620281d11d1e Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 12:11:32 +0800 Subject: [PATCH 07/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in native dsh e2e lane MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Same pure-sqlite default flip (5a80e2b8e, #6480) as the opencode lane: the JSON envelope writer is OFF, so 'proxy must persist the session within 20000ms' fails — the on-disk .json session file is never written. Pin the writer ON in the spawned dsh client's env (the bootstrapped proxy inherits it). Closes: native dsh lane red on master (run 43547497015, job 132302138843) --- tests/e2e/e2e-native-dsh.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/e2e/e2e-native-dsh.test.ts b/tests/e2e/e2e-native-dsh.test.ts index 7b7402356c..ea8c3969e4 100644 --- a/tests/e2e/e2e-native-dsh.test.ts +++ b/tests/e2e/e2e-native-dsh.test.ts @@ -463,6 +463,11 @@ function dshRun( cwd: ctx.dshCwd, env: { ...cleanEnv(), + // Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope + // writer OFF, but this lane asserts on the on-disk .json session + // file. Pin the writer ON so the envelope this test was written for + // is still produced regardless of the storage-mode default. + BILI_STORAGE_JSON_WRITER: "on", HOME: ctx.homeDir, TMPDIR: ctx.tmpDir, DSH_HOME: ctx.dshHome, From d67cc43557b98d9aa9ce61c24f4dcff93d882558 Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 12:11:32 +0800 Subject: [PATCH 08/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in pi codex-responses WS e2e lane MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Same pure-sqlite default flip (5a80e2b8e, #6480) as the opencode/dsh lanes: the JSON envelope writer is OFF, so 'session persisted' fails — the on-disk .json session file is never written. Pin the writer ON in the spawned pi client's env (the bootstrapped proxy inherits it). Closes: pi codex-responses WS lane red on master (run 43547626291, job 132302540960) --- tests/e2e/e2e-pi-codex-ws.test.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/e2e/e2e-pi-codex-ws.test.ts b/tests/e2e/e2e-pi-codex-ws.test.ts index 15788e0224..c5b3625224 100644 --- a/tests/e2e/e2e-pi-codex-ws.test.ts +++ b/tests/e2e/e2e-pi-codex-ws.test.ts @@ -342,6 +342,12 @@ function piRun( cwd: ctx.piCwd, env: { ...cleanEnv(opts.extraEnv), + // Pure-sqlite default (5a80e2b8e, #6480) turns the JSON + // envelope writer OFF, but this lane asserts on the on-disk + // .json session file. Pin the writer ON so the envelope this + // test was written for is still produced regardless of the + // storage-mode default. + BILI_STORAGE_JSON_WRITER: "on", PI_CODING_AGENT_DIR: ctx.piAgentDir, XDG_CONFIG_HOME: ctx.xdg.config, XDG_CACHE_HOME: ctx.xdg.cache, From c392237d4702601246f5bcb70235b46f8becdc8d Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 13:18:32 +0800 Subject: [PATCH 09/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in pi package-native e2e lane MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 4th lane of the pure-sqlite default flip (5a80e2b8e, #6480) family: the JSON envelope writer is OFF, so 'proxy must persist the session' and 'at least one persisted session must carry compressed blocks' fail — the on-disk .json session file is never written. Pin the writer ON in the spawned pi client's env (the bootstrapped proxy inherits it). Closes: pi package-native lane red on ci-fixes (run 43558179054, job 132336647955) --- tests/e2e/e2e-native-pi.test.ts | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/e2e/e2e-native-pi.test.ts b/tests/e2e/e2e-native-pi.test.ts index 151b1606e1..cbedc8dd9b 100644 --- a/tests/e2e/e2e-native-pi.test.ts +++ b/tests/e2e/e2e-native-pi.test.ts @@ -468,8 +468,13 @@ function piRun( // (CI sentinel incident, #4599). Pin the legacy posture so this // coverage stays deterministic; inline posture is covered by // tests/pi-inline-ws.test.ts and tests/pi-native.test.ts. - BILI_PI_INLINE: "0", - PI_CODING_AGENT_DIR: ctx.piAgentDir, + BILI_PI_INLINE: "0", + // Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope + // writer OFF, but this lane asserts on the on-disk .json session + // file. Pin the writer ON so the envelope this test was written for + // is still produced regardless of the storage-mode default. + BILI_STORAGE_JSON_WRITER: "on", + PI_CODING_AGENT_DIR: ctx.piAgentDir, XDG_CONFIG_HOME: ctx.xdg.config, XDG_CACHE_HOME: ctx.xdg.cache, XDG_STATE_HOME: ctx.xdg.state, From 974cd4c2f67c9ee5a1f8879709224cc00b2f91df Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 13:18:32 +0800 Subject: [PATCH 10/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in fork-ccr-adoption suite Same pure-sqlite default flip (5a80e2b8e, #6480) family: the JSON writer is OFF, so the per-session CCR content-store sidecar (.content-store.json) that 'child persists its own companion and survives a proxy restart' asserts on is never written (0 !== 1). The earlier b1bc17b40 pin only covered tests/plugin-fork.test.ts, not this file. Pin the writer ON at module load (before any SessionStore is constructed). Closes: dsh plugin lane red on ci-fixes (run 43558179102, job 132336519539) --- tests/fork-ccr-adoption.test.ts | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/fork-ccr-adoption.test.ts b/tests/fork-ccr-adoption.test.ts index 4cd9a7b586..ea8004f747 100644 --- a/tests/fork-ccr-adoption.test.ts +++ b/tests/fork-ccr-adoption.test.ts @@ -38,6 +38,12 @@ import { maybeAdoptForkBlocks } from "../src/fork-adoption.ts"; import { rmrf } from "./tmp-rm.ts"; process.env.BILI_PERSIST = "0"; +// Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope writer OFF, +// so the per-session CCR content-store sidecar (.content-store.json) this +// suite asserts on is never written. Pin the writer ON at module load (before +// any SessionStore is constructed) so the companion-envelope coverage this +// test was written for still runs regardless of the storage-mode default. +process.env.BILI_STORAGE_JSON_WRITER = "on"; const LIMIT = 200_000; const META = { protocol: "openai" as const, upstreamOrigin: "http://upstream.example/v1" }; From 271abba541666260a2142767c78cb2e53ea00595 Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 13:31:56 +0800 Subject: [PATCH 11/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in subagent-sessions e2e lane MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pure-sqlite default flip (5a80e2b8e, #6480) family: the JSON envelope writer is OFF, so 'proxy must persist the session' fails — the on-disk .json session file is never written. Pin the writer ON in the spawned opencode client's env (the bootstrapped proxy inherits it). --- tests/e2e/e2e-subagent-sessions.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/e2e/e2e-subagent-sessions.test.ts b/tests/e2e/e2e-subagent-sessions.test.ts index af08050217..b1a6188bca 100644 --- a/tests/e2e/e2e-subagent-sessions.test.ts +++ b/tests/e2e/e2e-subagent-sessions.test.ts @@ -394,6 +394,11 @@ async function ocRun( cwd: ctx.ocCwd, env: { ...cleanEnv(), + // Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope + // writer OFF, but this lane asserts on the on-disk .json session + // file. Pin the writer ON so the envelope this test was written for + // is still produced regardless of the storage-mode default. + BILI_STORAGE_JSON_WRITER: "on", HOME: ctx.homeDir, TMPDIR: ctx.tmdir, XDG_CONFIG_HOME: ctx.xdg.config, From 5d47196a267e20b63ed7965b6fea58374cc599f7 Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 13:31:56 +0800 Subject: [PATCH 12/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in dsh-persona e2e lane Pure-sqlite default flip (5a80e2b8e, #6480) family: the JSON envelope writer is OFF, so the on-disk .json session envelope this lane asserts on (exactly ONE persisted session under the raw key) is never written. Pin the writer ON in the spawned dsh client's env. --- tests/e2e/e2e-native-dsh-persona.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/e2e/e2e-native-dsh-persona.test.ts b/tests/e2e/e2e-native-dsh-persona.test.ts index 82f3abc94b..8d3ea3d34c 100644 --- a/tests/e2e/e2e-native-dsh-persona.test.ts +++ b/tests/e2e/e2e-native-dsh-persona.test.ts @@ -400,6 +400,11 @@ function buildRig(tag: string, withAutoReview: boolean): Rig { const env: NodeJS.ProcessEnv = { ...cleanEnv(), + // Pure-sqlite default (5a80e2b8e, #6480) turns the JSON envelope + // writer OFF, but this lane asserts on the on-disk .json session + // envelope. Pin the writer ON so the envelope this test was written + // for is still produced regardless of the storage-mode default. + BILI_STORAGE_JSON_WRITER: "on", HOME: home, TMPDIR: tmp, DSH_HOME: dshHome, From 1ca40871581c5009fdb69eea944f448d002098e7 Mon Sep 17 00:00:00 2001 From: ework-agent Date: Sat, 14 Nov 2026 13:31:56 +0800 Subject: [PATCH 13/13] fix(tests): pin BILI_STORAGE_JSON_WRITER=on in update-state e2e lane MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pure-sqlite default flip (5a80e2b8e, #6480) family: the JSON envelope writer is OFF, so the on-disk .json session file this lane asserts on (state survival across the OLD→NEW update) is never written. Pin the writer ON in the spawned proxy's env (both update phases share envBase). --- tests/e2e/e2e-update-state.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/e2e/e2e-update-state.test.ts b/tests/e2e/e2e-update-state.test.ts index 03f2b1db22..e31baf7659 100644 --- a/tests/e2e/e2e-update-state.test.ts +++ b/tests/e2e/e2e-update-state.test.ts @@ -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);