@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/dist/__tests__/durable/CodexCliProbe.test.js

@@ -1,129 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-describe("CodexCliProbe", ()=>{
-    it("validates version, exec JSON/stdin, and resume capabilities without a model call", async ()=>{
-        const api = await import("../../index.js");
-        expect(api).toHaveProperty("CodexCliProbe");
-        const exec = vi.fn().mockResolvedValueOnce({
-            stdout: "codex-cli 0.147.0",
-            stderr: ""
-        }).mockResolvedValueOnce({
-            stdout: "Usage: codex exec [PROMPT]\n--json\n- read from stdin\nresume",
-            stderr: ""
-        }).mockResolvedValueOnce({
-            stdout: "Usage: codex exec resume [SESSION_ID] [PROMPT]\n--json\n- stdin",
-            stderr: ""
-        });
-        const Probe = api.CodexCliProbe;
-        await expect(new Probe({
-            executable: "fake-codex",
-            exec
-        }).validate()).resolves.toEqual({
-            executable: "fake-codex",
-            version: "codex-cli 0.147.0"
-        });
-        expect(exec.mock.calls).toEqual([
-            [
-                "fake-codex",
-                [
-                    "--version"
-                ]
-            ],
-            [
-                "fake-codex",
-                [
-                    "exec",
-                    "--help"
-                ]
-            ],
-            [
-                "fake-codex",
-                [
-                    "exec",
-                    "resume",
-                    "--help"
-                ]
-            ]
-        ]);
-    });
-    it("rejects unsupported and unavailable CLIs with bounded sanitized errors", async ()=>{
-        const api = await import("../../index.js");
-        const Probe = api.CodexCliProbe;
-        const unsupported = new Probe({
-            exec: vi.fn().mockResolvedValueOnce({
-                stdout: "version",
-                stderr: ""
-            }).mockResolvedValueOnce({
-                stdout: "exec",
-                stderr: ""
-            }).mockResolvedValueOnce({
-                stdout: "resume",
-                stderr: ""
-            })
-        });
-        await expect(unsupported.validate()).rejects.toMatchObject({
-            code: "CODEX_CLI_UNSUPPORTED"
-        });
-        const missingCommands = new Probe({
-            exec: vi.fn().mockResolvedValueOnce({
-                stdout: "version",
-                stderr: ""
-            }).mockResolvedValueOnce({
-                stdout: "",
-                stderr: ""
-            }).mockResolvedValueOnce({
-                stdout: "",
-                stderr: ""
-            })
-        });
-        await expect(missingCommands.validate()).rejects.toMatchObject({
-            code: "CODEX_CLI_UNSUPPORTED"
-        });
-        const unavailable = new Probe({
-            exec: vi.fn().mockRejectedValue(new Error(`bad\0${"x".repeat(1000)}`))
-        });
-        const error = await unavailable.validate().catch((value)=>value);
-        expect(error.code).toBe("CODEX_CLI_UNAVAILABLE");
-        expect(error.message).not.toContain("\0");
-        expect(error.message.length).toBeLessThan(600);
-    });
-    it("reports an empty version response as unknown", async ()=>{
-        const api = await import("../../index.js");
-        const Probe = api.CodexCliProbe;
-        const exec = vi.fn().mockResolvedValueOnce({
-            stdout: " \n",
-            stderr: ""
-        }).mockResolvedValueOnce({
-            stdout: "exec --json -",
-            stderr: ""
-        }).mockResolvedValueOnce({
-            stdout: "resume --json -",
-            stderr: ""
-        });
-        await expect(new Probe({
-            exec
-        }).validate()).resolves.toMatchObject({
-            version: "unknown"
-        });
-    });
-    it("requires a standalone stdin dash rather than accepting flag hyphens", async ()=>{
-        const api = await import("../../index.js");
-        const Probe = api.CodexCliProbe;
-        const exec = vi.fn().mockResolvedValueOnce({
-            stdout: "version",
-            stderr: ""
-        }).mockResolvedValueOnce({
-            stdout: "exec --json",
-            stderr: ""
-        }).mockResolvedValueOnce({
-            stdout: "resume --json",
-            stderr: ""
-        });
-        await expect(new Probe({
-            exec
-        }).validate()).rejects.toMatchObject({
-            code: "CODEX_CLI_UNSUPPORTED"
-        });
-    });
-});
-
-//# sourceMappingURL=CodexCliProbe.test.js.map

