alvin-bot 4.18.0 → 4.18.1

package/test/async-agent-parser.test.ts

@@ -1,322 +0,0 @@
-/**
- * Fix #17 (Stage 2) — async-agent-parser unit tests.
- *
- * Two pure helpers:
- *   parseAsyncLaunchedToolResult(text) → { agentId, outputFile } | null
- *   parseOutputFileStatus(path) → { state: "running"|"completed"|"failed"|"missing" }
- *
- * Format details captured from the live SDK probe in
- * docs/superpowers/specs/sdk-async-agent-outputfile-format.md
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-import {
-  parseAsyncLaunchedToolResult,
-  parseOutputFileStatus,
-} from "../src/services/async-agent-parser.js";
-
-describe("parseAsyncLaunchedToolResult — plain text format (Stage 2)", () => {
-  it("extracts agentId and output_file from the real SDK tool-result text", () => {
-    const text = `Async agent launched successfully.
-agentId: a9e9c5913b2faec71 (internal ID - do not mention to user. Use SendMessage with to: 'a9e9c5913b2faec71' to continue this agent.)
-The agent is working in the background. You will be notified automatically when it completes.
-Do not duplicate this agent's work — avoid working with the same files or topics it is using.
-output_file: /private/tmp/claude-502/-Users-alvin-de-Projects-alvin-bot/abc/tasks/a9e9c5913b2faec71.output
-If asked, you can check progress before completion by using Read or Bash tail on the output file.`;
-
-    const info = parseAsyncLaunchedToolResult(text);
-    expect(info).not.toBeNull();
-    expect(info?.agentId).toBe("a9e9c5913b2faec71");
-    expect(info?.outputFile).toBe(
-      "/private/tmp/claude-502/-Users-alvin-de-Projects-alvin-bot/abc/tasks/a9e9c5913b2faec71.output",
-    );
-  });
-
-  it("returns null for ordinary tool result text (e.g. Read output)", () => {
-    expect(parseAsyncLaunchedToolResult("file contents here")).toBeNull();
-  });
-
-  it("returns null for an empty string", () => {
-    expect(parseAsyncLaunchedToolResult("")).toBeNull();
-  });
-
-  it("returns null when the marker line is missing", () => {
-    expect(
-      parseAsyncLaunchedToolResult("agentId: x\noutput_file: /tmp/a"),
-    ).toBeNull();
-  });
-
-  it("returns null when output_file line is missing", () => {
-    const text =
-      "Async agent launched successfully.\nagentId: abc123\nMore prose";
-    expect(parseAsyncLaunchedToolResult(text)).toBeNull();
-  });
-
-  it("returns null when agentId line is missing", () => {
-    const text =
-      "Async agent launched successfully.\noutput_file: /tmp/a\nMore prose";
-    expect(parseAsyncLaunchedToolResult(text)).toBeNull();
-  });
-
-  it("trims whitespace around extracted values", () => {
-    const text = `Async agent launched successfully.
-agentId:    abc-with-spaces   (something)
-output_file:    /tmp/path with spaces.output   `;
-    const info = parseAsyncLaunchedToolResult(text);
-    expect(info?.agentId).toBe("abc-with-spaces");
-    // Path can contain spaces — we just trim leading/trailing
-    expect(info?.outputFile).toBe("/tmp/path with spaces.output");
-  });
-
-  it("handles input that is an array of content blocks (Anthropic SDK shape)", () => {
-    const blocks = [
-      { type: "text", text: "Async agent launched successfully.\nagentId: id1\noutput_file: /tmp/o1\n" },
-    ];
-    const info = parseAsyncLaunchedToolResult(blocks);
-    expect(info?.agentId).toBe("id1");
-    expect(info?.outputFile).toBe("/tmp/o1");
-  });
-
-  it("handles non-string input gracefully", () => {
-    expect(parseAsyncLaunchedToolResult(null)).toBeNull();
-    expect(parseAsyncLaunchedToolResult(undefined)).toBeNull();
-    expect(parseAsyncLaunchedToolResult(42 as unknown as string)).toBeNull();
-  });
-});
-
-const TMP_BASE = resolve(os.tmpdir(), `alvin-parser-${process.pid}`);
-
-beforeEach(() => {
-  fs.mkdirSync(TMP_BASE, { recursive: true });
-});
-
-afterEach(() => {
-  try {
-    fs.rmSync(TMP_BASE, { recursive: true, force: true });
-  } catch { /* ignore */ }
-});
-
-async function writeJsonl(name: string, lines: object[]): Promise<string> {
-  const path = resolve(TMP_BASE, name);
-  fs.writeFileSync(
-    path,
-    lines.map((l) => JSON.stringify(l)).join("\n") + "\n",
-    "utf-8",
-  );
-  return path;
-}
-
-describe("parseOutputFileStatus — JSONL completion detection (Stage 2)", () => {
-  it("returns 'missing' when the file doesn't exist", async () => {
-    const status = await parseOutputFileStatus(`${TMP_BASE}/nonexistent.jsonl`);
-    expect(status.state).toBe("missing");
-  });
-
-  it("returns 'missing' for an empty file", async () => {
-    const path = resolve(TMP_BASE, "empty.jsonl");
-    fs.writeFileSync(path, "", "utf-8");
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("missing");
-  });
-
-  it("returns 'running' when the file has events but no end_turn", async () => {
-    const path = await writeJsonl("running.jsonl", [
-      {
-        type: "user",
-        isSidechain: true,
-        agentId: "x",
-        message: { role: "user", content: "do the thing" },
-      },
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [{ type: "tool_use", name: "Bash", input: { command: "ls" } }],
-          stop_reason: "tool_use",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("running");
-  });
-
-  it("returns 'completed' with the final text when stop_reason is end_turn", async () => {
-    const path = await writeJsonl("completed.jsonl", [
-      {
-        type: "user",
-        isSidechain: true,
-        agentId: "x",
-        message: { role: "user", content: "p" },
-      },
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "Final report: it works!" }],
-          stop_reason: "end_turn",
-          usage: { input_tokens: 100, output_tokens: 50 },
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toContain("Final report: it works!");
-      expect(status.tokensUsed).toEqual({ input: 100, output: 50 });
-    }
-  });
-
-  it("concatenates multiple text blocks in the final assistant message", async () => {
-    const path = await writeJsonl("multi-block.jsonl", [
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [
-            { type: "thinking", text: "let me think" },
-            { type: "text", text: "Part one." },
-            { type: "text", text: "Part two." },
-          ],
-          stop_reason: "end_turn",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("Part one.\n\nPart two.");
-      // thinking blocks are NOT included
-      expect(status.output).not.toContain("let me think");
-    }
-  });
-
-  it("ignores assistant messages with stop_reason !== end_turn (still running)", async () => {
-    const path = await writeJsonl("intermediate.jsonl", [
-      {
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "checking..." }],
-          stop_reason: "tool_use",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("running");
-  });
-
-  it("uses the LAST end_turn assistant message when there are multiple turns", async () => {
-    const path = await writeJsonl("multi-turn.jsonl", [
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "first answer" }],
-          stop_reason: "end_turn",
-        },
-      },
-      {
-        type: "user",
-        agentId: "x",
-        message: { content: [{ type: "tool_result", content: "..." }] },
-      },
-      {
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "second and final answer" }],
-          stop_reason: "end_turn",
-        },
-      },
-    ]);
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("second and final answer");
-    }
-  });
-
-  it("survives partial final lines (mid-write)", async () => {
-    const path = resolve(TMP_BASE, "partial.jsonl");
-    fs.writeFileSync(
-      path,
-      JSON.stringify({
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "checking" }],
-          stop_reason: "tool_use",
-        },
-      }) +
-        "\n" +
-        '{"type":"assistant","agentId":"x","mes',
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    // Partial line is ignored; only the complete event counts
-    expect(status.state).toBe("running");
-  });
-
-  it("survives unparseable lines (skip them, keep checking)", async () => {
-    const path = resolve(TMP_BASE, "garbage.jsonl");
-    fs.writeFileSync(
-      path,
-      "garbage line\n" +
-        JSON.stringify({
-          type: "assistant",
-          agentId: "x",
-          message: {
-            content: [{ type: "text", text: "the answer" }],
-            stop_reason: "end_turn",
-          },
-        }) +
-        "\n",
-      "utf-8",
-    );
-    const status = await parseOutputFileStatus(path);
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("the answer");
-    }
-  });
-
-  it("only tail-reads large files (does not load entire content into memory)", async () => {
-    const path = resolve(TMP_BASE, "huge.jsonl");
-    // Write a 200KB padding stream of 'running' events, then an end_turn
-    const padding = JSON.stringify({
-      type: "assistant",
-      agentId: "x",
-      message: { content: [{ type: "text", text: "x".repeat(500) }], stop_reason: "tool_use" },
-    });
-    let buf = "";
-    for (let i = 0; i < 200; i++) buf += padding + "\n";
-    buf +=
-      JSON.stringify({
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "FINAL" }],
-          stop_reason: "end_turn",
-        },
-      }) + "\n";
-    fs.writeFileSync(path, buf, "utf-8");
-    expect(fs.statSync(path).size).toBeGreaterThan(100_000);
-
-    const status = await parseOutputFileStatus(path, { maxTailBytes: 8192 });
-    // Tail should still find the last end_turn
-    expect(status.state).toBe("completed");
-    if (status.state === "completed") {
-      expect(status.output).toBe("FINAL");
-    }
-  });
-});

