@ai-devkit/agent-manager 0.28.1 → 0.30.0

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

@@ -0,0 +1,129 @@
+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

@@ -0,0 +1 @@
+{"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.fn()\n            .mockResolvedValueOnce({ stdout: 'codex-cli 0.147.0', stderr: '' })\n            .mockResolvedValueOnce({ stdout: 'Usage: codex exec [PROMPT]\\n--json\\n- read from stdin\\nresume', stderr: '' })\n            .mockResolvedValueOnce({ stdout: 'Usage: codex exec resume [SESSION_ID] [PROMPT]\\n--json\\n- stdin', stderr: '' });\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', 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({ exec: vi.fn()\n            .mockResolvedValueOnce({ stdout: 'version', stderr: '' })\n            .mockResolvedValueOnce({ stdout: 'exec', stderr: '' })\n            .mockResolvedValueOnce({ stdout: 'resume', stderr: '' }) });\n        await expect(unsupported.validate()).rejects.toMatchObject({ code: 'CODEX_CLI_UNSUPPORTED' });\n        const missingCommands = new Probe({ exec: vi.fn()\n            .mockResolvedValueOnce({ stdout: 'version', stderr: '' })\n            .mockResolvedValueOnce({ stdout: '', stderr: '' })\n            .mockResolvedValueOnce({ stdout: '', stderr: '' }) });\n        await expect(missingCommands.validate()).rejects.toMatchObject({ code: 'CODEX_CLI_UNSUPPORTED' });\n\n        const unavailable = new Probe({ exec: vi.fn().mockRejectedValue(new Error(`bad\\0${'x'.repeat(1000)}`)) });\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.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.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({ code: 'CODEX_CLI_UNSUPPORTED' });\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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1 @@
+{"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 { cwd, repository: new DurableAgentRepository({ dbPath: path.join(root, 'agents.db'), processInspector }) };\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(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))\n            .rejects.toMatchObject({ code: 'DURABLE_AGENT_REPOSITORY' });\n        await expect(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(repository.bindProviderSession(first.id, firstRun.token, OTHER_SESSION))\n            .rejects.toMatchObject({ code: 'CODEX_SESSION_MISMATCH' });\n        await expect(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

@@ -0,0 +1,126 @@
+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

@@ -0,0 +1 @@
+{"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({ dbPath: path.join(root, 'agents.db'), processInspector });\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 { sessionId: SESSION, result: `answer:${request.prompt}`, messages: [`answer:${request.prompt}`], exitCode: 0 };\n            }),\n        };\n        const service = new CodexPrintAgentService({\n            repository, probe: { validate: vi.fn() }, runner,\n        });\n\n        const created = await service.create({ name: 'reviewer', cwd });\n        expect(created).toMatchObject({ provider: 'codex', providerSessionId: null, sessionHealth: 'uninitialized' });\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({ result: 'answer:follow up' });\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({ dbPath: path.join(root, 'agents.db'), processInspector });\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, probe: { validate: vi.fn() }, runner,\n        });\n        const created = await service.create({ name: 'reviewer', cwd });\n\n        await expect(service.send(created.id, 'secret')).rejects.toMatchObject({ code: 'CODEX_PROCESS' });\n        expect((await repository.getById(created.id))).toMatchObject({\n            providerSessionId: SESSION, state: 'degraded', 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

@@ -0,0 +1,271 @@
+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