package/dist/__tests__/durable/CodexCliProbe.test.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/__tests__/durable/CodexCliProbe.test.ts"],"sourcesContent":["import { describe, expect, it, vi } from \"vitest\";\n\ndescribe(\"CodexCliProbe\", () => {\n  it(\"validates version, exec JSON/stdin, and resume capabilities without a model call\", async () => {\n    const api = (await import(\"../../index.js\")) as Record<string, unknown>;\n    expect(api).toHaveProperty(\"CodexCliProbe\");\n    const exec = vi\n      .fn()\n      .mockResolvedValueOnce({ stdout: \"codex-cli 0.147.0\", stderr: \"\" })\n      .mockResolvedValueOnce({\n        stdout: \"Usage: codex exec [PROMPT]\\n--json\\n- read from stdin\\nresume\",\n        stderr: \"\",\n      })\n      .mockResolvedValueOnce({\n        stdout: \"Usage: codex exec resume [SESSION_ID] [PROMPT]\\n--json\\n- stdin\",\n        stderr: \"\",\n      });\n    const Probe = api.CodexCliProbe as new (options: unknown) => any;\n\n    await expect(new Probe({ executable: \"fake-codex\", exec }).validate()).resolves.toEqual({\n      executable: \"fake-codex\",\n      version: \"codex-cli 0.147.0\",\n    });\n    expect(exec.mock.calls).toEqual([\n      [\"fake-codex\", [\"--version\"]],\n      [\"fake-codex\", [\"exec\", \"--help\"]],\n      [\"fake-codex\", [\"exec\", \"resume\", \"--help\"]],\n    ]);\n  });\n\n  it(\"rejects unsupported and unavailable CLIs with bounded sanitized errors\", async () => {\n    const api = (await import(\"../../index.js\")) as Record<string, unknown>;\n    const Probe = api.CodexCliProbe as new (options: unknown) => any;\n    const unsupported = new Probe({\n      exec: vi\n        .fn()\n        .mockResolvedValueOnce({ stdout: \"version\", stderr: \"\" })\n        .mockResolvedValueOnce({ stdout: \"exec\", stderr: \"\" })\n        .mockResolvedValueOnce({ stdout: \"resume\", stderr: \"\" }),\n    });\n    await expect(unsupported.validate()).rejects.toMatchObject({ code: \"CODEX_CLI_UNSUPPORTED\" });\n    const missingCommands = new Probe({\n      exec: vi\n        .fn()\n        .mockResolvedValueOnce({ stdout: \"version\", stderr: \"\" })\n        .mockResolvedValueOnce({ stdout: \"\", stderr: \"\" })\n        .mockResolvedValueOnce({ stdout: \"\", stderr: \"\" }),\n    });\n    await expect(missingCommands.validate()).rejects.toMatchObject({\n      code: \"CODEX_CLI_UNSUPPORTED\",\n    });\n\n    const unavailable = new Probe({\n      exec: vi.fn().mockRejectedValue(new Error(`bad\\0${\"x\".repeat(1000)}`)),\n    });\n    const error = await unavailable.validate().catch((value: Error & { code: string }) => value);\n    expect(error.code).toBe(\"CODEX_CLI_UNAVAILABLE\");\n    expect(error.message).not.toContain(\"\\0\");\n    expect(error.message.length).toBeLessThan(600);\n  });\n\n  it(\"reports an empty version response as unknown\", async () => {\n    const api = (await import(\"../../index.js\")) as Record<string, unknown>;\n    const Probe = api.CodexCliProbe as new (options: unknown) => any;\n    const exec = vi\n      .fn()\n      .mockResolvedValueOnce({ stdout: \" \\n\", stderr: \"\" })\n      .mockResolvedValueOnce({ stdout: \"exec --json -\", stderr: \"\" })\n      .mockResolvedValueOnce({ stdout: \"resume --json -\", stderr: \"\" });\n    await expect(new Probe({ exec }).validate()).resolves.toMatchObject({ version: \"unknown\" });\n  });\n\n  it(\"requires a standalone stdin dash rather than accepting flag hyphens\", async () => {\n    const api = (await import(\"../../index.js\")) as Record<string, unknown>;\n    const Probe = api.CodexCliProbe as new (options: unknown) => any;\n    const exec = vi\n      .fn()\n      .mockResolvedValueOnce({ stdout: \"version\", stderr: \"\" })\n      .mockResolvedValueOnce({ stdout: \"exec --json\", stderr: \"\" })\n      .mockResolvedValueOnce({ stdout: \"resume --json\", stderr: \"\" });\n    await expect(new Probe({ exec }).validate()).rejects.toMatchObject({\n      code: \"CODEX_CLI_UNSUPPORTED\",\n    });\n  });\n});\n"],"names":["describe","expect","it","vi","api","toHaveProperty","exec","fn","mockResolvedValueOnce","stdout","stderr","Probe","CodexCliProbe","executable","validate","resolves","toEqual","version","mock","calls","unsupported","rejects","toMatchObject","code","missingCommands","unavailable","mockRejectedValue","Error","repeat","error","catch","value","toBe","message","not","toContain","length","toBeLessThan"],"mappings":"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"}

