@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/dist/__tests__/harnesses/codex/CodexSessionMapping.test.js

@@ -0,0 +1,86 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { CodexSessionMapping } from "../../../harnesses/codex/CodexSessionMapping.js";
+describe("CodexSessionMapping", ()=>{
+    let tmpDir;
+    let sessionsDir;
+    let mappingPath;
+    let processInfo;
+    beforeEach(()=>{
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-mapping-"));
+        sessionsDir = path.join(tmpDir, ".codex", "sessions");
+        mappingPath = path.join(tmpDir, ".codex", "ai-devkit", "sessions.json");
+        processInfo = {
+            pid: 5151,
+            command: "codex",
+            cwd: "/repo",
+            tty: "ttys001"
+        };
+    });
+    afterEach(()=>{
+        fs.rmSync(tmpDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("matches a process to an existing trusted session file", ()=>{
+        const sessionFile = path.join(sessionsDir, "2026", "06", "26", "session.jsonl");
+        fs.mkdirSync(path.dirname(sessionFile), {
+            recursive: true
+        });
+        fs.mkdirSync(path.dirname(mappingPath), {
+            recursive: true
+        });
+        fs.writeFileSync(sessionFile, "");
+        fs.writeFileSync(mappingPath, JSON.stringify({
+            5151: sessionFile
+        }));
+        expect(createMapping().match([
+            processInfo
+        ])).toEqual({
+            matches: [
+                {
+                    process: processInfo,
+                    filePath: sessionFile
+                }
+            ],
+            fallback: []
+        });
+    });
+    it("falls back for malformed mappings, missing files, invalid pids, and untrusted paths", ()=>{
+        fs.mkdirSync(path.dirname(mappingPath), {
+            recursive: true
+        });
+        fs.writeFileSync(mappingPath, JSON.stringify({
+            invalid: path.join(sessionsDir, "ignored.jsonl"),
+            5151: path.join(tmpDir, "outside.jsonl"),
+            9999: path.join(sessionsDir, "missing.jsonl")
+        }));
+        expect(createMapping().match([
+            processInfo
+        ])).toEqual({
+            matches: [],
+            fallback: [
+                processInfo
+            ]
+        });
+        fs.writeFileSync(mappingPath, "{not-json");
+        expect(createMapping().match([
+            processInfo
+        ])).toEqual({
+            matches: [],
+            fallback: [
+                processInfo
+            ]
+        });
+    });
+    function createMapping() {
+        return new CodexSessionMapping({
+            mappingPath,
+            sessionsDir
+        });
+    }
+});
+
+//# sourceMappingURL=CodexSessionMapping.test.js.map

package/dist/__tests__/harnesses/codex/CodexSessionMapping.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/__tests__/harnesses/codex/CodexSessionMapping.test.ts"],"sourcesContent":["import * as fs from \"fs\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport type { ProcessInfo } from \"../../../adapters/AgentAdapter.js\";\nimport { CodexSessionMapping } from \"../../../harnesses/codex/CodexSessionMapping.js\";\n\ndescribe(\"CodexSessionMapping\", () => {\n  let tmpDir: string;\n  let sessionsDir: string;\n  let mappingPath: string;\n  let processInfo: ProcessInfo;\n\n  beforeEach(() => {\n    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), \"codex-mapping-\"));\n    sessionsDir = path.join(tmpDir, \".codex\", \"sessions\");\n    mappingPath = path.join(tmpDir, \".codex\", \"ai-devkit\", \"sessions.json\");\n    processInfo = { pid: 5151, command: \"codex\", cwd: \"/repo\", tty: \"ttys001\" };\n  });\n\n  afterEach(() => {\n    fs.rmSync(tmpDir, { recursive: true, force: true });\n  });\n\n  it(\"matches a process to an existing trusted session file\", () => {\n    const sessionFile = path.join(sessionsDir, \"2026\", \"06\", \"26\", \"session.jsonl\");\n    fs.mkdirSync(path.dirname(sessionFile), { recursive: true });\n    fs.mkdirSync(path.dirname(mappingPath), { recursive: true });\n    fs.writeFileSync(sessionFile, \"\");\n    fs.writeFileSync(mappingPath, JSON.stringify({ 5151: sessionFile }));\n\n    expect(createMapping().match([processInfo])).toEqual({\n      matches: [{ process: processInfo, filePath: sessionFile }],\n      fallback: [],\n    });\n  });\n\n  it(\"falls back for malformed mappings, missing files, invalid pids, and untrusted paths\", () => {\n    fs.mkdirSync(path.dirname(mappingPath), { recursive: true });\n    fs.writeFileSync(\n      mappingPath,\n      JSON.stringify({\n        invalid: path.join(sessionsDir, \"ignored.jsonl\"),\n        5151: path.join(tmpDir, \"outside.jsonl\"),\n        9999: path.join(sessionsDir, \"missing.jsonl\"),\n      }),\n    );\n\n    expect(createMapping().match([processInfo])).toEqual({\n      matches: [],\n      fallback: [processInfo],\n    });\n\n    fs.writeFileSync(mappingPath, \"{not-json\");\n    expect(createMapping().match([processInfo])).toEqual({\n      matches: [],\n      fallback: [processInfo],\n    });\n  });\n\n  function createMapping(): CodexSessionMapping {\n    return new CodexSessionMapping({ mappingPath, sessionsDir });\n  }\n});\n"],"names":["fs","os","path","CodexSessionMapping","describe","tmpDir","sessionsDir","mappingPath","processInfo","beforeEach","mkdtempSync","join","tmpdir","pid","command","cwd","tty","afterEach","rmSync","recursive","force","it","sessionFile","mkdirSync","dirname","writeFileSync","JSON","stringify","expect","createMapping","match","toEqual","matches","process","filePath","fallback","invalid"],"mappings":"AAAA,YAAYA,QAAQ,KAAK;AACzB,YAAYC,QAAQ,KAAK;AACzB,YAAYC,UAAU,OAAO;AAE7B,SAASC,mBAAmB,QAAQ,kDAAkD;AAEtFC,SAAS,uBAAuB;IAC9B,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IAEJC,WAAW;QACTJ,SAASL,GAAGU,WAAW,CAACR,KAAKS,IAAI,CAACV,GAAGW,MAAM,IAAI;QAC/CN,cAAcJ,KAAKS,IAAI,CAACN,QAAQ,UAAU;QAC1CE,cAAcL,KAAKS,IAAI,CAACN,QAAQ,UAAU,aAAa;QACvDG,cAAc;YAAEK,KAAK;YAAMC,SAAS;YAASC,KAAK;YAASC,KAAK;QAAU;IAC5E;IAEAC,UAAU;QACRjB,GAAGkB,MAAM,CAACb,QAAQ;YAAEc,WAAW;YAAMC,OAAO;QAAK;IACnD;IAEAC,GAAG,yDAAyD;QAC1D,MAAMC,cAAcpB,KAAKS,IAAI,CAACL,aAAa,QAAQ,MAAM,MAAM;QAC/DN,GAAGuB,SAAS,CAACrB,KAAKsB,OAAO,CAACF,cAAc;YAAEH,WAAW;QAAK;QAC1DnB,GAAGuB,SAAS,CAACrB,KAAKsB,OAAO,CAACjB,cAAc;YAAEY,WAAW;QAAK;QAC1DnB,GAAGyB,aAAa,CAACH,aAAa;QAC9BtB,GAAGyB,aAAa,CAAClB,aAAamB,KAAKC,SAAS,CAAC;YAAE,MAAML;QAAY;QAEjEM,OAAOC,gBAAgBC,KAAK,CAAC;YAACtB;SAAY,GAAGuB,OAAO,CAAC;YACnDC,SAAS;gBAAC;oBAAEC,SAASzB;oBAAa0B,UAAUZ;gBAAY;aAAE;YAC1Da,UAAU,EAAE;QACd;IACF;IAEAd,GAAG,uFAAuF;QACxFrB,GAAGuB,SAAS,CAACrB,KAAKsB,OAAO,CAACjB,cAAc;YAAEY,WAAW;QAAK;QAC1DnB,GAAGyB,aAAa,CACdlB,aACAmB,KAAKC,SAAS,CAAC;YACbS,SAASlC,KAAKS,IAAI,CAACL,aAAa;YAChC,MAAMJ,KAAKS,IAAI,CAACN,QAAQ;YACxB,MAAMH,KAAKS,IAAI,CAACL,aAAa;QAC/B;QAGFsB,OAAOC,gBAAgBC,KAAK,CAAC;YAACtB;SAAY,GAAGuB,OAAO,CAAC;YACnDC,SAAS,EAAE;YACXG,UAAU;gBAAC3B;aAAY;QACzB;QAEAR,GAAGyB,aAAa,CAAClB,aAAa;QAC9BqB,OAAOC,gBAAgBC,KAAK,CAAC;YAACtB;SAAY,GAAGuB,OAAO,CAAC;YACnDC,SAAS,EAAE;YACXG,UAAU;gBAAC3B;aAAY;QACzB;IACF;IAEA,SAASqB;QACP,OAAO,IAAI1B,oBAAoB;YAAEI;YAAaD;QAAY;IAC5D;AACF"}

package/dist/__tests__/harnesses/codex/CodexSessionParser.test.js

@@ -0,0 +1,254 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import { CodexSessionParser } from "../../../harnesses/codex/CodexSessionParser.js";
+describe("CodexSessionParser", ()=>{
+    let tmpDir;
+    let parser;
+    beforeEach(()=>{
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-parser-"));
+        parser = new CodexSessionParser();
+    });
+    afterEach(()=>{
+        fs.rmSync(tmpDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("reads session metadata, summary, timestamps, and status signal", ()=>{
+        const filePath = writeJsonl("session.jsonl", [
+            {
+                type: "session_meta",
+                payload: {
+                    id: "sess-1",
+                    timestamp: "2026-03-18T15:00:00Z",
+                    cwd: "/repo"
+                }
+            },
+            {
+                type: "event",
+                timestamp: "2026-03-18T15:01:00Z",
+                payload: {
+                    type: "agent_reasoning",
+                    message: "Working on feature"
+                }
+            }
+        ]);
+        const session = parser.readSession(filePath);
+        expect(session).toMatchObject({
+            sessionId: "sess-1",
+            projectPath: "/repo",
+            summary: "Working on feature",
+            lastPayloadType: "agent_reasoning"
+        });
+        expect(session?.sessionStart.toISOString()).toBe("2026-03-18T15:00:00.000Z");
+        expect(parser.determineStatus(session)).toBe(AgentStatus.IDLE);
+    });
+    it("reads current response_item and event_msg messages without mirrored duplicates", ()=>{
+        const filePath = writeJsonl("conversation.jsonl", [
+            {
+                type: "session_meta",
+                payload: {
+                    id: "sess-1",
+                    cwd: "/repo",
+                    timestamp: "2026-03-27T10:00:00Z"
+                }
+            },
+            {
+                type: "response_item",
+                timestamp: "2026-03-27T10:00:01Z",
+                payload: {
+                    type: "message",
+                    role: "user",
+                    content: [
+                        {
+                            type: "input_text",
+                            text: "Fix the bug"
+                        }
+                    ],
+                    internal_chat_message_metadata_passthrough: {
+                        turn_id: "turn-1"
+                    }
+                }
+            },
+            {
+                type: "event_msg",
+                timestamp: "2026-03-27T10:00:01.001Z",
+                payload: {
+                    type: "item_completed",
+                    turn_id: "turn-1",
+                    item: {
+                        type: "UserMessage",
+                        content: [
+                            {
+                                type: "text",
+                                text: "Fix the bug"
+                            }
+                        ]
+                    }
+                }
+            },
+            {
+                type: "event_msg",
+                timestamp: "2026-03-27T10:00:05Z",
+                payload: {
+                    type: "item_completed",
+                    turn_id: "turn-1",
+                    item: {
+                        type: "AgentMessage",
+                        content: [
+                            {
+                                type: "Text",
+                                text: "I found the issue"
+                            }
+                        ]
+                    }
+                }
+            },
+            {
+                type: "response_item",
+                timestamp: "2026-03-27T10:00:05.005Z",
+                payload: {
+                    type: "message",
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "output_text",
+                            text: "I found the issue"
+                        }
+                    ],
+                    internal_chat_message_metadata_passthrough: {
+                        turn_id: "turn-1"
+                    }
+                }
+            }
+        ]);
+        expect(parser.getConversation(filePath)).toEqual([
+            {
+                role: "user",
+                content: "Fix the bug",
+                timestamp: "2026-03-27T10:00:01Z"
+            },
+            {
+                role: "assistant",
+                content: "I found the issue",
+                timestamp: "2026-03-27T10:00:05.005Z"
+            }
+        ]);
+    });
+    it("maps completed assistant messages as waiting while recent active events stay running", ()=>{
+        const waiting = parser.readSession("unused.jsonl", [
+            JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: "waiting",
+                    timestamp: new Date().toISOString(),
+                    cwd: "/repo"
+                }
+            }),
+            JSON.stringify({
+                type: "event_msg",
+                timestamp: new Date().toISOString(),
+                payload: {
+                    type: "item_completed",
+                    item: {
+                        type: "AgentMessage",
+                        content: [
+                            {
+                                type: "Text",
+                                text: "Waiting for the user now"
+                            }
+                        ]
+                    }
+                }
+            })
+        ].join("\n"));
+        const running = parser.readSession("unused.jsonl", [
+            JSON.stringify({
+                type: "session_meta",
+                payload: {
+                    id: "running",
+                    timestamp: new Date().toISOString(),
+                    cwd: "/repo"
+                }
+            }),
+            JSON.stringify({
+                type: "event",
+                timestamp: new Date().toISOString(),
+                payload: {
+                    type: "token_count",
+                    message: "Working"
+                }
+            })
+        ].join("\n"));
+        expect(waiting?.summary).toBe("Waiting for the user now");
+        expect(parser.determineStatus(waiting)).toBe(AgentStatus.WAITING);
+        expect(parser.determineStatus(running)).toBe(AgentStatus.RUNNING);
+    });
+    it("builds historical summaries from the first non-synthetic user message", ()=>{
+        const filePath = writeJsonl("summary.jsonl", [
+            {
+                type: "session_meta",
+                payload: {
+                    id: "summary",
+                    cwd: "/repo",
+                    timestamp: "2025-01-01T00:00:00Z"
+                }
+            },
+            {
+                type: "response_item",
+                timestamp: "2025-01-01T00:00:00.500Z",
+                payload: {
+                    type: "message",
+                    role: "user",
+                    content: [
+                        {
+                            type: "input_text",
+                            text: "<environment_context>\n  <cwd>/repo</cwd>\n</environment_context>"
+                        }
+                    ]
+                }
+            },
+            {
+                type: "event_msg",
+                timestamp: "2025-01-01T00:00:02Z",
+                payload: {
+                    type: "item_completed",
+                    item: {
+                        type: "UserMessage",
+                        content: [
+                            {
+                                type: "text",
+                                text: "first event user"
+                            }
+                        ]
+                    }
+                }
+            }
+        ]);
+        expect(parser.fileToSessionSummary(filePath)).toMatchObject({
+            type: "codex",
+            sessionId: "summary",
+            cwd: "/repo",
+            firstUserMessage: "first event user",
+            sessionFilePath: filePath
+        });
+    });
+    it("returns null or empty results for unreadable and malformed inputs", ()=>{
+        expect(parser.readSession(path.join(tmpDir, "missing.jsonl"))).toBeNull();
+        expect(parser.readSession("unused.jsonl", "")).toBeNull();
+        expect(parser.readSession("unused.jsonl", JSON.stringify({
+            type: "event",
+            payload: {}
+        }))).toBeNull();
+        expect(parser.getConversation(path.join(tmpDir, "missing.jsonl"))).toEqual([]);
+    });
+    function writeJsonl(name, entries) {
+        const filePath = path.join(tmpDir, name);
+        fs.writeFileSync(filePath, entries.map((entry)=>JSON.stringify(entry)).join("\n"));
+        return filePath;
+    }
+});
+
+//# sourceMappingURL=CodexSessionParser.test.js.map

