@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/__tests__/harnesses/claude/ClaudeSessionParser.test.ts

@@ -0,0 +1,300 @@
+/**
+ * Tests for harnesses/claude/ClaudeSessionParser.ts — focused on stripping
+ * harness-injected XML tags from conversation content.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { ClaudeSessionParser } from "../../../harnesses/claude/ClaudeSessionParser.js";
+
+interface JsonlEntry {
+  type: "user" | "assistant" | "system";
+  message: {
+    content:
+      | string
+      | Array<{
+          type: string;
+          text?: string;
+          content?: string;
+          name?: string;
+          input?: unknown;
+          is_error?: boolean;
+        }>;
+  };
+  timestamp?: string;
+}
+
+function writeSession(entries: JsonlEntry[]): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "parser-test-"));
+  const filePath = path.join(dir, "session.jsonl");
+  fs.writeFileSync(filePath, entries.map((e) => JSON.stringify(e)).join("\n"));
+  return filePath;
+}
+
+describe("ClaudeSessionParser.getConversation — harness tag stripping", () => {
+  let parser: ClaudeSessionParser;
+  const tempFiles: string[] = [];
+
+  beforeEach(() => {
+    parser = new ClaudeSessionParser();
+  });
+
+  afterEach(() => {
+    for (const f of tempFiles) {
+      try {
+        fs.rmSync(path.dirname(f), { recursive: true, force: true });
+      } catch {
+        /* best effort */
+      }
+    }
+    tempFiles.length = 0;
+  });
+
+  function makeSession(entries: JsonlEntry[]): string {
+    const f = writeSession(entries);
+    tempFiles.push(f);
+    return f;
+  }
+
+  it("strips <system-reminder> blocks from text content", () => {
+    const file = makeSession([
+      {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "text",
+              text: "Real response here.\n<system-reminder>\nDo not mention this reminder.\n</system-reminder>\nMore response.",
+            },
+          ],
+        },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv).toHaveLength(1);
+    expect(conv[0].content).toBe("Real response here.\n\nMore response.");
+  });
+
+  it("strips <local-command-stdout> blocks", () => {
+    const file = makeSession([
+      {
+        type: "system",
+        message: {
+          content: "before <local-command-stdout>\nRunning...\nDone\n</local-command-stdout> after",
+        },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("before  after");
+  });
+
+  it("strips <user-prompt-submit-hook> blocks", () => {
+    const file = makeSession([
+      {
+        type: "user",
+        message: {
+          content:
+            "<user-prompt-submit-hook>hook output</user-prompt-submit-hook>\nactual question",
+        },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("actual question");
+  });
+
+  it("strips bash and command stdout/stderr blocks", () => {
+    const file = makeSession([
+      {
+        type: "assistant",
+        message: {
+          content: [
+            {
+              type: "text",
+              text: "Output:\n<bash-input>ls</bash-input>\n<bash-stdout>file.txt</bash-stdout>\n<bash-stderr></bash-stderr>\n<command-stdout>x</command-stdout>\n<command-stderr>y</command-stderr>\nEnd.",
+            },
+          ],
+        },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("Output:\n\n\n\n\n\nEnd.".replace(/\n{3,}/g, "\n\n"));
+    expect(conv[0].content).not.toMatch(/<bash-/);
+    expect(conv[0].content).not.toMatch(/<command-stdout>|<command-stderr>/);
+  });
+
+  it('collapses <command-name>/<command-args> into "/name args" shorthand', () => {
+    const file = makeSession([
+      {
+        type: "user",
+        message: {
+          content:
+            "<command-message>debug</command-message>\n<command-name>/debug</command-name>\n<command-args>fix the bug</command-args>",
+        },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("/debug fix the bug");
+  });
+
+  it("handles <command-name> without <command-args>", () => {
+    const file = makeSession([
+      {
+        type: "user",
+        message: {
+          content: "<command-message>clear</command-message>\n<command-name>/clear</command-name>",
+        },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("/clear");
+  });
+
+  it("handles multiple harness tags mixed together", () => {
+    const file = makeSession([
+      {
+        type: "user",
+        message: {
+          content: [
+            {
+              type: "text",
+              text: "<system-reminder>ignore me</system-reminder>\n<command-message>build</command-message>\n<command-name>/build</command-name>\n<command-args>--watch</command-args>\n<local-command-stdout>build output here</local-command-stdout>",
+            },
+          ],
+        },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("/build --watch");
+  });
+
+  it("leaves text without harness tags unchanged", () => {
+    const file = makeSession([
+      {
+        type: "assistant",
+        message: { content: [{ type: "text", text: "Hello, world!" }] },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("Hello, world!");
+  });
+
+  it("drops a message that becomes empty after stripping", () => {
+    const file = makeSession([
+      {
+        type: "system",
+        message: { content: "<system-reminder>only this</system-reminder>" },
+      },
+      {
+        type: "assistant",
+        message: { content: [{ type: "text", text: "kept" }] },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv).toHaveLength(1);
+    expect(conv[0].content).toBe("kept");
+  });
+
+  it("strips tags spanning multiple lines", () => {
+    const multilineReminder = "<system-reminder>\nLine 1\nLine 2\nLine 3\n</system-reminder>";
+    const file = makeSession([
+      {
+        type: "assistant",
+        message: { content: [{ type: "text", text: `before\n${multilineReminder}\nafter` }] },
+      },
+    ]);
+
+    const conv = parser.getConversation(file);
+    expect(conv[0].content).toBe("before\n\nafter");
+  });
+});
+
+describe("ClaudeSessionParser.readSession — UI-state entries ignored for status", () => {
+  let parser: ClaudeSessionParser;
+  const tempFiles: string[] = [];
+
+  beforeEach(() => {
+    parser = new ClaudeSessionParser();
+  });
+
+  afterEach(() => {
+    for (const f of tempFiles) {
+      try {
+        fs.rmSync(path.dirname(f), { recursive: true, force: true });
+      } catch {
+        /* best effort */
+      }
+    }
+    tempFiles.length = 0;
+  });
+
+  function writeRawSession(lines: object[]): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "parser-status-"));
+    const filePath = path.join(dir, "session.jsonl");
+    fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join("\n"));
+    tempFiles.push(filePath);
+    return filePath;
+  }
+
+  const uiStateTypes = [
+    "attachment",
+    "permission-mode",
+    "ai-title",
+    "queued_command",
+    "tools_changed",
+    "model_changed",
+    "hook_progress",
+  ];
+
+  for (const uiType of uiStateTypes) {
+    it(`keeps lastEntryType from previous conversation turn when trailing entry is ${uiType}`, () => {
+      const file = writeRawSession([
+        { type: "user", timestamp: "2026-05-30T06:17:57.189Z", message: { content: "hello" } },
+        { type: uiType, timestamp: "2026-05-30T06:17:57.201Z" },
+      ]);
+
+      const session = parser.readSession(file, "/test");
+      expect(session?.lastEntryType).toBe("user");
+    });
+  }
+
+  it("keeps lastEntryType from a user turn even with multiple trailing UI-state entries", () => {
+    const file = writeRawSession([
+      { type: "user", timestamp: "2026-05-30T06:17:57.189Z", message: { content: "hello" } },
+      {
+        type: "attachment",
+        timestamp: "2026-05-30T06:17:57.200Z",
+        attachment: { type: "task_reminder", content: [] },
+      },
+      { type: "permission-mode", timestamp: "2026-05-30T06:17:57.210Z", permissionMode: "default" },
+      { type: "ai-title", timestamp: "2026-05-30T06:17:57.220Z" },
+    ]);
+
+    const session = parser.readSession(file, "/test");
+    expect(session?.lastEntryType).toBe("user");
+  });
+
+  it("keeps lastEntryType from assistant turn when followed by UI-state events", () => {
+    const file = writeRawSession([
+      { type: "user", timestamp: "2026-05-30T06:17:00.000Z", message: { content: "go" } },
+      {
+        type: "assistant",
+        timestamp: "2026-05-30T06:17:01.000Z",
+        message: { content: [{ type: "text", text: "done" }] },
+      },
+      { type: "permission-mode", timestamp: "2026-05-30T06:17:02.000Z", permissionMode: "default" },
+    ]);
+
+    const session = parser.readSession(file, "/test");
+    expect(session?.lastEntryType).toBe("assistant");
+  });
+});

package/src/__tests__/harnesses/claude/durable/ClaudeCliProbe.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+import { ClaudeCliProbe } from "../../../../harnesses/claude/durable/ClaudeCliProbe.js";
+
+describe("ClaudeCliProbe", () => {
+  it("validates only version/help and requires the print session flags", async () => {
+    const exec = vi
+      .fn()
+      .mockResolvedValueOnce({ stdout: "2.1.220\n", stderr: "" })
+      .mockResolvedValueOnce({
+        stdout: "--print --session-id --resume --output-format stream-json",
+        stderr: "",
+      });
+
+    await expect(new ClaudeCliProbe({ exec }).validate()).resolves.toEqual({
+      executable: "claude",
+      version: "2.1.220",
+    });
+    expect(exec.mock.calls).toEqual([
+      ["claude", ["--version"]],
+      ["claude", ["--help"]],
+    ]);
+  });
+
+  it("rejects a CLI missing a required capability", async () => {
+    const exec = vi
+      .fn()
+      .mockResolvedValueOnce({ stdout: "old", stderr: "" })
+      .mockResolvedValueOnce({ stdout: "--print only", stderr: "" });
+
+    await expect(new ClaudeCliProbe({ exec }).validate()).rejects.toMatchObject({
+      code: "CLAUDE_CLI_UNSUPPORTED",
+    });
+  });
+});

package/src/__tests__/harnesses/claude/durable/ClaudePrintAgent.integration.test.ts

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  DurableAgentRepository,
+  type ProcessInspector,
+} from "../../../../durable/DurableAgentRepository.js";
+import { ClaudePrintAgentService } from "../../../../harnesses/claude/durable/ClaudePrintAgentService.js";
+
+const roots: string[] = [];
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("Claude durable-agent fake-provider journey", () => {
+  it("creates without invocation, then starts and resumes the same session through stdin", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "durable-agent-integration-"));
+    roots.push(root);
+    const cwd = path.join(root, "project");
+    fs.mkdirSync(cwd);
+    const processInspector: ProcessInspector = {
+      getIdentity: (pid) => ({ pid, startedAt: `process-${pid}` }),
+    };
+    const repository = new DurableAgentRepository({
+      dbPath: path.join(root, "state", "agents.db"),
+      processInspector,
+    });
+    const runner = {
+      run: vi.fn().mockImplementation(async (request) => {
+        await request.onSpawn({ pid: 42, startedAt: "process-42" });
+        return {
+          sessionId: request.agent.providerSessionId,
+          result: `answer:${request.prompt}`,
+          exitCode: 0,
+        };
+      }),
+    };
+    const service = new ClaudePrintAgentService({
+      repository,
+      probe: { validate: vi.fn() },
+      runner,
+    });
+
+    const created = await service.create({ name: "reviewer", cwd });
+
+    await expect(service.send(created.id, "first secret")).resolves.toMatchObject({
+      result: "answer:first secret",
+    });
+    await expect(service.send(created.id, "follow up")).resolves.toMatchObject({
+      result: "answer:follow up",
+    });
+
+    expect(runner.run.mock.calls[0][0]).toMatchObject({ firstRun: true, prompt: "first secret" });
+    expect(runner.run.mock.calls[1][0]).toMatchObject({ firstRun: false, prompt: "follow up" });
+
+    const persisted = await repository.getById(created.id);
+    expect(persisted).toMatchObject({ state: "ready", sessionHealth: "healthy" });
+  });
+});

package/src/__tests__/harnesses/claude/durable/ClaudePrintAgentService.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it, vi } from "vitest";
+
+describe("ClaudePrintAgentService", () => {
+  it("validates before create and does not run Claude", async () => {
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
+    expect(api).toHaveProperty("ClaudePrintAgentService");
+    const probe = {
+      validate: vi.fn().mockResolvedValue({ executable: "claude", version: "2.1.220" }),
+    };
+    const repository = { create: vi.fn().mockResolvedValue({ id: "agent-id", name: "reviewer" }) };
+    const runner = { run: vi.fn() };
+    const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
+
+    await expect(
+      new Service({ repository, probe, runner }).create({ name: "reviewer", cwd: "/project" }),
+    ).resolves.toMatchObject({ id: "agent-id" });
+    expect(probe.validate).toHaveBeenCalledOnce();
+    expect(repository.create).toHaveBeenCalledWith({ name: "reviewer", cwd: "/project" });
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+
+  it("runs first and resumed sends and records provider identity/results", async () => {
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
+    const base = {
+      id: "id",
+      name: "reviewer",
+      provider: "claude",
+      providerSessionId: "session",
+      sessionHealth: "uninitialized",
+    };
+    const repository = {
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi
+        .fn()
+        .mockResolvedValueOnce({ agent: base, token: "one" })
+        .mockResolvedValueOnce({ agent: { ...base, sessionHealth: "healthy" }, token: "two" }),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn().mockResolvedValue({}),
+    };
+    const runner = {
+      run: vi.fn().mockImplementation(async (request) => {
+        await request.onSpawn({ pid: 42, startedAt: "start" });
+        return { sessionId: "session", result: "answer", exitCode: 0 };
+      }),
+    };
+    const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
+    const service = new Service({
+      repository,
+      probe: { validate: vi.fn() },
+      runner,
+      executable: "fake-claude",
+    });
+
+    await service.send("reviewer", "first");
+    await service.send("id", "later");
+
+    expect(runner.run.mock.calls[0][0]).toMatchObject({
+      prompt: "first",
+      firstRun: true,
+      executable: "fake-claude",
+    });
+    expect(runner.run.mock.calls[1][0]).toMatchObject({
+      prompt: "later",
+      firstRun: false,
+      executable: "fake-claude",
+    });
+    expect(repository.recordProviderProcess).toHaveBeenCalledWith("id", "one", {
+      pid: 42,
+      startedAt: "start",
+    });
+    expect(repository.completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({
+        status: "succeeded",
+        exitCode: 0,
+        sessionHealth: "healthy",
+      }),
+    );
+  });
+
+  it("rejects a non-Claude target without acquiring or mutating it", async () => {
+    const api = (await import("../../../../index.js")) as Record<string, unknown>;
+    const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
+    const target = { id: "id", name: "reviewer", provider: "pi" };
+    const repository = {
+      resolve: vi.fn().mockResolvedValue(target),
+      acquireRun: vi.fn(),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn(),
+    };
+
+    await expect(
+      new Service({ repository, probe: { validate: vi.fn() }, runner: { run: vi.fn() } }).send(
+        "reviewer",
+        "x",
+      ),
+    ).rejects.toMatchObject({ code: "CLAUDE_PRINT_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")) as Record<string, unknown>;
+    const Service = api.ClaudePrintAgentService as new (options: unknown) => any;
+    const target = {
+      id: "id",
+      name: "reviewer",
+      provider: "claude",
+      providerSessionId: "session",
+      sessionHealth: "healthy",
+    };
+    const completionFailure = new Error("completion failed");
+    const repository = {
+      resolve: vi.fn().mockResolvedValue(target),
+      acquireRun: vi.fn().mockResolvedValue({ agent: target, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn().mockRejectedValue(completionFailure),
+    };
+    const runner = {
+      run: vi.fn().mockResolvedValue({ sessionId: "session", result: "answer", exitCode: 0 }),
+    };
+
+    await expect(
+      new Service({ repository, probe: { validate: vi.fn() }, runner }).send("reviewer", "x"),
+    ).rejects.toBe(completionFailure);
+    expect(repository.completeRun).toHaveBeenCalledOnce();
+  });
+});

package/src/__tests__/harnesses/claude/durable/ClaudePrintRunner.test.ts

@@ -0,0 +1,152 @@
+import { EventEmitter } from "node:events";
+import { PassThrough, Writable } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+import type { DurableAgent } from "../../../../durable/DurableAgent.js";
+import { ClaudePrintRunner } from "../../../../harnesses/claude/durable/ClaudePrintRunner.js";
+
+function agent(): DurableAgent {
+  return {
+    id: "11111111-1111-4111-8111-111111111111",
+    name: "reviewer",
+    provider: "claude",
+    mode: "durable",
+    cwd: "/project",
+    providerSessionId: "22222222-2222-4222-8222-222222222222",
+    state: "running",
+    sessionHealth: "uninitialized",
+    createdAt: "",
+    updatedAt: "",
+    lastActiveAt: null,
+    lastResult: null,
+    activeRun: null,
+  };
+}
+
+function fakeSpawn(events: object[], exitCode = 0) {
+  const calls: unknown[][] = [];
+  const promptChunks: Buffer[] = [];
+  const child = new EventEmitter() as any;
+  child.pid = 4242;
+  child.stdout = new PassThrough();
+  child.stderr = new PassThrough();
+  child.stdin = new Writable({
+    write(chunk, _encoding, callback) {
+      promptChunks.push(Buffer.from(chunk));
+      callback();
+    },
+    final(callback) {
+      for (const event of events) child.stdout.write(`${JSON.stringify(event)}\n`);
+      child.stdout.end();
+      queueMicrotask(() => child.emit("close", exitCode, null));
+      callback();
+    },
+  });
+  const spawn = vi.fn((...args: unknown[]) => {
+    calls.push(args);
+    return child;
+  });
+  return { spawn, calls, promptChunks };
+}
+
+describe("ClaudePrintRunner", () => {
+  it("starts a caller-assigned session and persists provider identity before stdin", async () => {
+    const fixture = fakeSpawn([
+      { type: "system", subtype: "init", session_id: agent().providerSessionId },
+      { type: "result", session_id: agent().providerSessionId, result: "done" },
+    ]);
+    let persisted = false;
+    const runner = new ClaudePrintRunner({
+      spawn: fixture.spawn,
+      processInspector: {
+        getIdentity: () => ({ pid: 4242, startedAt: "provider-start" }),
+      },
+    });
+
+    const result = await runner.run({
+      agent: agent(),
+      prompt: "secret prompt",
+      executable: "claude-test",
+      firstRun: true,
+      onSpawn: async () => {
+        expect(fixture.promptChunks).toHaveLength(0);
+        persisted = true;
+      },
+    });
+
+    expect(persisted).toBe(true);
+    expect(fixture.calls[0]).toEqual([
+      "claude-test",
+      [
+        "-p",
+        "--session-id",
+        agent().providerSessionId,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+      ],
+      expect.objectContaining({ cwd: "/project", shell: false, stdio: ["pipe", "pipe", "pipe"] }),
+    ]);
+    expect(JSON.stringify(fixture.calls)).not.toContain("secret prompt");
+    expect(Buffer.concat(fixture.promptChunks).toString()).toBe("secret prompt");
+    expect(result).toEqual({ sessionId: agent().providerSessionId, result: "done", exitCode: 0 });
+  });
+
+  it("uses exact resume and rejects a mismatched result session", async () => {
+    const fixture = fakeSpawn([{ type: "result", session_id: "wrong", result: "nope" }]);
+    const runner = new ClaudePrintRunner({
+      spawn: fixture.spawn,
+      processInspector: {
+        getIdentity: () => ({ pid: 4242, startedAt: "provider-start" }),
+      },
+    });
+
+    await expect(
+      runner.run({
+        agent: agent(),
+        prompt: "followup",
+        executable: "claude",
+        firstRun: false,
+        onSpawn: vi.fn(),
+      }),
+    ).rejects.toMatchObject({ code: "CLAUDE_SESSION_MISMATCH" });
+    expect(fixture.calls[0]![1]).toEqual([
+      "-p",
+      "--resume",
+      agent().providerSessionId,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+    ]);
+  });
+
+  it("does not disclose provider stderr in a failed-run error", async () => {
+    const fixture = fakeSpawn([], 1);
+    const runner = new ClaudePrintRunner({
+      spawn: fixture.spawn,
+      processInspector: {
+        getIdentity: () => ({ pid: 4242, startedAt: "provider-start" }),
+      },
+    });
+    fixture.spawn.mockImplementationOnce((...args: unknown[]) => {
+      const child = (fakeSpawn([], 1).spawn as any)(...args);
+      child.stdin = new Writable({
+        final(callback) {
+          child.stderr.write("secret prompt echoed by provider");
+          child.stderr.end();
+          queueMicrotask(() => child.emit("close", 1, null));
+          callback();
+        },
+      });
+      return child;
+    });
+
+    await expect(
+      runner.run({
+        agent: agent(),
+        prompt: "secret prompt",
+        firstRun: true,
+        onSpawn: vi.fn(),
+      }),
+    ).rejects.not.toThrow(/secret prompt/);
+  });
+});