package/dist/__tests__/durable/CodexDurableAgentRepository.test.js

@@ -1,84 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { DurableAgentRepository } from "../../durable/DurableAgentRepository.js";
-const SESSION = "22222222-2222-4222-8222-222222222222";
-const OTHER_SESSION = "33333333-3333-4333-8333-333333333333";
-const roots = [];
-afterEach(()=>{
-    for (const root of roots.splice(0))fs.rmSync(root, {
-        recursive: true,
-        force: true
-    });
-});
-function fixture() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-durable-repository-"));
-    roots.push(root);
-    const cwd = path.join(root, "project");
-    fs.mkdirSync(cwd);
-    const processInspector = {
-        getIdentity: (pid)=>({
-                pid,
-                startedAt: "owner-start"
-            })
-    };
-    return {
-        cwd,
-        repository: new DurableAgentRepository({
-            dbPath: path.join(root, "agents.db"),
-            processInspector
-        })
-    };
-}
-describe("Codex durable-agent repository binding", ()=>{
-    it("creates Codex agents unbound and binds during the owned run", async ()=>{
-        const { cwd, repository } = fixture();
-        const agent = await repository.create({
-            name: "reviewer",
-            cwd,
-            provider: "codex"
-        });
-        expect(agent).toMatchObject({
-            provider: "codex",
-            mode: "durable",
-            providerSessionId: null
-        });
-        const run = await repository.acquireRun(agent.id);
-        const bound = await repository.bindProviderSession(agent.id, run.token, SESSION);
-        expect(bound.providerSessionId).toBe(SESSION);
-        await expect(repository.bindProviderSession(agent.id, run.token, SESSION)).resolves.toMatchObject({
-            providerSessionId: SESSION
-        });
-    });
-    it("rejects invalid, stale, replacement, and duplicate bindings", async ()=>{
-        const { cwd, repository } = fixture();
-        const first = await repository.create({
-            name: "first",
-            cwd,
-            provider: "codex"
-        });
-        const second = await repository.create({
-            name: "second",
-            cwd,
-            provider: "codex"
-        });
-        const firstRun = await repository.acquireRun(first.id);
-        const secondRun = await repository.acquireRun(second.id);
-        await expect(repository.bindProviderSession(first.id, "stale", SESSION)).rejects.toMatchObject({
-            code: "DURABLE_AGENT_REPOSITORY"
-        });
-        await expect(repository.bindProviderSession(first.id, firstRun.token, "invalid")).rejects.toMatchObject({
-            code: "DURABLE_AGENT_REPOSITORY"
-        });
-        await repository.bindProviderSession(first.id, firstRun.token, SESSION);
-        await expect(repository.bindProviderSession(first.id, firstRun.token, OTHER_SESSION)).rejects.toMatchObject({
-            code: "CODEX_SESSION_MISMATCH"
-        });
-        await expect(repository.bindProviderSession(second.id, secondRun.token, SESSION)).rejects.toMatchObject({
-            code: "CODEX_SESSION_MISMATCH"
-        });
-    });
-});
-
-//# sourceMappingURL=CodexDurableAgentRepository.test.js.map