package/dist/__tests__/harnesses/codex/CodexSessionParser.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/__tests__/harnesses/codex/CodexSessionParser.test.ts"],"sourcesContent":["import * as fs from \"fs\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport { AgentStatus } from \"../../../adapters/AgentAdapter.js\";\nimport { CodexSessionParser } from \"../../../harnesses/codex/CodexSessionParser.js\";\n\ndescribe(\"CodexSessionParser\", () => {\n  let tmpDir: string;\n  let parser: CodexSessionParser;\n\n  beforeEach(() => {\n    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), \"codex-parser-\"));\n    parser = new CodexSessionParser();\n  });\n\n  afterEach(() => {\n    fs.rmSync(tmpDir, { recursive: true, force: true });\n  });\n\n  it(\"reads session metadata, summary, timestamps, and status signal\", () => {\n    const filePath = writeJsonl(\"session.jsonl\", [\n      {\n        type: \"session_meta\",\n        payload: { id: \"sess-1\", timestamp: \"2026-03-18T15:00:00Z\", cwd: \"/repo\" },\n      },\n      {\n        type: \"event\",\n        timestamp: \"2026-03-18T15:01:00Z\",\n        payload: { type: \"agent_reasoning\", message: \"Working on feature\" },\n      },\n    ]);\n\n    const session = parser.readSession(filePath);\n\n    expect(session).toMatchObject({\n      sessionId: \"sess-1\",\n      projectPath: \"/repo\",\n      summary: \"Working on feature\",\n      lastPayloadType: \"agent_reasoning\",\n    });\n    expect(session?.sessionStart.toISOString()).toBe(\"2026-03-18T15:00:00.000Z\");\n    expect(parser.determineStatus(session!)).toBe(AgentStatus.IDLE);\n  });\n\n  it(\"reads current response_item and event_msg messages without mirrored duplicates\", () => {\n    const filePath = writeJsonl(\"conversation.jsonl\", [\n      {\n        type: \"session_meta\",\n        payload: { id: \"sess-1\", cwd: \"/repo\", timestamp: \"2026-03-27T10:00:00Z\" },\n      },\n      {\n        type: \"response_item\",\n        timestamp: \"2026-03-27T10:00:01Z\",\n        payload: {\n          type: \"message\",\n          role: \"user\",\n          content: [{ type: \"input_text\", text: \"Fix the bug\" }],\n          internal_chat_message_metadata_passthrough: { turn_id: \"turn-1\" },\n        },\n      },\n      {\n        type: \"event_msg\",\n        timestamp: \"2026-03-27T10:00:01.001Z\",\n        payload: {\n          type: \"item_completed\",\n          turn_id: \"turn-1\",\n          item: { type: \"UserMessage\", content: [{ type: \"text\", text: \"Fix the bug\" }] },\n        },\n      },\n      {\n        type: \"event_msg\",\n        timestamp: \"2026-03-27T10:00:05Z\",\n        payload: {\n          type: \"item_completed\",\n          turn_id: \"turn-1\",\n          item: { type: \"AgentMessage\", content: [{ type: \"Text\", text: \"I found the issue\" }] },\n        },\n      },\n      {\n        type: \"response_item\",\n        timestamp: \"2026-03-27T10:00:05.005Z\",\n        payload: {\n          type: \"message\",\n          role: \"assistant\",\n          content: [{ type: \"output_text\", text: \"I found the issue\" }],\n          internal_chat_message_metadata_passthrough: { turn_id: \"turn-1\" },\n        },\n      },\n    ]);\n\n    expect(parser.getConversation(filePath)).toEqual([\n      { role: \"user\", content: \"Fix the bug\", timestamp: \"2026-03-27T10:00:01Z\" },\n      { role: \"assistant\", content: \"I found the issue\", timestamp: \"2026-03-27T10:00:05.005Z\" },\n    ]);\n  });\n\n  it(\"maps completed assistant messages as waiting while recent active events stay running\", () => {\n    const waiting = parser.readSession(\n      \"unused.jsonl\",\n      [\n        JSON.stringify({\n          type: \"session_meta\",\n          payload: { id: \"waiting\", timestamp: new Date().toISOString(), cwd: \"/repo\" },\n        }),\n        JSON.stringify({\n          type: \"event_msg\",\n          timestamp: new Date().toISOString(),\n          payload: {\n            type: \"item_completed\",\n            item: {\n              type: \"AgentMessage\",\n              content: [{ type: \"Text\", text: \"Waiting for the user now\" }],\n            },\n          },\n        }),\n      ].join(\"\\n\"),\n    );\n\n    const running = parser.readSession(\n      \"unused.jsonl\",\n      [\n        JSON.stringify({\n          type: \"session_meta\",\n          payload: { id: \"running\", timestamp: new Date().toISOString(), cwd: \"/repo\" },\n        }),\n        JSON.stringify({\n          type: \"event\",\n          timestamp: new Date().toISOString(),\n          payload: { type: \"token_count\", message: \"Working\" },\n        }),\n      ].join(\"\\n\"),\n    );\n\n    expect(waiting?.summary).toBe(\"Waiting for the user now\");\n    expect(parser.determineStatus(waiting!)).toBe(AgentStatus.WAITING);\n    expect(parser.determineStatus(running!)).toBe(AgentStatus.RUNNING);\n  });\n\n  it(\"builds historical summaries from the first non-synthetic user message\", () => {\n    const filePath = writeJsonl(\"summary.jsonl\", [\n      {\n        type: \"session_meta\",\n        payload: { id: \"summary\", cwd: \"/repo\", timestamp: \"2025-01-01T00:00:00Z\" },\n      },\n      {\n        type: \"response_item\",\n        timestamp: \"2025-01-01T00:00:00.500Z\",\n        payload: {\n          type: \"message\",\n          role: \"user\",\n          content: [\n            {\n              type: \"input_text\",\n              text: \"<environment_context>\\n  <cwd>/repo</cwd>\\n</environment_context>\",\n            },\n          ],\n        },\n      },\n      {\n        type: \"event_msg\",\n        timestamp: \"2025-01-01T00:00:02Z\",\n        payload: {\n          type: \"item_completed\",\n          item: { type: \"UserMessage\", content: [{ type: \"text\", text: \"first event user\" }] },\n        },\n      },\n    ]);\n\n    expect(parser.fileToSessionSummary(filePath)).toMatchObject({\n      type: \"codex\",\n      sessionId: \"summary\",\n      cwd: \"/repo\",\n      firstUserMessage: \"first event user\",\n      sessionFilePath: filePath,\n    });\n  });\n\n  it(\"returns null or empty results for unreadable and malformed inputs\", () => {\n    expect(parser.readSession(path.join(tmpDir, \"missing.jsonl\"))).toBeNull();\n    expect(parser.readSession(\"unused.jsonl\", \"\")).toBeNull();\n    expect(\n      parser.readSession(\"unused.jsonl\", JSON.stringify({ type: \"event\", payload: {} })),\n    ).toBeNull();\n    expect(parser.getConversation(path.join(tmpDir, \"missing.jsonl\"))).toEqual([]);\n  });\n\n  function writeJsonl(name: string, entries: object[]): string {\n    const filePath = path.join(tmpDir, name);\n    fs.writeFileSync(filePath, entries.map((entry) => JSON.stringify(entry)).join(\"\\n\"));\n    return filePath;\n  }\n});\n"],"names":["fs","os","path","AgentStatus","CodexSessionParser","describe","tmpDir","parser","beforeEach","mkdtempSync","join","tmpdir","afterEach","rmSync","recursive","force","it","filePath","writeJsonl","type","payload","id","timestamp","cwd","message","session","readSession","expect","toMatchObject","sessionId","projectPath","summary","lastPayloadType","sessionStart","toISOString","toBe","determineStatus","IDLE","role","content","text","internal_chat_message_metadata_passthrough","turn_id","item","getConversation","toEqual","waiting","JSON","stringify","Date","running","WAITING","RUNNING","fileToSessionSummary","firstUserMessage","sessionFilePath","toBeNull","name","entries","writeFileSync","map","entry"],"mappings":"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"}

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

