@ai-devkit/agent-manager 0.33.1 → 0.34.0

package/src/__tests__/capacity/fixtures/zai-quota.json

@@ -0,0 +1,38 @@
+{
+  "success": true,
+  "code": 200,
+  "data": {
+    "limits": [
+      {
+        "type": "TOKENS_LIMIT",
+        "unit": 3,
+        "number": 5,
+        "percentage": 99,
+        "usage": 1000,
+        "currentValue": 200,
+        "remaining": 700,
+        "nextResetTime": 1787220000000
+      },
+      {
+        "type": "CREDIT_LIMIT",
+        "unit": 6,
+        "number": 1,
+        "percentage": 5,
+        "usage": 200,
+        "currentValue": 80,
+        "remaining": 150,
+        "nextResetTime": 1787824800000
+      },
+      {
+        "type": "TIME_LIMIT",
+        "unit": 5,
+        "number": 1,
+        "percentage": 25,
+        "usage": 100,
+        "currentValue": 20,
+        "remaining": 90,
+        "nextResetTime": 1789812000000
+      }
+    ]
+  }
+}

package/src/__tests__/capacity/index.test.ts

@@ -6,7 +6,8 @@ const checkedAt = "2026-08-09T10:00:00.000Z";
 describe("getCodexCapacityReport", () => {
   it("checks Codex installation before probing", async () => {
     const probe = vi.fn(async (context) => ({
-      provider: "codex",
+      harness: "codex",
+      provider: "openai",
       generatedAt: context.checkedAt,
       authenticated: true,
       available: "yes" as const,
@@ -24,7 +25,12 @@ describe("getCodexCapacityReport", () => {
     });
 
     expect(probe).toHaveBeenCalledWith({ installed: true, checkedAt });
-    expect(report).toMatchObject({ provider: "codex", generatedAt: checkedAt, available: "yes" });
+    expect(report).toMatchObject({
+      harness: "codex",
+      provider: "openai",
+      generatedAt: checkedAt,
+      available: "yes",
+    });
   });
 
   it("redacts unexpected probe failures into a stable unknown result", async () => {
@@ -37,7 +43,8 @@ describe("getCodexCapacityReport", () => {
     });
 
     expect(report).toMatchObject({
-      provider: "codex",
+      harness: "codex",
+      provider: "openai",
       available: "unknown",
       authenticated: null,
       windows: [],

package/src/__tests__/capacity/zai.test.ts

@@ -0,0 +1,186 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it, vi } from "vitest";
+import {
+  parseZaiQuota,
+  probeZaiCapacity,
+  resolveZaiApiKey,
+} from "../../capacity/zai.js";
+
+const checkedAt = "2026-08-20T10:00:00.000Z";
+const fixture = (name: string) =>
+  readFile(
+    fileURLToPath(new URL(`./fixtures/${name}`, import.meta.url)),
+    "utf8",
+  );
+
+describe("z.ai credential resolution", () => {
+  it("prefers Z_AI_API_KEY without reading Pi auth", async () => {
+    const readAuth = vi.fn(async () => fixture("zai-auth.json"));
+    await expect(
+      resolveZaiApiKey({
+        env: { Z_AI_API_KEY: "env-zai-test-key" },
+        readFile: readAuth,
+      }),
+    ).resolves.toBe("env-zai-test-key");
+    expect(readAuth).not.toHaveBeenCalled();
+  });
+
+  it("reads the Pi zai api_key credential from ~/.pi/agent/auth.json", async () => {
+    const readAuth = vi.fn(async () => fixture("zai-auth.json"));
+    await expect(
+      resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
+    ).resolves.toBe("pi-zai-test-key");
+    expect(readAuth).toHaveBeenCalledWith(
+      "/users/test/.pi/agent/auth.json",
+      "utf8",
+    );
+  });
+
+  it.each([
+    [
+      "missing",
+      async () =>
+        Promise.reject(Object.assign(new Error("missing"), { code: "ENOENT" })),
+    ],
+    ["invalid JSON", async () => "{"],
+    [
+      "wrong credential type",
+      async () => JSON.stringify({ zai: { type: "oauth", key: "x" } }),
+    ],
+    ["missing key", async () => JSON.stringify({ zai: { type: "api_key" } })],
+  ])(
+    "fails clearly for %s credentials without exposing file content",
+    async (_name, readAuth) => {
+      await expect(
+        resolveZaiApiKey({ env: { HOME: "/users/test" }, readFile: readAuth }),
+      ).rejects.toThrow(/z\.ai API key|z\.ai Pi auth file/);
+    },
+  );
+});
+
+describe("z.ai quota mapping", () => {
+  it("maps token, credit, and monthly MCP windows with recomputed usage", async () => {
+    const report = parseZaiQuota(
+      JSON.parse(await fixture("zai-quota.json")),
+      checkedAt,
+    );
+    expect(report).toMatchObject({
+      harness: "pi",
+      provider: "zai",
+      generatedAt: checkedAt,
+      authenticated: true,
+      available: "yes",
+      creditsRemaining: null,
+    });
+    expect(report.windows).toEqual([
+      {
+        id: "zai:tokens:1",
+        label: "Tokens · 5 hours",
+        limitType: "TOKENS_LIMIT",
+        durationMinutes: 300,
+        usedPercent: 30,
+        resetsAt: "2026-08-20T10:00:00.000Z",
+        total: 1000,
+        current: 200,
+        remaining: 700,
+      },
+      {
+        id: "zai:credit:2",
+        label: "Credit · 1 week",
+        limitType: "CREDIT_LIMIT",
+        durationMinutes: 10080,
+        usedPercent: 40,
+        resetsAt: "2026-08-27T10:00:00.000Z",
+        total: 200,
+        current: 80,
+        remaining: 150,
+      },
+      {
+        id: "zai:time:3",
+        label: "MCP · monthly",
+        limitType: "TIME_LIMIT",
+        durationMinutes: 43200,
+        usedPercent: 20,
+        resetsAt: "2026-09-19T10:00:00.000Z",
+        total: 100,
+        current: 20,
+        remaining: 90,
+      },
+    ]);
+  });
+
+  it("uses and clamps the server percentage when quota amounts are unavailable", () => {
+    const report = parseZaiQuota(
+      {
+        success: true,
+        code: 200,
+        data: {
+          limits: [
+            { type: "TOKENS_LIMIT", unit: 1, number: 1, percentage: 120 },
+            { type: "CREDIT_LIMIT", unit: 5, number: 30, percentage: -5 },
+          ],
+        },
+      },
+      checkedAt,
+    );
+    expect(report.windows.map((window) => window.usedPercent)).toEqual([
+      100, 0,
+    ]);
+  });
+
+  it.each([
+    [
+      "invalid fixture",
+      async () => JSON.parse(await fixture("zai-quota-invalid.json")),
+    ],
+    [
+      "unsuccessful envelope",
+      async () => ({ success: false, code: 401, data: { limits: [] } }),
+    ],
+    [
+      "invalid entry",
+      async () => ({ success: true, code: 200, data: { limits: [{}] } }),
+    ],
+  ])("rejects %s", async (_name, input) => {
+    const value = await input();
+    expect(() => parseZaiQuota(value, checkedAt)).toThrow(/z\.ai quota/);
+  });
+});
+
+describe("z.ai request", () => {
+  it("GETs the global quota endpoint with only Bearer authentication", async () => {
+    const body = await fixture("zai-quota.json");
+    const fetch = vi.fn(async () => new Response(body, { status: 200 }));
+    const report = await probeZaiCapacity({
+      checkedAt,
+      env: { Z_AI_API_KEY: "request-test-key" },
+      fetch,
+    });
+    expect(fetch).toHaveBeenCalledWith(
+      "https://api.z.ai/api/monitor/usage/quota/limit",
+      expect.objectContaining({
+        method: "GET",
+        headers: { Authorization: "Bearer request-test-key" },
+      }),
+    );
+    expect(JSON.stringify(report)).not.toContain("request-test-key");
+  });
+
+  it("rejects non-200 and malformed JSON responses with sanitized errors", async () => {
+    await expect(
+      probeZaiCapacity({
+        checkedAt,
+        env: { Z_AI_API_KEY: "never-expose-this-key" },
+        fetch: vi.fn(async () => new Response("private body", { status: 503 })),
+      }),
+    ).rejects.toThrow("z.ai quota request failed: HTTP 503");
+    await expect(
+      probeZaiCapacity({
+        checkedAt,
+        env: { Z_AI_API_KEY: "never-expose-this-key" },
+        fetch: vi.fn(async () => new Response("not-json", { status: 200 })),
+      }),
+    ).rejects.toThrow("z.ai quota response is not valid JSON");
+  });
+});

package/src/__tests__/providers/opencode/OpenCodeAdapter.test.ts

@@ -0,0 +1,197 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { OpenCodeAdapter } from "../../../providers/opencode/OpenCodeAdapter.js";
+
+describe("OpenCodeAdapter", () => {
+  let adapter: OpenCodeAdapter;
+  let tmpDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-adapter-test-"));
+    dbPath = path.join(tmpDir, "opencode.db");
+    adapter = new OpenCodeAdapter(dbPath);
+  });
+
+  afterEach(() => {
+    adapter.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("detects opencode executables", () => {
+    expect(adapter.canHandle({ pid: 1, command: "opencode", cwd: "/repo" })).toBe(true);
+    expect(adapter.canHandle({ pid: 2, command: "/usr/bin/opencode.exe", cwd: "/repo" })).toBe(
+      true,
+    );
+    expect(adapter.canHandle({ pid: 3, command: "node /repo/opencode-plugin.js" })).toBe(false);
+  });
+
+  it("returns process-only agents when the database is unavailable", async () => {
+    const agents = await adapter.detectAgents({
+      processes: [{ pid: 100, command: "opencode", cwd: "/repo", tty: "ttys001" }],
+    });
+
+    expect(agents).toEqual([
+      expect.objectContaining({
+        type: "opencode",
+        status: AgentStatus.RUNNING,
+        pid: 100,
+        projectPath: "/repo",
+        sessionId: "pid-100",
+        summary: "OpenCode process running",
+      }),
+    ]);
+  });
+
+  it("maps matching OpenCode sessions to agents", async () => {
+    const now = Date.now();
+    writeDatabase(dbPath, {
+      sessions: [{ id: "sess-001", directory: "/repo", timeCreated: now - 60_000 }],
+      messages: [
+        {
+          id: "msg-user",
+          sessionId: "sess-001",
+          role: "user",
+          timeCreated: now - 50_000,
+          timeUpdated: now - 50_000,
+        },
+        {
+          id: "msg-assistant",
+          sessionId: "sess-001",
+          role: "assistant",
+          timeCreated: now - 30_000,
+          timeUpdated: now - 30_000,
+          completed: now - 20_000,
+        },
+      ],
+      parts: [
+        {
+          messageId: "msg-user",
+          sessionId: "sess-001",
+          type: "text",
+          text: "Refactor this module",
+          timeCreated: now - 50_000,
+        },
+      ],
+    });
+
+    const process: ProcessInfo = { pid: 200, command: "opencode", cwd: "/repo", tty: "ttys002" };
+    const [agent] = await adapter.detectAgents({ processes: [process] });
+
+    expect(agent).toMatchObject({
+      type: "opencode",
+      status: AgentStatus.WAITING,
+      pid: 200,
+      projectPath: "/repo",
+      sessionId: "sess-001",
+      summary: "Refactor this module",
+      sessionFilePath: `${dbPath}::sess-001`,
+    });
+  });
+
+  it("returns conversation messages for encoded OpenCode session refs", () => {
+    writeDatabase(dbPath, {
+      sessions: [{ id: "sess-abc", directory: "/repo", timeCreated: Date.now() }],
+      messages: [
+        {
+          id: "msg-user",
+          sessionId: "sess-abc",
+          role: "user",
+          timeCreated: 1000,
+          timeUpdated: 1000,
+        },
+      ],
+      parts: [
+        {
+          messageId: "msg-user",
+          sessionId: "sess-abc",
+          type: "text",
+          text: "Hello agent",
+          timeCreated: 1000,
+        },
+      ],
+    });
+
+    expect(adapter.getConversation(`${dbPath}::sess-abc`)).toEqual([
+      { role: "user", content: "Hello agent" },
+    ]);
+    expect(adapter.getConversation("/not-an-opencode-ref")).toEqual([]);
+  });
+});
+
+function writeDatabase(
+  filePath: string,
+  data: {
+    sessions: Array<{ id: string; directory: string; timeCreated: number }>;
+    messages?: Array<{
+      id: string;
+      sessionId: string;
+      role: string;
+      timeCreated: number;
+      timeUpdated: number;
+      completed?: number;
+    }>;
+    parts?: Array<{
+      messageId: string;
+      sessionId: string;
+      type: string;
+      text?: string;
+      reasoning?: string;
+      tool?: string;
+      timeCreated: number;
+    }>;
+  },
+): void {
+  const db = new Database(filePath);
+  db.exec(`
+    CREATE TABLE session (id TEXT, directory TEXT, time_created INTEGER);
+    CREATE TABLE message (id TEXT, session_id TEXT, data TEXT, time_created INTEGER, time_updated INTEGER);
+    CREATE TABLE part (message_id TEXT, session_id TEXT, data TEXT, time_created INTEGER);
+  `);
+
+  const insertSession = db.prepare(
+    "INSERT INTO session (id, directory, time_created) VALUES (?, ?, ?)",
+  );
+  for (const session of data.sessions) {
+    insertSession.run(session.id, session.directory, session.timeCreated);
+  }
+
+  const insertMessage = db.prepare(
+    "INSERT INTO message (id, session_id, data, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+  );
+  for (const message of data.messages ?? []) {
+    insertMessage.run(
+      message.id,
+      message.sessionId,
+      JSON.stringify({
+        role: message.role,
+        time: message.completed === undefined ? {} : { completed: message.completed },
+      }),
+      message.timeCreated,
+      message.timeUpdated,
+    );
+  }
+
+  const insertPart = db.prepare(
+    "INSERT INTO part (message_id, session_id, data, time_created) VALUES (?, ?, ?, ?)",
+  );
+  for (const part of data.parts ?? []) {
+    insertPart.run(
+      part.messageId,
+      part.sessionId,
+      JSON.stringify({
+        type: part.type,
+        text: part.text,
+        reasoning: part.reasoning,
+        tool: part.tool,
+      }),
+      part.timeCreated,
+    );
+  }
+
+  db.close();
+}

package/src/__tests__/providers/opencode/OpenCodeAgentMapper.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import { OpenCodeAgentMapper } from "../../../providers/opencode/OpenCodeAgentMapper.js";
+
+describe("OpenCodeAgentMapper", () => {
+  const mapper = new OpenCodeAgentMapper("/tmp/opencode.db");
+
+  it("maps completed assistant sessions as waiting", () => {
+    const now = Date.now();
+
+    const agent = mapper.mapSessionToAgent(
+      { sessionId: "sess-1", directory: "/repo", timeCreated: now - 60_000 },
+      {
+        lastRole: "assistant",
+        lastTimeUpdated: now - 30_000,
+        lastAssistantCompleted: true,
+        lastAssistantErrored: false,
+        summary: "Ship the feature",
+      },
+      { pid: 123, command: "opencode", cwd: "/repo" },
+    );
+
+    expect(agent).toMatchObject({
+      type: "opencode",
+      status: AgentStatus.WAITING,
+      summary: "Ship the feature",
+      pid: 123,
+      projectPath: "/repo",
+      sessionId: "sess-1",
+      sessionFilePath: "/tmp/opencode.db::sess-1",
+    });
+  });
+
+  it("keeps incomplete assistant sessions running even when they are quiet briefly", () => {
+    const now = Date.now();
+
+    const agent = mapper.mapSessionToAgent(
+      { sessionId: "sess-2", directory: "/repo", timeCreated: now - 120_000 },
+      {
+        lastRole: "assistant",
+        lastTimeUpdated: now - 120_000,
+        lastAssistantCompleted: false,
+        lastAssistantErrored: false,
+        summary: "",
+      },
+      { pid: 124, command: "opencode", cwd: "/repo" },
+    );
+
+    expect(agent.status).toBe(AgentStatus.RUNNING);
+    expect(agent.summary).toBe("OpenCode session active");
+  });
+
+  it("marks stale sessions idle", () => {
+    const staleTime = Date.now() - 10 * 60 * 1000;
+
+    const agent = mapper.mapSessionToAgent(
+      { sessionId: "sess-3", directory: "/old", timeCreated: staleTime },
+      {
+        lastRole: "assistant",
+        lastTimeUpdated: staleTime,
+        lastAssistantCompleted: true,
+        lastAssistantErrored: false,
+        summary: "",
+      },
+      { pid: 125, command: "opencode", cwd: "/old" },
+    );
+
+    expect(agent.status).toBe(AgentStatus.IDLE);
+  });
+
+  it("maps unmatched processes as running process-only agents", () => {
+    const agent = mapper.mapProcessOnlyAgent({ pid: 500, command: "opencode", cwd: "/repo" });
+
+    expect(agent).toMatchObject({
+      type: "opencode",
+      status: AgentStatus.RUNNING,
+      summary: "OpenCode process running",
+      pid: 500,
+      projectPath: "/repo",
+      sessionId: "pid-500",
+    });
+  });
+});

package/src/__tests__/providers/opencode/OpenCodeSessionLocator.test.ts

@@ -0,0 +1,84 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { OpenCodeSessionLocator } from "../../../providers/opencode/OpenCodeSessionLocator.js";
+import { OpenCodeSessionParser } from "../../../providers/opencode/OpenCodeSessionParser.js";
+
+describe("OpenCodeSessionLocator", () => {
+  let tmpDir: string;
+  let dbPath: string;
+  let locator: OpenCodeSessionLocator;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-locator-test-"));
+    dbPath = path.join(tmpDir, "opencode.db");
+    locator = new OpenCodeSessionLocator(dbPath, new OpenCodeSessionParser());
+  });
+
+  afterEach(() => {
+    locator.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns null when the database file does not exist", () => {
+    expect(locator.openDb()).toBeNull();
+    expect(locator.listSessions()).toEqual([]);
+  });
+
+  it("finds the newest session for a directory", () => {
+    writeDatabase(dbPath, [
+      { id: "old", directory: "/repo", timeCreated: 1000 },
+      { id: "new", directory: "/repo", timeCreated: 2000 },
+      { id: "other", directory: "/other", timeCreated: 3000 },
+    ]);
+
+    const db = locator.openDb();
+    expect(db).not.toBeNull();
+    expect(locator.findSessionForDirectory(db!, "/repo")).toEqual({
+      sessionId: "new",
+      directory: "/repo",
+      timeCreated: 2000,
+    });
+  });
+
+  it("lists sessions and filters by cwd", () => {
+    writeDatabase(dbPath, [
+      { id: "sess-a", directory: "/repo-a", timeCreated: 1000 },
+      { id: "sess-b", directory: "/repo-b", timeCreated: 2000 },
+    ]);
+
+    const sessions = locator.listSessions({ cwd: "/repo-a" });
+
+    expect(sessions).toEqual([
+      expect.objectContaining({
+        type: "opencode",
+        sessionId: "sess-a",
+        cwd: "/repo-a",
+        sessionFilePath: `${dbPath}::sess-a`,
+      }),
+    ]);
+  });
+});
+
+function writeDatabase(
+  filePath: string,
+  sessions: Array<{ id: string; directory: string; timeCreated: number }>,
+): void {
+  const db = new Database(filePath);
+  db.exec(`
+    CREATE TABLE session (id TEXT, directory TEXT, time_created INTEGER);
+    CREATE TABLE message (id TEXT, session_id TEXT, data TEXT, time_created INTEGER, time_updated INTEGER);
+    CREATE TABLE part (message_id TEXT, session_id TEXT, data TEXT, time_created INTEGER);
+  `);
+
+  const insertSession = db.prepare(
+    "INSERT INTO session (id, directory, time_created) VALUES (?, ?, ?)",
+  );
+  for (const session of sessions) {
+    insertSession.run(session.id, session.directory, session.timeCreated);
+  }
+
+  db.close();
+}