package/dist/__tests__/durable/CodexDurableAgentRepository.test.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/__tests__/durable/CodexDurableAgentRepository.test.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport os from \"node:os\";\nimport path from \"node:path\";\nimport { afterEach, describe, expect, it } from \"vitest\";\nimport { DurableAgentRepository } from \"../../durable/DurableAgentRepository.js\";\n\nconst SESSION = \"22222222-2222-4222-8222-222222222222\";\nconst OTHER_SESSION = \"33333333-3333-4333-8333-333333333333\";\nconst roots: string[] = [];\n\nafterEach(() => {\n  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });\n});\n\nfunction fixture() {\n  const root = fs.mkdtempSync(path.join(os.tmpdir(), \"codex-durable-repository-\"));\n  roots.push(root);\n  const cwd = path.join(root, \"project\");\n  fs.mkdirSync(cwd);\n  const processInspector = { getIdentity: (pid: number) => ({ pid, startedAt: \"owner-start\" }) };\n  return {\n    cwd,\n    repository: new DurableAgentRepository({\n      dbPath: path.join(root, \"agents.db\"),\n      processInspector,\n    }),\n  };\n}\n\ndescribe(\"Codex durable-agent repository binding\", () => {\n  it(\"creates Codex agents unbound and binds during the owned run\", async () => {\n    const { cwd, repository } = fixture();\n    const agent = await repository.create({ name: \"reviewer\", cwd, provider: \"codex\" });\n    expect(agent).toMatchObject({ provider: \"codex\", mode: \"durable\", providerSessionId: null });\n\n    const run = await repository.acquireRun(agent.id);\n    const bound = await repository.bindProviderSession(agent.id, run.token, SESSION);\n    expect(bound.providerSessionId).toBe(SESSION);\n    await expect(\n      repository.bindProviderSession(agent.id, run.token, SESSION),\n    ).resolves.toMatchObject({ providerSessionId: SESSION });\n  });\n\n  it(\"rejects invalid, stale, replacement, and duplicate bindings\", async () => {\n    const { cwd, repository } = fixture();\n    const first = await repository.create({ name: \"first\", cwd, provider: \"codex\" });\n    const second = await repository.create({ name: \"second\", cwd, provider: \"codex\" });\n    const firstRun = await repository.acquireRun(first.id);\n    const secondRun = await repository.acquireRun(second.id);\n\n    await expect(repository.bindProviderSession(first.id, \"stale\", SESSION)).rejects.toMatchObject({\n      code: \"DURABLE_AGENT_REPOSITORY\",\n    });\n    await expect(\n      repository.bindProviderSession(first.id, firstRun.token, \"invalid\"),\n    ).rejects.toMatchObject({ code: \"DURABLE_AGENT_REPOSITORY\" });\n    await repository.bindProviderSession(first.id, firstRun.token, SESSION);\n    await expect(\n      repository.bindProviderSession(first.id, firstRun.token, OTHER_SESSION),\n    ).rejects.toMatchObject({ code: \"CODEX_SESSION_MISMATCH\" });\n    await expect(\n      repository.bindProviderSession(second.id, secondRun.token, SESSION),\n    ).rejects.toMatchObject({ code: \"CODEX_SESSION_MISMATCH\" });\n  });\n});\n"],"names":["fs","os","path","afterEach","describe","expect","it","DurableAgentRepository","SESSION","OTHER_SESSION","roots","root","splice","rmSync","recursive","force","fixture","mkdtempSync","join","tmpdir","push","cwd","mkdirSync","processInspector","getIdentity","pid","startedAt","repository","dbPath","agent","create","name","provider","toMatchObject","mode","providerSessionId","run","acquireRun","id","bound","bindProviderSession","token","toBe","resolves","first","second","firstRun","secondRun","rejects","code"],"mappings":"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"}

package/dist/__tests__/durable/CodexPrintAgent.integration.test.js

