import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, expect, it } from "vitest"; import { sandboxEnv, withProcessEnv } from "../../test/fixture/env.ts"; import { defineChoiceSetting, defineIntegerSetting, parseNumberSetting, resolveSetting, type SettingDeclaration, } from "./templates/pi-ext-settings.ts"; let root: string | undefined; afterEach(() => { if (root) rmSync(root, { recursive: true, force: true }); root = undefined; }); function resolve( declaration: SettingDeclaration, input: { user?: unknown; project?: unknown; env?: Record; flags?: Record; trusted?: boolean; }, ) { root = mkdtempSync(join(tmpdir(), "pi-ext-settings-")); const env = sandboxEnv(root, input.env ? { env: input.env } : {}); const write = (dir: string, value: unknown) => { mkdirSync(dir, { recursive: true }); writeFileSync(join(dir, "settings.json"), JSON.stringify(value)); }; if (input.user !== undefined) write(join(env["HOME"] ?? "", ".pi/agent"), input.user); if (input.project !== undefined) write(join(root, ".pi"), input.project); const cwd = root; return withProcessEnv(env, () => resolveSetting( { getFlag: (name) => input.flags?.[name] }, { cwd, isProjectTrusted: () => input.trusted ?? true }, declaration, ), ); } const block: SettingDeclaration> = { key: "demo", parse: (raw) => { if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return undefined; const value = raw as Record; if ("bad" in value) throw new Error("demo.bad is not allowed"); return value; }, default: {}, }; it("deep-merges objects project over user, replacing arrays and scalars", async () => { const result = await resolve(block, { user: { demo: { a: 1, list: [1, 2], nested: { keep: true, over: "user" } }, }, project: { demo: { list: [3], nested: { over: "project" } } }, }); expect(result).toEqual({ ok: true, source: "project", value: { a: 1, list: [3], nested: { keep: true, over: "project" }, }, }); }); it("keeps __proto__ keys as own properties when merging", async () => { root = mkdtempSync(join(tmpdir(), "pi-ext-settings-")); const env = sandboxEnv(root); const agent = join(env["HOME"] ?? "", ".pi/agent"); mkdirSync(agent, { recursive: true }); mkdirSync(join(root, ".pi"), { recursive: true }); writeFileSync(join(agent, "settings.json"), '{"demo":{"a":1}}'); writeFileSync( join(root, ".pi", "settings.json"), '{"demo":{"__proto__":{"polluted":true}}}', ); const cwd = root; const result = await withProcessEnv(env, () => resolveSetting( { getFlag: () => undefined }, { cwd, isProjectTrusted: () => true }, block, ), ); if (!result.ok) throw new Error(result.error); expect(Object.hasOwn(result.value, "__proto__")).toBe(true); expect(Object.getPrototypeOf(result.value)).toBe(Object.prototype); expect(({} as Record)["polluted"]).toBeUndefined(); }); it("parses numbers from settings and numeric strings from env or flags only", () => { expect(parseNumberSetting(70, "user")).toBe(70); expect(parseNumberSetting("70", "env")).toBe(70); expect(parseNumberSetting("2.5", "flag")).toBe(2.5); expect(parseNumberSetting("70", "project")).toBeUndefined(); for (const raw of ["", " ", "abc", "Infinity", Number.NaN, true, null]) expect(parseNumberSetting(raw, "env"), String(raw)).toBeUndefined(); }); it("derives strict enum validation from the declared choices", async () => { const setting = defineChoiceSetting({ key: "demo.engine", default: "fast", choices: ["fast", "quality"], label: "Engine", description: "Choose an engine.", env: "PI_DEMO_ENGINE", }); expect(setting.choices).toEqual(["fast", "quality"]); expect(setting.label).toBe("Engine"); for (const source of ["user", "project", "env", "flag"] as const) { expect(setting.parse("quality", source)).toBe("quality"); for (const raw of [true, 1, null, undefined, "", "unknown", " fast"]) expect(() => setting.parse(raw, source)).toThrow("expected one of:"); } expect(await resolve(setting, {})).toEqual({ ok: true, source: "default", value: "fast", }); expect( await resolve(setting, { user: { demo: { engine: "quality" } }, env: { PI_DEMO_ENGINE: "unknown" }, }), ).toMatchObject({ ok: false, source: "env" }); expect(() => defineChoiceSetting({ key: "bad", default: "missing", choices: ["fast"] }), ).toThrow("Invalid choice declaration"); expect(() => defineChoiceSetting({ key: "bad", default: "missing", choices: [] }), ).toThrow("Invalid choice declaration"); }); it("preserves unset enum defaults without accepting explicit unset or invalid inputs", async () => { const setting = defineChoiceSetting({ key: "demo.thinking", choices: ["low", "high"], default: undefined, }); expect(await resolve(setting, {})).toEqual({ ok: true, source: "default", value: undefined, }); expect( await resolve(setting, { user: { demo: { thinking: "high" } } }), ).toEqual({ ok: true, source: "user", value: "high" }); expect( await resolve(setting, { user: { demo: { thinking: "high" } }, project: { demo: { thinking: null } }, }), ).toMatchObject({ ok: false, source: "project" }); expect(setting.parse(undefined, "default")).toBeUndefined(); for (const source of ["user", "project", "env", "flag"] as const) { for (const value of [undefined, null, true, "", "auto", "HIGH"]) expect(() => setting.parse(value, source)).toThrow("expected one of:"); } expect(() => defineChoiceSetting({ key: "bad", choices: [], default: undefined }), ).toThrow("Invalid choice declaration"); }); it("derives integer validation without coercing JSON strings or booleans", async () => { const setting = defineIntegerSetting({ key: "demo.threads", default: undefined, range: { min: 1, max: 8 }, env: "PI_DEMO_THREADS", }); for (const source of ["user", "project", "env", "flag"] as const) { for (const raw of [1, 8]) expect(setting.parse(raw, source)).toBe(raw); for (const raw of [ true, false, null, undefined, [], {}, 0, 9, 1.5, Number.NaN, Infinity, "", ]) expect(() => setting.parse(raw, source)).toThrow("expected an integer"); } for (const source of ["user", "project"] as const) expect(() => setting.parse("4", source)).toThrow("expected an integer"); for (const source of ["env", "flag"] as const) expect(setting.parse("4", source)).toBe(4); expect(setting.parse(undefined, "default")).toBeUndefined(); expect(await resolve(setting, {})).toEqual({ ok: true, source: "default", value: undefined, }); expect( await resolve(setting, { user: { demo: { threads: 4 } }, project: { demo: { threads: true } }, }), ).toMatchObject({ ok: false, source: "project" }); expect( await resolve(setting, { user: { demo: { threads: "4" } } }), ).toMatchObject({ ok: false, source: "user" }); }); it("validates integer declaration bounds, defaults, and step alignment", () => { const setting = defineIntegerSetting({ key: "demo.count", default: 2, range: { min: -2, max: 8, step: 2 }, }); for (const value of [-2, 0, 2, 8]) expect(setting.parse(value, "user")).toBe(value); expect(() => setting.parse(3, "user")).toThrow("steps of 2"); for (const range of [ { min: 8, max: 1 }, { min: 1.5, max: 8 }, { min: 1, max: Infinity }, { min: 1, max: 8, step: 0 }, { min: 1, max: 8, step: 1.5 }, { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER }, ]) expect(() => defineIntegerSetting({ key: "bad", default: undefined, range }), ).toThrow("Invalid integer declaration"); expect(() => defineIntegerSetting({ key: "bad", default: 9, range: { min: 1, max: 8 } }), ).toThrow("Invalid integer declaration"); }); it("ignores untrusted project objects", async () => { const result = await resolve(block, { user: { demo: { a: 1 } }, project: { demo: { a: 2 } }, trusted: false, }); expect(result).toEqual({ ok: true, source: "user", value: { a: 1 } }); }); it("reports thrown parser messages with the merged source", async () => { const result = await resolve(block, { user: { demo: { a: 1 } }, project: { demo: { bad: true } }, }); expect(result).toEqual({ ok: false, source: "project", error: "Invalid demo from merged project and user settings: demo.bad is not allowed", }); }); it("keeps a non-object project value from falling through or merging", async () => { const result = await resolve(block, { user: { demo: { a: 1 } }, project: { demo: "oops" }, }); expect(result).toEqual({ ok: false, source: "project", error: "Invalid demo from project settings", }); }); it("prefers flag, then env, over settings", async () => { const text: SettingDeclaration = { key: "demo.name", parse: (raw) => (typeof raw === "string" ? raw : undefined), default: "default", flag: { name: "demo-name", type: "string", description: "demo" }, env: "PI_DEMO_NAME", }; const settings = { user: { demo: { name: "user" } } }; expect( await resolve(text, { ...settings, env: { PI_DEMO_NAME: "env" }, flags: { "demo-name": "flag" }, }), ).toEqual({ ok: true, source: "flag", value: "flag" }); expect( await resolve(text, { ...settings, env: { PI_DEMO_NAME: "env" } }), ).toEqual({ ok: true, source: "env", value: "env" }); expect(await resolve(text, {})).toEqual({ ok: true, source: "default", value: "default", }); });