@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/__tests__/fixtures/fake-codex.cjs

@@ -1,56 +0,0 @@
-#!/usr/bin/env node
-const fs = require("node:fs");
-
-const SESSION = "22222222-2222-4222-8222-222222222222";
-const MISMATCH = "33333333-3333-4333-8333-333333333333";
-const args = process.argv.slice(2);
-
-if (args[0] === "--version") {
-  process.stdout.write("codex-cli 0.147.0\n");
-  process.exit(0);
-}
-if (args[0] === "exec" && args.at(-1) === "--help") {
-  process.stdout.write(
-    args[1] === "resume"
-      ? "Usage: codex exec resume [SESSION_ID] [PROMPT]\n--json\n- stdin\n"
-      : "Usage: codex exec [PROMPT]\nresume\n--json\n- stdin\n",
-  );
-  process.exit(0);
-}
-
-let prompt = "";
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => {
-  prompt += chunk;
-});
-process.stdin.on("end", () => {
-  const mode = process.env.AI_DEVKIT_FAKE_CODEX_MODE || "success";
-  const isResume = args[1] === "resume";
-  const requested = isResume ? args[3] : null;
-  const sessionId = mode === "mismatch" ? MISMATCH : requested || SESSION;
-  const capture = process.env.AI_DEVKIT_FAKE_CODEX_CAPTURE;
-  if (capture)
-    fs.appendFileSync(capture, `${JSON.stringify({ args, prompt, cwd: process.cwd() })}\n`);
-  if (mode === "fail-before-bind") process.exit(1);
-  if (mode !== "missing-thread")
-    process.stdout.write(`${JSON.stringify({ type: "thread.started", thread_id: sessionId })}\n`);
-  if (mode === "fail-after-bind") process.exit(1);
-  if (mode === "malformed") return process.stdout.write("{bad\n");
-  if (mode === "oversized") return process.stdout.write(`${"x".repeat(1024 * 1024 + 1)}\n`);
-  if (mode === "truncated") return process.stdout.write("{");
-  process.stdout.write(`${JSON.stringify({ type: "turn.started" })}\n`);
-  if (mode !== "missing-result") {
-    process.stdout.write(
-      `${JSON.stringify({ type: "item.completed", item: { id: "item_0", type: "agent_message", text: "first" } })}\n`,
-    );
-    process.stdout.write(
-      `${JSON.stringify({ type: "item.completed", item: { id: "item_1", type: "agent_message", text: `answer:${prompt}` } })}\n`,
-    );
-  }
-  if (mode !== "missing-completion")
-    process.stdout.write(`${JSON.stringify({ type: "turn.completed", usage: {} })}\n`);
-  if (mode === "stderr-failure") {
-    process.stderr.write("secret-looking diagnostic");
-    process.exitCode = 1;
-  }
-});

package/src/__tests__/print/ClaudeCliProbe.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { ClaudeCliProbe } from "../../providers/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__/print/ClaudePrintAgent.integration.test.ts

@@ -1,61 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  ClaudePrintAgentService,
-  DurableAgentRepository,
-  type ProcessInspector,
-} from "../../index.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__/print/ClaudePrintAgentService.test.ts

@@ -1,129 +0,0 @@
-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__/print/ClaudePrintRunner.test.ts

@@ -1,152 +0,0 @@
-import { EventEmitter } from "node:events";
-import { PassThrough, Writable } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
-import type { DurableAgent } from "../../index.js";
-import { ClaudePrintRunner } from "../../providers/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/);
-  });
-});

package/src/__tests__/providers/claude/ClaudeAgentMapper.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { ClaudeAgentMapper } from "../../../providers/claude/ClaudeAgentMapper.js";
-import type { ClaudeSession } from "../../../providers/claude/ClaudeSessionParser.js";
-import type { SessionFile } from "../../../utils/session.js";
-
-function makeProcess(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
-  return {
-    pid: 123,
-    command: "claude",
-    cwd: "/repo/my-app",
-    tty: "ttys001",
-    ...overrides,
-  };
-}
-
-function makeSession(overrides: Partial<ClaudeSession> = {}): ClaudeSession {
-  return {
-    sessionId: "session-1",
-    projectPath: "/repo/my-app",
-    sessionStart: new Date("2026-08-23T10:00:00.000Z"),
-    lastActive: new Date("2026-08-23T10:05:00.000Z"),
-    lastEntryType: "assistant",
-    isInterrupted: false,
-    lastUserMessage: "Review this change",
-    ...overrides,
-  };
-}
-
-function makeSessionFile(overrides: Partial<SessionFile> = {}): SessionFile {
-  return {
-    sessionId: "session-1",
-    filePath: "/home/.claude/projects/-repo-my-app/session-1.jsonl",
-    projectDir: "/home/.claude/projects/-repo-my-app",
-    birthtimeMs: new Date("2026-08-23T10:00:00.000Z").getTime(),
-    resolvedCwd: "/repo/my-app",
-    ...overrides,
-  };
-}
-
-describe("ClaudeAgentMapper", () => {
-  it("prefers live PID-file status and waiting reason over JSONL-derived status", () => {
-    const mapper = new ClaudeAgentMapper();
-
-    const agent = mapper.mapSessionToAgent({
-      session: makeSession({ lastEntryType: "assistant" }),
-      processInfo: makeProcess(),
-      sessionFile: makeSessionFile(),
-      liveInfo: {
-        pidStatus: AgentStatus.WAITING,
-        waitingFor: "approve Read",
-      },
-    });
-
-    expect(agent).toMatchObject({
-      name: "my-app-123",
-      type: "claude",
-      status: AgentStatus.WAITING,
-      summary: "Review this change — waiting for approve Read",
-      pid: 123,
-      projectPath: "/repo/my-app",
-      sessionId: "session-1",
-      sessionFilePath: "/home/.claude/projects/-repo-my-app/session-1.jsonl",
-    });
-  });
-
-  it("maps unmatched processes to the existing process-only fallback shape", () => {
-    const mapper = new ClaudeAgentMapper();
-
-    const agent = mapper.mapProcessOnlyAgent(makeProcess({ pid: 456, cwd: "/repo/tooling" }));
-
-    expect(agent).toMatchObject({
-      name: "tooling-456",
-      type: "claude",
-      status: AgentStatus.IDLE,
-      summary: "Unknown",
-      pid: 456,
-      projectPath: "/repo/tooling",
-      sessionId: "pid-456",
-    });
-    expect(agent.lastActive).toBeInstanceOf(Date);
-  });
-});