@@ -1,126 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { CodexPrintError, CodexPrintAgentService, DurableAgentRepository } from "../../index.js";
-const SESSION = "22222222-2222-4222-8222-222222222222";
-const roots = [];
-afterEach(()=>{
-    for (const root of roots.splice(0))fs.rmSync(root, {
-        recursive: true,
-        force: true
-    });
-});
-describe("Codex print-agent fake-provider journey", ()=>{
-    it("creates unbound, then binds and explicitly resumes the provider-minted session", async ()=>{
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-print-integration-"));
-        roots.push(root);
-        const cwd = path.join(root, "project");
-        fs.mkdirSync(cwd);
-        const processInspector = {
-            getIdentity: (pid)=>({
-                    pid,
-                    startedAt: `process-${pid}`
-                })
-        };
-        const repository = new DurableAgentRepository({
-            dbPath: path.join(root, "agents.db"),
-            processInspector
-        });
-        const runner = {
-            run: vi.fn().mockImplementation(async (request)=>{
-                await request.onSpawn({
-                    pid: 42,
-                    startedAt: "process-42"
-                });
-                await request.onSession(SESSION);
-                return {
-                    sessionId: SESSION,
-                    result: `answer:${request.prompt}`,
-                    messages: [
-                        `answer:${request.prompt}`
-                    ],
-                    exitCode: 0
-                };
-            })
-        };
-        const service = new CodexPrintAgentService({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner
-        });
-        const created = await service.create({
-            name: "reviewer",
-            cwd
-        });
-        expect(created).toMatchObject({
-            provider: "codex",
-            providerSessionId: null,
-            sessionHealth: "uninitialized"
-        });
-        const first = await service.send(created.id, "first secret");
-        expect(first).toMatchObject({
-            result: "answer:first secret"
-        });
-        const bound = await repository.getById(created.id);
-        expect(bound?.providerSessionId).toBe(first.sessionId);
-        await expect(service.send(created.id, "follow up")).resolves.toMatchObject({
-            result: "answer:follow up"
-        });
-        expect(runner.run.mock.calls[0][0].agent).toMatchObject({
-            providerSessionId: null
-        });
-        expect(runner.run.mock.calls[1][0].agent).toMatchObject({
-            providerSessionId: SESSION
-        });
-    });
-    it("retains a first-run binding when the provider fails after thread start", async ()=>{
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), "codex-print-bind-failure-"));
-        roots.push(root);
-        const cwd = path.join(root, "project");
-        fs.mkdirSync(cwd);
-        const processInspector = {
-            getIdentity: (pid)=>({
-                    pid,
-                    startedAt: `process-${pid}`
-                })
-        };
-        const repository = new DurableAgentRepository({
-            dbPath: path.join(root, "agents.db"),
-            processInspector
-        });
-        const runner = {
-            run: vi.fn().mockImplementation(async (request)=>{
-                await request.onSpawn({
-                    pid: 42,
-                    startedAt: "process-42"
-                });
-                await request.onSession(SESSION);
-                throw new CodexPrintError("Codex print run failed.", "CODEX_PROCESS");
-            })
-        };
-        const service = new CodexPrintAgentService({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner
-        });
-        const created = await service.create({
-            name: "reviewer",
-            cwd
-        });
-        await expect(service.send(created.id, "secret")).rejects.toMatchObject({
-            code: "CODEX_PROCESS"
-        });
-        expect(await repository.getById(created.id)).toMatchObject({
-            providerSessionId: SESSION,
-            state: "degraded",
-            sessionHealth: "unknown"
-        });
-    });
-});
-
-//# sourceMappingURL=CodexPrintAgent.integration.test.js.map