@@ -0,0 +1,121 @@
+import { describe, expect, it, vi } from "vitest";
+import { CodexCliProbe } from "../../../../harnesses/codex/durable/CodexCliProbe.js";
+describe("CodexCliProbe", ()=>{
+    it("validates version, exec JSON/stdin, and resume capabilities without a model call", async ()=>{
+        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: ""
+        });
+        await expect(new CodexCliProbe({
+            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 unsupported = new CodexCliProbe({
+            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 CodexCliProbe({
+            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 CodexCliProbe({
+            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 exec = vi.fn().mockResolvedValueOnce({
+            stdout: " \n",
+            stderr: ""
+        }).mockResolvedValueOnce({
+            stdout: "exec --json -",
+            stderr: ""
+        }).mockResolvedValueOnce({
+            stdout: "resume --json -",
+            stderr: ""
+        });
+        await expect(new CodexCliProbe({
+            exec
+        }).validate()).resolves.toMatchObject({
+            version: "unknown"
+        });
+    });
+    it("requires a standalone stdin dash rather than accepting flag hyphens", async ()=>{
+        const exec = vi.fn().mockResolvedValueOnce({
+            stdout: "version",
+            stderr: ""
+        }).mockResolvedValueOnce({
+            stdout: "exec --json",
+            stderr: ""
+        }).mockResolvedValueOnce({
+            stdout: "resume --json",
+            stderr: ""
+        });
+        await expect(new CodexCliProbe({
+            exec
+        }).validate()).rejects.toMatchObject({
+            code: "CODEX_CLI_UNSUPPORTED"
+        });
+    });
+});
+
+//# sourceMappingURL=CodexCliProbe.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/__tests__/harnesses/codex/durable/CodexCliProbe.test.ts"],"sourcesContent":["import { describe, expect, it, vi } from \"vitest\";\nimport { CodexCliProbe } from \"../../../../harnesses/codex/durable/CodexCliProbe.js\";\n\ndescribe(\"CodexCliProbe\", () => {\n  it(\"validates version, exec JSON/stdin, and resume capabilities without a model call\", async () => {\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    await expect(new CodexCliProbe({ executable: \"fake-codex\", exec }).validate()).resolves.toEqual(\n      {\n        executable: \"fake-codex\",\n        version: \"codex-cli 0.147.0\",\n      },\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 unsupported = new CodexCliProbe({\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 CodexCliProbe({\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 CodexCliProbe({\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 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 CodexCliProbe({ exec }).validate()).resolves.toMatchObject({\n      version: \"unknown\",\n    });\n  });\n\n  it(\"requires a standalone stdin dash rather than accepting flag hyphens\", async () => {\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 CodexCliProbe({ exec }).validate()).rejects.toMatchObject({\n      code: \"CODEX_CLI_UNSUPPORTED\",\n    });\n  });\n});\n"],"names":["describe","expect","it","vi","CodexCliProbe","exec","fn","mockResolvedValueOnce","stdout","stderr","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__/harnesses/codex/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__/harnesses/codex/durable/CodexDurableAgentRepository.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/__tests__/harnesses/codex/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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"}