package/test/async-agent-watcher.test.ts

@@ -1,229 +0,0 @@
-/**
- * Fix #17 (Stage 2) — async-agent-watcher integration tests.
- *
- * The watcher polls outputFiles of pending agents, detects completion,
- * delivers via subagent-delivery.ts, and persists state to disk so the
- * pending list survives bot restarts.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-
-const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-async-watcher-${process.pid}-${Date.now()}`);
-
-interface DeliveredCall {
-  info: { name: string; source?: string; parentChatId?: number; status?: string };
-  result: { status: string; output: string; duration: number; error?: string };
-}
-
-let delivered: DeliveredCall[] = [];
-
-beforeEach(async () => {
-  if (fs.existsSync(TEST_DATA_DIR)) fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
-  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
-  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
-  delivered = [];
-  vi.resetModules();
-  vi.doMock("../src/services/subagent-delivery.js", () => ({
-    deliverSubAgentResult: async (info: unknown, result: unknown) => {
-      delivered.push({ info: info as DeliveredCall["info"], result: result as DeliveredCall["result"] });
-    },
-    attachBotApi: () => {},
-    __setBotApiForTest: () => {},
-  }));
-});
-
-afterEach(async () => {
-  try {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.stopWatcher();
-    mod.__resetForTest();
-  } catch { /* ignore */ }
-});
-
-function writeCompletedJsonl(path: string, finalText: string): void {
-  const lines = [
-    JSON.stringify({
-      type: "user",
-      isSidechain: true,
-      agentId: "x",
-      message: { role: "user", content: "do it" },
-    }),
-    JSON.stringify({
-      type: "assistant",
-      isSidechain: true,
-      agentId: "x",
-      message: {
-        role: "assistant",
-        content: [{ type: "text", text: finalText }],
-        stop_reason: "end_turn",
-        usage: { input_tokens: 100, output_tokens: 50 },
-      },
-    }),
-  ].join("\n") + "\n";
-  fs.mkdirSync(resolve(path, ".."), { recursive: true });
-  fs.writeFileSync(path, lines, "utf-8");
-}
-
-describe("async-agent-watcher (Stage 2)", () => {
-  it("registers a pending agent and persists it to disk", async () => {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.registerPendingAgent({
-      agentId: "abc-1",
-      outputFile: `${TEST_DATA_DIR}/out-abc-1.jsonl`,
-      description: "Test SEO audit",
-      prompt: "do a test",
-      chatId: 42,
-      userId: 42,
-      toolUseId: "toolu_1",
-    });
-    const stateFile = `${TEST_DATA_DIR}/state/async-agents.json`;
-    expect(fs.existsSync(stateFile)).toBe(true);
-    const parsed = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
-    expect(parsed).toHaveLength(1);
-    expect(parsed[0].agentId).toBe("abc-1");
-    expect(parsed[0].description).toBe("Test SEO audit");
-  });
-
-  it("delivers a pending agent when its outputFile completes", async () => {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    const outPath = `${TEST_DATA_DIR}/out-abc-2.jsonl`;
-    mod.registerPendingAgent({
-      agentId: "abc-2",
-      outputFile: outPath,
-      description: "quick task",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-    });
-    writeCompletedJsonl(outPath, "Here is the report");
-
-    await mod.pollOnce();
-
-    expect(delivered).toHaveLength(1);
-    expect(delivered[0].info.name).toBe("quick task");
-    expect(delivered[0].result.output).toContain("Here is the report");
-    expect(delivered[0].result.status).toBe("completed");
-  });
-
-  it("removes a pending agent from persistence after delivery", async () => {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    const outPath = `${TEST_DATA_DIR}/out-abc-3.jsonl`;
-    mod.registerPendingAgent({
-      agentId: "abc-3",
-      outputFile: outPath,
-      description: "cleanup test",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-    });
-    writeCompletedJsonl(outPath, "done");
-    await mod.pollOnce();
-
-    const stateFile = `${TEST_DATA_DIR}/state/async-agents.json`;
-    const state = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
-    expect(state).toHaveLength(0);
-  });
-
-  it("loads pending agents from disk at startup (bot restart catchup)", async () => {
-    fs.mkdirSync(`${TEST_DATA_DIR}/state`, { recursive: true });
-    const outPath = `${TEST_DATA_DIR}/out-preexisting.jsonl`;
-    fs.writeFileSync(
-      `${TEST_DATA_DIR}/state/async-agents.json`,
-      JSON.stringify([
-        {
-          agentId: "preexisting",
-          outputFile: outPath,
-          description: "Survived restart",
-          prompt: "p",
-          chatId: 42,
-          userId: 42,
-          startedAt: Date.now() - 5000,
-          lastCheckedAt: Date.now() - 1000,
-          giveUpAt: Date.now() + 86_400_000,
-          toolUseId: null,
-        },
-      ]),
-    );
-    writeCompletedJsonl(outPath, "result from earlier session");
-
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.startWatcher();
-    await mod.pollOnce();
-
-    expect(delivered).toHaveLength(1);
-    expect(delivered[0].info.name).toBe("Survived restart");
-    expect(delivered[0].result.output).toContain("result from earlier session");
-  });
-
-  it("gives up on agents older than giveUpAt and delivers a timeout banner", async () => {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    const outPath = `${TEST_DATA_DIR}/out-timeout.jsonl`;
-    mod.registerPendingAgent({
-      agentId: "abc-4",
-      outputFile: outPath,
-      description: "forever task",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-      giveUpAt: Date.now() - 1000,
-    });
-    // File never exists
-    await mod.pollOnce();
-
-    expect(delivered).toHaveLength(1);
-    expect(delivered[0].result.status).toBe("timeout");
-    expect(delivered[0].info.status).toBe("timeout");
-  });
-
-  it("multiple concurrent pending agents all get delivered as they complete", async () => {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    const outA = `${TEST_DATA_DIR}/out-a.jsonl`;
-    const outB = `${TEST_DATA_DIR}/out-b.jsonl`;
-    const outC = `${TEST_DATA_DIR}/out-c.jsonl`;
-    mod.registerPendingAgent({
-      agentId: "a", outputFile: outA, description: "A",
-      prompt: "p", chatId: 1, userId: 1, toolUseId: null,
-    });
-    mod.registerPendingAgent({
-      agentId: "b", outputFile: outB, description: "B",
-      prompt: "p", chatId: 2, userId: 2, toolUseId: null,
-    });
-    mod.registerPendingAgent({
-      agentId: "c", outputFile: outC, description: "C",
-      prompt: "p", chatId: 3, userId: 3, toolUseId: null,
-    });
-
-    writeCompletedJsonl(outA, "A done");
-    writeCompletedJsonl(outB, "B done");
-    // C still pending
-
-    await mod.pollOnce();
-    expect(delivered).toHaveLength(2);
-    expect(delivered.map((d) => d.info.name).sort()).toEqual(["A", "B"]);
-
-    writeCompletedJsonl(outC, "C done");
-    await mod.pollOnce();
-    expect(delivered).toHaveLength(3);
-  });
-
-  it("listPendingAgents reflects in-memory state", async () => {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    expect(mod.listPendingAgents()).toEqual([]);
-    mod.registerPendingAgent({
-      agentId: "x",
-      outputFile: `${TEST_DATA_DIR}/out-x.jsonl`,
-      description: "test",
-      prompt: "p",
-      chatId: 1,
-      userId: 1,
-      toolUseId: null,
-    });
-    expect(mod.listPendingAgents()).toHaveLength(1);
-    expect(mod.listPendingAgents()[0].agentId).toBe("x");
-  });
-});