package/dist/__tests__/durable/CodexPrintAgent.integration.test.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/__tests__/durable/CodexPrintAgent.integration.test.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport os from \"node:os\";\nimport path from \"node:path\";\nimport { afterEach, describe, expect, it, vi } from \"vitest\";\nimport {\n  CodexPrintError,\n  CodexPrintAgentService,\n  DurableAgentRepository,\n  type ProcessInspector,\n} from \"../../index.js\";\n\nconst SESSION = \"22222222-2222-4222-8222-222222222222\";\nconst roots: string[] = [];\n\nafterEach(() => {\n  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });\n});\n\ndescribe(\"Codex print-agent fake-provider journey\", () => {\n  it(\"creates unbound, then binds and explicitly resumes the provider-minted session\", async () => {\n    const root = fs.mkdtempSync(path.join(os.tmpdir(), \"codex-print-integration-\"));\n    roots.push(root);\n    const cwd = path.join(root, \"project\");\n    fs.mkdirSync(cwd);\n    const processInspector: ProcessInspector = {\n      getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),\n    };\n    const repository = new DurableAgentRepository({\n      dbPath: path.join(root, \"agents.db\"),\n      processInspector,\n    });\n    const runner = {\n      run: vi.fn().mockImplementation(async (request) => {\n        await request.onSpawn({ pid: 42, startedAt: \"process-42\" });\n        await request.onSession(SESSION);\n        return {\n          sessionId: SESSION,\n          result: `answer:${request.prompt}`,\n          messages: [`answer:${request.prompt}`],\n          exitCode: 0,\n        };\n      }),\n    };\n    const service = new CodexPrintAgentService({\n      repository,\n      probe: { validate: vi.fn() },\n      runner,\n    });\n\n    const created = await service.create({ name: \"reviewer\", cwd });\n    expect(created).toMatchObject({\n      provider: \"codex\",\n      providerSessionId: null,\n      sessionHealth: \"uninitialized\",\n    });\n\n    const first = await service.send(created.id, \"first secret\");\n    expect(first).toMatchObject({ result: \"answer:first secret\" });\n    const bound = await repository.getById(created.id);\n    expect(bound?.providerSessionId).toBe(first.sessionId);\n    await expect(service.send(created.id, \"follow up\")).resolves.toMatchObject({\n      result: \"answer:follow up\",\n    });\n\n    expect(runner.run.mock.calls[0][0].agent).toMatchObject({ providerSessionId: null });\n    expect(runner.run.mock.calls[1][0].agent).toMatchObject({ providerSessionId: SESSION });\n  });\n\n  it(\"retains a first-run binding when the provider fails after thread start\", async () => {\n    const root = fs.mkdtempSync(path.join(os.tmpdir(), \"codex-print-bind-failure-\"));\n    roots.push(root);\n    const cwd = path.join(root, \"project\");\n    fs.mkdirSync(cwd);\n    const processInspector: ProcessInspector = {\n      getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),\n    };\n    const repository = new DurableAgentRepository({\n      dbPath: path.join(root, \"agents.db\"),\n      processInspector,\n    });\n    const runner = {\n      run: vi.fn().mockImplementation(async (request) => {\n        await request.onSpawn({ pid: 42, startedAt: \"process-42\" });\n        await request.onSession(SESSION);\n        throw new CodexPrintError(\"Codex print run failed.\", \"CODEX_PROCESS\");\n      }),\n    };\n    const service = new CodexPrintAgentService({\n      repository,\n      probe: { validate: vi.fn() },\n      runner,\n    });\n    const created = await service.create({ name: \"reviewer\", cwd });\n\n    await expect(service.send(created.id, \"secret\")).rejects.toMatchObject({\n      code: \"CODEX_PROCESS\",\n    });\n    expect(await repository.getById(created.id)).toMatchObject({\n      providerSessionId: SESSION,\n      state: \"degraded\",\n      sessionHealth: \"unknown\",\n    });\n  });\n});\n"],"names":["fs","os","path","afterEach","describe","expect","it","vi","CodexPrintError","CodexPrintAgentService","DurableAgentRepository","SESSION","roots","root","splice","rmSync","recursive","force","mkdtempSync","join","tmpdir","push","cwd","mkdirSync","processInspector","getIdentity","pid","startedAt","repository","dbPath","runner","run","fn","mockImplementation","request","onSpawn","onSession","sessionId","result","prompt","messages","exitCode","service","probe","validate","created","create","name","toMatchObject","provider","providerSessionId","sessionHealth","first","send","id","bound","getById","toBe","resolves","mock","calls","agent","rejects","code","state"],"mappings":"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"}

package/dist/__tests__/durable/CodexPrintAgentService.test.js

