import { chmodSync, closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readdirSync, readFileSync, renameSync, rmSync, symlinkSync, utimesSync, writeFileSync, writeSync, } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, describe, expect, it, vi } from "vitest"; import { sandboxEnv, withProcessEnv } from "../../test/fixture/env.ts"; vi.mock("node:fs", async (importOriginal) => { const fs = await importOriginal(); return { ...fs, openSync: vi.fn(fs.openSync), closeSync: vi.fn(fs.closeSync), renameSync: vi.fn(fs.renameSync), writeSync: vi.fn(fs.writeSync), }; }); // The template's own slug placeholder is the extension name under test. const slug = "{{extension-slug}}"; const enable = `PI_${slug.toUpperCase().replaceAll("-", "_")}_DEBUG`; const posix = process.platform !== "win32"; let root: string | undefined; afterEach(() => { if (root) rmSync(root, { recursive: true, force: true }); root = undefined; vi.useRealTimers(); vi.resetAllMocks(); vi.restoreAllMocks(); vi.resetModules(); }); function sandbox() { root = mkdtempSync(join(tmpdir(), "pi-ext-debug-")); const env = sandboxEnv(root, { env: { [enable]: "1" } }); const directory = process.platform === "darwin" ? join(root, "Library", "Logs", "pi-ext", slug) : join(root, ".test-state", "pi-ext", "debug", slug); return { env, state: process.platform === "darwin" ? join(root, "Library", "Logs") : join(root, ".test-state"), directory, }; } /** Load a fresh template copy, log one event and one span, then close. */ function logOnce(env: NodeJS.ProcessEnv) { return withProcessEnv(env, async () => { vi.resetModules(); const { defineDebug } = await import("./templates/pi-ext-debug.ts"); const { dbg, span, closeDebug } = defineDebug({ events: ["session.start"], spans: ["request"], fields: { count: "number" }, } as const); expect(() => { dbg?.("session.start", { count: 1 }); span?.("request")("finish", { count: 2 }); }).not.toThrow(); closeDebug(); }); } const records = (directory: string) => readdirSync(directory).flatMap((file) => readFileSync(join(directory, file), "utf8") .trim() .split("\n") .map((line) => JSON.parse(line)), ); describe("pi-ext-debug rolling retention", () => { it("rolls without losing the triggering event and retains three capped segments", async () => { const { env, directory } = sandbox(); await withProcessEnv(env, async () => { const { defineDebug } = await import("./templates/pi-ext-debug.ts"); const fields = Object.fromEntries( Array.from({ length: 23 }, (_, i) => [`field${i}`, ["a".repeat(127)]]), ); const { dbg, closeDebug } = defineDebug({ events: ["sample"], spans: [], fields: { ...fields, count: "number" }, }); const details = Object.fromEntries( Object.keys(fields).map((key) => [key, "a".repeat(127)]), ); try { for (let count = 0; count < 3500; count++) dbg?.("sample", { ...details, count }); } finally { closeDebug(); } }); const files = readdirSync(directory); expect(files).toHaveLength(3); for (const file of files) { expect(file).toMatch(/\.closed\.jsonl$/); expect(lstatSync(join(directory, file)).size).toBeLessThanOrEqual( 2 * 1024 * 1024, ); } const rows = records(directory); expect(rows.some((row) => row.event === "debug.roll")).toBe(true); const counts = rows .filter((row) => row.event === "sample") .map((row) => row.count) .sort((a, b) => a - b); expect(counts.at(-1)).toBe(3499); expect(counts).toEqual( Array.from({ length: counts.length }, (_, i) => counts[0] + i), ); }); it("retains recently modified segments despite clock rollback and equal filename timestamps", async () => { const { env, directory } = sandbox(); mkdirSync(directory, { recursive: true, mode: 0o700 }); const old = ["000000000003", "000000000002", "000000000001"].map( (suffix, i) => { const file = join( directory, `2099-01-01T00-00-00-000Z-1-${suffix}.closed.jsonl`, ); writeFileSync(file, "old\n", { mode: 0o600 }); utimesSync(file, i + 1, i + 1); return file; }, ); vi.useFakeTimers({ toFake: ["Date"] }); vi.setSystemTime(new Date("2010-01-01T00:00:00Z")); await logOnce(env); expect(old.map(existsSync)).toEqual([false, true, true]); expect( readdirSync(directory).some((file) => file.startsWith("2010-")), ).toBe(true); }); it("protects another active writer, including one in the same process", async () => { const { env, directory } = sandbox(); await withProcessEnv(env, async () => { const first = await import("./templates/pi-ext-debug.ts"); first.dbg?.("active"); const active = readdirSync(directory)[0]!; try { for (let i = 0; i < 5; i++) await logOnce(env); expect(existsSync(join(directory, active))).toBe(true); first.dbg?.("still.active"); expect(readFileSync(join(directory, active), "utf8")).toContain( '"event":"still.active"', ); } finally { first.closeDebug(); } }); expect(readdirSync(directory)).toHaveLength(3); }); it.each(["ESRCH", "EPERM"])( "only reclaims an unmarked file when PID probing returns ESRCH (%s)", async (code) => { const { env, directory } = sandbox(); mkdirSync(directory, { recursive: true, mode: 0o700 }); const old = join( directory, "2020-01-01T00-00-00-000Z-2147483647-000000000000.jsonl", ); writeFileSync(old, "old\n", { mode: 0o600 }); vi.spyOn(process, "kill").mockImplementation(() => { throw Object.assign(new Error("probe"), { code }); }); for (let i = 0; i < 4; i++) await logOnce(env); expect(existsSync(old)).toBe(code !== "ESRCH"); }, ); it.each(["close", "rename"])( "keeps failed %s segments unmarked and protects them from same-PID cleanup", async (operation) => { const { env, directory } = sandbox(); await withProcessEnv(env, async () => { const logger = await import("./templates/pi-ext-debug.ts"); logger.dbg?.("before.close"); const old = join(directory, readdirSync(directory)[0]!); const actual = await vi.importActual("node:fs"); let leakedFd: number | undefined; if (operation === "close") vi.mocked(closeSync).mockImplementationOnce((fd) => { leakedFd = fd; throw new Error("close failure"); }); else vi.mocked(renameSync).mockImplementationOnce(() => { throw new Error("rename failure"); }); try { expect(() => logger.closeDebug()).not.toThrow(); for (let i = 0; i < 4; i++) await logOnce(env); expect(existsSync(old)).toBe(true); logger.dbg?.("after.close"); expect( records(directory).some((row) => row.event === "after.close"), ).toBe(true); } finally { logger.closeDebug(); if (leakedFd !== undefined) actual.closeSync(leakedFd); } }); }, ); it.each(["write", "rollover-open"])( "silently stops after %s failure, even after close", async (operation) => { const { env, directory } = sandbox(); await withProcessEnv(env, async () => { const logger = await import("./templates/pi-ext-debug.ts"); logger.dbg?.("before.failure"); if (operation === "write") vi.mocked(writeSync).mockImplementationOnce(() => { throw new Error("write failure"); }); else vi.mocked(openSync).mockImplementation(() => { throw new Error("open failure"); }); expect(() => { for (let i = 0; i < 12000; i++) logger.dbg?.("sample", { modelId: "a".repeat(127) }); logger.closeDebug(); logger.dbg?.("after.failure"); }).not.toThrow(); expect( records(directory).some((row) => row.event === "after.failure"), ).toBe(false); if (operation === "rollover-open") expect( records(directory).some((row) => row.event === "debug.roll"), ).toBe(true); }); }, ); it("leaves unrelated files and matching symlinks untouched", async () => { const { env, directory } = sandbox(); mkdirSync(directory, { recursive: true, mode: 0o700 }); const unrelated = join(directory, "notes.jsonl"); writeFileSync(unrelated, "keep", { mode: 0o600 }); const link = join( directory, "2099-01-01T00-00-00-000Z-1-000000000000.closed.jsonl", ); for (let i = 1; i <= 3; i++) mkdirSync( join( directory, `2099-01-01T00-00-00-000Z-1-00000000000${i}.closed.jsonl`, ), ); if (posix) symlinkSync(unrelated, link); for (let i = 0; i < 4; i++) await logOnce(env); expect(readFileSync(unrelated, "utf8")).toBe("keep"); if (posix) expect(lstatSync(link).isSymbolicLink()).toBe(true); expect( readdirSync(directory).filter( (name) => lstatSync(join(directory, name)).isFile() && name !== "notes.jsonl", ), ).toHaveLength(3); }); }); describe("pi-ext-debug template directories", () => { it("creates missing private directories and a private file", async () => { const { env, directory } = sandbox(); await logOnce(env); expect(records(directory).map((record) => record.event)).toEqual([ "session.start", "request.start", "request.finish", ]); if (posix) { for (const part of [ join(directory, "..", ".."), join(directory, ".."), directory, ]) expect(lstatSync(part).mode & 0o777).toBe(0o700); const [file] = readdirSync(directory); expect(lstatSync(join(directory, file!)).mode & 0o777).toBe(0o600); } }); it("reuses existing private directories for a new file", async () => { const { env, directory } = sandbox(); await logOnce(env); await logOnce(env); expect(readdirSync(directory)).toHaveLength(2); expect(records(directory)).toHaveLength(6); }); it.runIf(posix)("refuses a directory readable by others", async () => { const { env, state, directory } = sandbox(); mkdirSync(join(state, "pi-ext"), { recursive: true, mode: 0o700 }); chmodSync(join(state, "pi-ext"), 0o755); await logOnce(env); expect(existsSync(directory)).toBe(false); }); it.runIf(posix)("refuses a symlinked extension directory", async () => { const { env, state, directory } = sandbox(); const target = join(state, "elsewhere"); mkdirSync(target, { recursive: true, mode: 0o700 }); mkdirSync(join(directory, ".."), { recursive: true, mode: 0o700 }); chmodSync(join(state, "pi-ext"), 0o700); symlinkSync(target, directory); await logOnce(env); expect(readdirSync(target)).toEqual([]); }); });