@@ -1,271 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-const SESSION = "22222222-2222-4222-8222-222222222222";
-const base = {
-    id: "id",
-    name: "reviewer",
-    provider: "codex",
-    providerSessionId: null,
-    sessionHealth: "uninitialized"
-};
-describe("CodexPrintAgentService", ()=>{
-    it("constructs default non-billable dependencies without invoking them", async ()=>{
-        const api = await import("../../index.js");
-        const Service = api.CodexPrintAgentService;
-        expect(new Service().repository).toBeDefined();
-    });
-    it("validates before provider-aware create and never runs Codex", async ()=>{
-        const api = await import("../../index.js");
-        expect(api).toHaveProperty("CodexPrintAgentService");
-        const probe = {
-            validate: vi.fn().mockResolvedValue({
-                executable: "codex",
-                version: "0.147.0"
-            })
-        };
-        const repository = {
-            create: vi.fn().mockResolvedValue(base),
-            list: vi.fn()
-        };
-        const runner = {
-            run: vi.fn()
-        };
-        const Service = api.CodexPrintAgentService;
-        await new Service({
-            repository,
-            probe,
-            runner
-        }).create({
-            name: "reviewer",
-            cwd: "/project"
-        });
-        expect(repository.create).toHaveBeenCalledWith({
-            name: "reviewer",
-            cwd: "/project",
-            provider: "codex"
-        });
-        expect(runner.run).not.toHaveBeenCalled();
-    });
-    it("binds during first send and explicitly resumes later sends", async ()=>{
-        const api = await import("../../index.js");
-        const repository = {
-            list: vi.fn(),
-            resolve: vi.fn().mockResolvedValue(base),
-            acquireRun: vi.fn().mockResolvedValueOnce({
-                agent: base,
-                token: "one"
-            }).mockResolvedValueOnce({
-                agent: {
-                    ...base,
-                    providerSessionId: SESSION,
-                    sessionHealth: "healthy"
-                },
-                token: "two"
-            }),
-            recordProviderProcess: vi.fn(),
-            bindProviderSession: vi.fn(),
-            completeRun: vi.fn()
-        };
-        const runner = {
-            run: vi.fn().mockImplementation(async (request)=>{
-                await request.onSpawn({
-                    pid: 42,
-                    startedAt: "start"
-                });
-                await request.onSession(SESSION);
-                return {
-                    sessionId: SESSION,
-                    result: "answer",
-                    messages: [
-                        "answer"
-                    ],
-                    exitCode: 0
-                };
-            })
-        };
-        const Service = api.CodexPrintAgentService;
-        const service = new Service({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner,
-            executable: "fake-codex"
-        });
-        await service.send("reviewer", "first");
-        await service.send("reviewer", "later");
-        expect(repository.bindProviderSession).toHaveBeenNthCalledWith(1, "id", "one", SESSION);
-        expect(repository.bindProviderSession).toHaveBeenNthCalledWith(2, "id", "two", SESSION);
-        expect(repository.completeRun).toHaveBeenCalledWith("id", "one", expect.objectContaining({
-            status: "succeeded",
-            sessionHealth: "healthy"
-        }));
-    });
-    it("records mismatch separately from unknown failures", async ()=>{
-        const api = await import("../../index.js");
-        const ErrorType = api.CodexPrintError;
-        const completeRun = vi.fn();
-        const repository = {
-            list: vi.fn(),
-            resolve: vi.fn().mockResolvedValue(base),
-            acquireRun: vi.fn().mockResolvedValue({
-                agent: base,
-                token: "one"
-            }),
-            recordProviderProcess: vi.fn(),
-            bindProviderSession: vi.fn(),
-            completeRun
-        };
-        const Service = api.CodexPrintAgentService;
-        const service = new Service({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner: {
-                run: vi.fn().mockRejectedValue(new ErrorType("mismatch", "CODEX_SESSION_MISMATCH"))
-            }
-        });
-        await expect(service.send("reviewer", "x")).rejects.toMatchObject({
-            code: "CODEX_SESSION_MISMATCH"
-        });
-        expect(completeRun).toHaveBeenCalledWith("id", "one", expect.objectContaining({
-            sessionHealth: "mismatch"
-        }));
-    });
-    it("rejects a non-Codex target without acquiring or mutating it", async ()=>{
-        const api = await import("../../index.js");
-        const Service = api.CodexPrintAgentService;
-        const repository = {
-            resolve: vi.fn().mockResolvedValue({
-                ...base,
-                provider: "claude"
-            }),
-            acquireRun: vi.fn(),
-            recordProviderProcess: vi.fn(),
-            bindProviderSession: vi.fn(),
-            completeRun: vi.fn()
-        };
-        await expect(new Service({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner: {
-                run: vi.fn()
-            }
-        }).send("reviewer", "x")).rejects.toMatchObject({
-            code: "CODEX_UNSUPPORTED"
-        });
-        expect(repository.acquireRun).not.toHaveBeenCalled();
-        expect(repository.completeRun).not.toHaveBeenCalled();
-    });
-    it("does not turn a successful completion write failure into a second completion", async ()=>{
-        const api = await import("../../index.js");
-        const Service = api.CodexPrintAgentService;
-        const completionFailure = new Error("completion failed");
-        const repository = {
-            resolve: vi.fn().mockResolvedValue(base),
-            acquireRun: vi.fn().mockResolvedValue({
-                agent: base,
-                token: "one"
-            }),
-            recordProviderProcess: vi.fn(),
-            bindProviderSession: vi.fn(),
-            completeRun: vi.fn().mockRejectedValue(completionFailure)
-        };
-        const runner = {
-            run: vi.fn().mockResolvedValue({
-                sessionId: SESSION,
-                result: "answer",
-                messages: [
-                    "answer"
-                ],
-                exitCode: 0
-            })
-        };
-        await expect(new Service({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner
-        }).send("reviewer", "x")).rejects.toBe(completionFailure);
-        expect(repository.completeRun).toHaveBeenCalledOnce();
-    });
-    it("records a repository binding conflict as a session mismatch", async ()=>{
-        const api = await import("../../index.js");
-        const BindingError = api.CodexPrintError;
-        const completeRun = vi.fn();
-        const repository = {
-            list: vi.fn(),
-            resolve: vi.fn().mockResolvedValue(base),
-            acquireRun: vi.fn().mockResolvedValue({
-                agent: base,
-                token: "one"
-            }),
-            recordProviderProcess: vi.fn(),
-            bindProviderSession: vi.fn().mockRejectedValue(new BindingError("binding mismatch", "CODEX_SESSION_MISMATCH")),
-            completeRun
-        };
-        const runner = {
-            run: vi.fn().mockImplementation(async (request)=>{
-                await request.onSession(SESSION);
-                return {
-                    sessionId: SESSION,
-                    result: "x",
-                    messages: [
-                        "x"
-                    ],
-                    exitCode: 0
-                };
-            })
-        };
-        const Service = api.CodexPrintAgentService;
-        await expect(new Service({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner
-        }).send("reviewer", "x")).rejects.toMatchObject({
-            code: "CODEX_SESSION_MISMATCH"
-        });
-        expect(completeRun).toHaveBeenCalledWith("id", "one", expect.objectContaining({
-            sessionHealth: "mismatch"
-        }));
-    });
-    it("rejects missing and ambiguous records before acquiring a run", async ()=>{
-        const api = await import("../../index.js");
-        const Service = api.CodexPrintAgentService;
-        const repository = {
-            list: vi.fn(),
-            create: vi.fn(),
-            resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([
-                base,
-                base
-            ]),
-            acquireRun: vi.fn(),
-            recordProviderProcess: vi.fn(),
-            bindProviderSession: vi.fn(),
-            completeRun: vi.fn()
-        };
-        const service = new Service({
-            repository,
-            probe: {
-                validate: vi.fn()
-            },
-            runner: {
-                run: vi.fn()
-            }
-        });
-        await expect(service.send("missing", "x")).rejects.toMatchObject({
-            code: "DURABLE_AGENT_NOT_FOUND"
-        });
-        await expect(service.send("ambiguous", "x")).rejects.toMatchObject({
-            code: "CODEX_UNSUPPORTED"
-        });
-        expect(repository.acquireRun).not.toHaveBeenCalled();
-    });
-});
-
-//# sourceMappingURL=CodexPrintAgentService.test.js.map