alvin-bot 4.18.0 → 4.18.2

package/test/watcher-pending-count.test.ts

@@ -1,228 +0,0 @@
-/**
- * v4.12.3 — async-agent watcher ↔ session.pendingBackgroundCount wiring.
- *
- * Contract:
- *   - registerPendingAgent takes an optional `sessionKey` so the watcher
- *     can locate the right UserSession later.
- *   - When the watcher delivers a result (completed/failed/timeout), the
- *     session's pendingBackgroundCount MUST be decremented so the main
- *     handler knows it's safe to resume SDK-session-based queries.
- *   - Decrement is clamped at 0 — the counter never goes negative even
- *     if decoupled operations drift.
- *   - The handler is responsible for INCREMENTING when it registers.
- *     The watcher only decrements.
- *
- * These tests use the shared in-memory session Map from session.ts so
- * they exercise the actual wiring, not a mock.
- */
-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-watcher-pending-${process.pid}-${Date.now()}`,
-);
-
-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;
-  vi.resetModules();
-  vi.doMock("../src/services/subagent-delivery.js", () => ({
-    deliverSubAgentResult: async () => {},
-    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: 10, output_tokens: 5 },
-        },
-      }),
-    ].join("\n") + "\n";
-  fs.mkdirSync(resolve(path, ".."), { recursive: true });
-  fs.writeFileSync(path, lines, "utf-8");
-}
-
-describe("watcher ↔ session.pendingBackgroundCount (v4.12.3)", () => {
-  it("completed delivery decrements pendingBackgroundCount on the right session", async () => {
-    const { getSession } = await import("../src/services/session.js");
-    const watcher = await import("../src/services/async-agent-watcher.js");
-
-    const sessionKey = "v412-session-a";
-    const session = getSession(sessionKey);
-    session.pendingBackgroundCount = 1;
-
-    const outPath = `${TEST_DATA_DIR}/out-a.jsonl`;
-    watcher.registerPendingAgent({
-      agentId: "a",
-      outputFile: outPath,
-      description: "research",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-      sessionKey,
-    });
-
-    writeCompletedJsonl(outPath, "result");
-    await watcher.pollOnce();
-
-    expect(session.pendingBackgroundCount).toBe(0);
-  });
-
-  it("timeout delivery also decrements the counter", async () => {
-    const { getSession } = await import("../src/services/session.js");
-    const watcher = await import("../src/services/async-agent-watcher.js");
-
-    const sessionKey = "v412-session-timeout";
-    const session = getSession(sessionKey);
-    session.pendingBackgroundCount = 2;
-
-    watcher.registerPendingAgent({
-      agentId: "timed-out",
-      outputFile: `${TEST_DATA_DIR}/never-written.jsonl`,
-      description: "slow task",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-      sessionKey,
-      giveUpAt: Date.now() - 1000,
-    });
-
-    await watcher.pollOnce();
-
-    expect(session.pendingBackgroundCount).toBe(1);
-  });
-
-  it("failure delivery decrements the counter", async () => {
-    const { getSession } = await import("../src/services/session.js");
-    const watcher = await import("../src/services/async-agent-watcher.js");
-
-    const sessionKey = "v412-session-fail";
-    const session = getSession(sessionKey);
-    session.pendingBackgroundCount = 3;
-
-    const outPath = `${TEST_DATA_DIR}/fail.jsonl`;
-    // Write a malformed "error" state — a single invalid line that will
-    // fall through the parser and stay in "running" state. Then mark
-    // the session as a timeout by moving giveUpAt into the past.
-    // Actually easier: use giveUpAt again as the trigger.
-    watcher.registerPendingAgent({
-      agentId: "fail-via-timeout",
-      outputFile: outPath,
-      description: "will fail",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-      sessionKey,
-      giveUpAt: Date.now() - 1000,
-    });
-
-    await watcher.pollOnce();
-
-    expect(session.pendingBackgroundCount).toBe(2);
-  });
-
-  it("decrement is clamped at 0 — counter never goes negative", async () => {
-    const { getSession } = await import("../src/services/session.js");
-    const watcher = await import("../src/services/async-agent-watcher.js");
-
-    const sessionKey = "v412-session-drift";
-    const session = getSession(sessionKey);
-    session.pendingBackgroundCount = 0; // drift scenario
-
-    const outPath = `${TEST_DATA_DIR}/drift.jsonl`;
-    watcher.registerPendingAgent({
-      agentId: "drift",
-      outputFile: outPath,
-      description: "drift",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-      sessionKey,
-    });
-    writeCompletedJsonl(outPath, "done");
-    await watcher.pollOnce();
-
-    expect(session.pendingBackgroundCount).toBe(0);
-  });
-
-  it("missing sessionKey is handled gracefully — no throw, no crash", async () => {
-    const watcher = await import("../src/services/async-agent-watcher.js");
-    const outPath = `${TEST_DATA_DIR}/orphan.jsonl`;
-    watcher.registerPendingAgent({
-      agentId: "orphan",
-      outputFile: outPath,
-      description: "orphan",
-      prompt: "p",
-      chatId: 42,
-      userId: 42,
-      toolUseId: null,
-      // sessionKey intentionally omitted
-    });
-    writeCompletedJsonl(outPath, "done");
-    await expect(watcher.pollOnce()).resolves.not.toThrow();
-  });
-
-  it("multiple agents for the same session all decrement", async () => {
-    const { getSession } = await import("../src/services/session.js");
-    const watcher = await import("../src/services/async-agent-watcher.js");
-
-    const sessionKey = "v412-session-multi";
-    const session = getSession(sessionKey);
-    session.pendingBackgroundCount = 3;
-
-    for (const id of ["m1", "m2", "m3"]) {
-      const outPath = `${TEST_DATA_DIR}/${id}.jsonl`;
-      watcher.registerPendingAgent({
-        agentId: id,
-        outputFile: outPath,
-        description: `task ${id}`,
-        prompt: "p",
-        chatId: 42,
-        userId: 42,
-        toolUseId: null,
-        sessionKey,
-      });
-      writeCompletedJsonl(outPath, `result ${id}`);
-    }
-
-    await watcher.pollOnce();
-
-    expect(session.pendingBackgroundCount).toBe(0);
-  });
-});

package/test/watcher-zombie-fix.test.ts

@@ -1,252 +0,0 @@
-/**
- * v4.14.2 — zombie-entry fix for async-agent-watcher.
- *
- * Problem: when the dispatched `claude -p` subprocess never produces
- * its outputFile (crashed before the first write, spawn failed, file
- * got deleted externally), `parseOutputFileStatus` returns "missing"
- * on every poll. The watcher keeps polling forever until `giveUpAt`
- * (12 hours) fires, then delivers a timeout banner. Meanwhile the
- * entry hangs in `/subagents list` as a permanent "running" zombie.
- *
- * Fix: when status is "missing" for longer than
- * `MISSING_FILE_FAILURE_MS` (default 10 min, env-configurable), the
- * watcher declares the agent failed with a clear "output file never
- * appeared" reason, delivers the failure banner, and removes the
- * entry. 10 minutes is well above normal startup variance (seconds)
- * and well below the 12h hard ceiling.
- *
- * Invariants preserved:
- *   - An agent whose output file DOES appear, even slowly, continues
- *     normally (missing on first poll, running on second, completed
- *     on third — same as v4.14.1).
- *   - The `completed` path (end_turn or stream-json result) is
- *     unchanged.
- *   - The `failed` path (existing "error" state from parser) is
- *     unchanged.
- *   - The 12h giveUpAt ceiling still applies — it's now just less
- *     likely to be hit because missing-file zombies resolve earlier.
- */
-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-zombie-${process.pid}-${Date.now()}`,
-);
-
-interface Delivered {
-  info: { name: string; status: string };
-  result: { status: string; output: string; error?: string };
-}
-let delivered: Delivered[] = [];
-
-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;
-  // Reset the env override between tests
-  delete process.env.ALVIN_MISSING_FILE_FAILURE_MS;
-  delivered = [];
-  vi.resetModules();
-  vi.doMock("../src/services/subagent-delivery.js", () => ({
-    deliverSubAgentResult: async (info: unknown, result: unknown) => {
-      delivered.push({
-        info: info as Delivered["info"],
-        result: result as Delivered["result"],
-      });
-    },
-    attachBotApi: () => {},
-    __setBotApiForTest: () => {},
-  }));
-});
-
-afterEach(async () => {
-  try {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.stopWatcher();
-    mod.__resetForTest();
-  } catch {}
-  delete process.env.ALVIN_MISSING_FILE_FAILURE_MS;
-});
-
-describe("watcher zombie fix (v4.14.2)", () => {
-  it("missing file younger than threshold stays pending (no premature fail)", async () => {
-    // Threshold = 10 min. Backdate only 2 min. Expect: still pending.
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.registerPendingAgent({
-      agentId: "young-zombie",
-      outputFile: `${TEST_DATA_DIR}/nonexistent.jsonl`,
-      description: "young",
-      prompt: "p",
-      chatId: 1,
-      userId: 1,
-      toolUseId: null,
-    });
-    // Forcibly set startedAt to 2 min ago
-    const pending = mod.listPendingAgents();
-    expect(pending).toHaveLength(1);
-    (pending[0] as { startedAt: number }).startedAt = Date.now() - 2 * 60_000;
-
-    await mod.pollOnce();
-
-    expect(delivered).toHaveLength(0);
-    expect(mod.listPendingAgents()).toHaveLength(1);
-  });
-
-  it("missing file older than threshold delivers failed + removes from pending", async () => {
-    process.env.ALVIN_MISSING_FILE_FAILURE_MS = "120000"; // 2 min for test
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.registerPendingAgent({
-      agentId: "old-zombie",
-      outputFile: `${TEST_DATA_DIR}/never-appears.jsonl`,
-      description: "stuck crash zombie",
-      prompt: "p",
-      chatId: 1,
-      userId: 1,
-      toolUseId: null,
-    });
-    // Backdate 5 min (> 2 min threshold)
-    const pending = mod.listPendingAgents();
-    (pending[0] as { startedAt: number }).startedAt = Date.now() - 5 * 60_000;
-
-    await mod.pollOnce();
-
-    expect(delivered).toHaveLength(1);
-    expect(delivered[0].result.status).toBe("error");
-    // Error message should be explicit so user understands
-    expect(delivered[0].result.error).toMatch(/output file|never appeared|never wrote/i);
-    expect(mod.listPendingAgents()).toHaveLength(0);
-  });
-
-  it("default threshold is 10 min when env var is not set", async () => {
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.registerPendingAgent({
-      agentId: "at-default",
-      outputFile: `${TEST_DATA_DIR}/z.jsonl`,
-      description: "default threshold",
-      prompt: "p",
-      chatId: 1,
-      userId: 1,
-      toolUseId: null,
-    });
-    // Backdate 9 min — still under the 10-min default, should stay pending
-    let p = mod.listPendingAgents();
-    (p[0] as { startedAt: number }).startedAt = Date.now() - 9 * 60_000;
-    await mod.pollOnce();
-    expect(delivered).toHaveLength(0);
-    expect(mod.listPendingAgents()).toHaveLength(1);
-
-    // Backdate to 11 min — over threshold, should fire
-    p = mod.listPendingAgents();
-    (p[0] as { startedAt: number }).startedAt = Date.now() - 11 * 60_000;
-    await mod.pollOnce();
-    expect(delivered).toHaveLength(1);
-  });
-
-  it("running file (has content, no end_turn) is unaffected by zombie check", async () => {
-    // A file WITH content should never trigger the missing-file path
-    // regardless of age.
-    const outPath = `${TEST_DATA_DIR}/running.jsonl`;
-    fs.writeFileSync(
-      outPath,
-      JSON.stringify({
-        type: "assistant",
-        isSidechain: true,
-        agentId: "x",
-        message: {
-          role: "assistant",
-          content: [{ type: "tool_use", name: "Bash", input: {} }],
-          stop_reason: "tool_use",
-        },
-      }) + "\n",
-      "utf-8",
-    );
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.registerPendingAgent({
-      agentId: "active-work",
-      outputFile: outPath,
-      description: "legitimately running",
-      prompt: "p",
-      chatId: 1,
-      userId: 1,
-      toolUseId: null,
-    });
-    const p = mod.listPendingAgents();
-    (p[0] as { startedAt: number }).startedAt = Date.now() - 30 * 60_000; // 30 min old
-
-    await mod.pollOnce();
-
-    // v4.12.4 staleness detection COULD fire here because the file has
-    // text content and is stale. That's a different (benign) path — the
-    // agent gets delivered as "completed with partial output". Either
-    // way, the zombie-fix error path must NOT fire.
-    const anyZombieError = delivered.some(
-      (d) => d.result.error && /output file never/i.test(d.result.error),
-    );
-    expect(anyZombieError).toBe(false);
-  });
-
-  it("completed file delivers as completed (unchanged)", async () => {
-    const outPath = `${TEST_DATA_DIR}/done.jsonl`;
-    fs.writeFileSync(
-      outPath,
-      JSON.stringify({
-        type: "assistant",
-        agentId: "x",
-        message: {
-          content: [{ type: "text", text: "all good" }],
-          stop_reason: "end_turn",
-        },
-      }) + "\n",
-      "utf-8",
-    );
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.registerPendingAgent({
-      agentId: "done-agent",
-      outputFile: outPath,
-      description: "clean completion",
-      prompt: "p",
-      chatId: 1,
-      userId: 1,
-      toolUseId: null,
-    });
-    // Backdate 1h — would trigger zombie if misapplied
-    const p = mod.listPendingAgents();
-    (p[0] as { startedAt: number }).startedAt = Date.now() - 60 * 60_000;
-
-    await mod.pollOnce();
-
-    expect(delivered).toHaveLength(1);
-    expect(delivered[0].result.status).toBe("completed");
-  });
-
-  it("decrements session counter on zombie failure delivery", async () => {
-    process.env.ALVIN_MISSING_FILE_FAILURE_MS = "1000"; // 1 sec for fast test
-    const sessionMod = await import("../src/services/session.js");
-    const session = sessionMod.getSession("zombie-session");
-    session.pendingBackgroundCount = 1;
-
-    const mod = await import("../src/services/async-agent-watcher.js");
-    mod.registerPendingAgent({
-      agentId: "session-zombie",
-      outputFile: `${TEST_DATA_DIR}/gone.jsonl`,
-      description: "zombie for counter",
-      prompt: "p",
-      chatId: 1,
-      userId: 1,
-      toolUseId: null,
-      sessionKey: "zombie-session",
-    });
-    const p = mod.listPendingAgents();
-    (p[0] as { startedAt: number }).startedAt = Date.now() - 5000; // 5 sec ago, > 1sec threshold
-
-    await mod.pollOnce();
-
-    expect(delivered).toHaveLength(1);
-    expect(session.pendingBackgroundCount).toBe(0);
-  });
-});

package/test/web-server-integration.test.ts

@@ -1,189 +0,0 @@
-/**
- * Fix #16 (integration) — end-to-end tests for the decoupled
- * startWebServer + stopWebServer pair.
- *
- * These tests exercise the ACTUAL http.Server binding, not the pure
- * decision helper. They rely on:
- *   - process.env.WEB_PORT to keep the test off the running bot's 3100
- *   - process.env.ALVIN_DATA_DIR to keep touch-points away from
- *     the maintainer's real ~/.alvin-bot/.env
- *
- * What's covered here:
- *   1. startWebServer() returns synchronously (void) without throwing
- *   2. stopWebServer() releases the port so another server can bind
- *   3. Start → stop → start cycle doesn't leak sockets or timers
- *   4. If the configured port is already busy, startWebServer still
- *      returns cleanly (no throw); the bot keeps running.
- *   5. stopWebServer() is idempotent — safe to call twice in a row
- *      and safe to call before startWebServer ever succeeded.
- *
- * The deliberate EADDRINUSE scenario is tested HERE against a real
- * running hog — no mocking.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import http from "http";
-import fs from "fs";
-import os from "os";
-import { resolve } from "path";
-
-const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-web-int-${process.pid}-${Date.now()}`);
-
-function getFreePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const s = http.createServer();
-    s.listen(0, () => {
-      const addr = s.address();
-      if (typeof addr === "object" && addr) {
-        const p = addr.port;
-        s.close(() => resolve(p));
-      } else {
-        reject(new Error("no address"));
-      }
-    });
-  });
-}
-
-async function waitForPortBound(port: number, timeoutMs = 3000): Promise<boolean> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const code = await new Promise<number>((resolveCode, reject) => {
-        const req = http.get(`http://127.0.0.1:${port}/`, (res) => {
-          res.resume();
-          resolveCode(res.statusCode ?? 0);
-        });
-        req.on("error", (err) => reject(err));
-        req.setTimeout(500, () => {
-          req.destroy(new Error("timeout"));
-        });
-      });
-      if (code > 0) return true;
-    } catch {
-      /* not yet */
-    }
-    await new Promise((r) => setTimeout(r, 100));
-  }
-  return false;
-}
-
-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;
-  // Write a minimal .env so config.ts loads cleanly
-  fs.writeFileSync(`${TEST_DATA_DIR}/.env`, "WEB_PASSWORD=\n", "utf-8");
-  process.env.WEB_PORT = String(await getFreePort());
-  // Reset module cache so each test imports server.js fresh and
-  // picks up the new WEB_PORT env var at module-load time.
-  vi.resetModules();
-});
-
-afterEach(async () => {
-  // Best-effort: stop whatever is running in the current module instance
-  try {
-    const { stopWebServer } = await import("../src/web/server.js");
-    await stopWebServer();
-  } catch {
-    /* ignore */
-  }
-  // Give the OS a moment to release ports before the next test
-  await new Promise((r) => setTimeout(r, 50));
-});
-
-describe("startWebServer / stopWebServer integration (Fix #16)", () => {
-  it("startWebServer returns void synchronously without throwing", async () => {
-    const { startWebServer } = await import("../src/web/server.js");
-    const result = startWebServer();
-    // Must return void (undefined). If it returned a Server instance
-    // the old API is still in place.
-    expect(result).toBeUndefined();
-  });
-
-  it("actually binds the web server and serves HTTP", async () => {
-    const port = Number(process.env.WEB_PORT);
-    const { startWebServer } = await import("../src/web/server.js");
-    startWebServer();
-    const up = await waitForPortBound(port, 3000);
-    expect(up).toBe(true);
-  });
-
-  it("stopWebServer releases the port", async () => {
-    const port = Number(process.env.WEB_PORT);
-    const { startWebServer, stopWebServer } = await import("../src/web/server.js");
-    startWebServer();
-    expect(await waitForPortBound(port, 3000)).toBe(true);
-    await stopWebServer();
-
-    // Port should now be free — a fresh bind must succeed
-    const reuse = http.createServer();
-    await new Promise<void>((resolve, reject) => {
-      reuse.once("error", reject);
-      reuse.listen(port, () => resolve());
-    });
-    await new Promise<void>((r) => reuse.close(() => r()));
-  });
-
-  it("stopWebServer is idempotent — safe to call multiple times", async () => {
-    const { startWebServer, stopWebServer } = await import("../src/web/server.js");
-    startWebServer();
-    await new Promise((r) => setTimeout(r, 200));
-    await stopWebServer();
-    // Second call must not throw
-    await expect(stopWebServer()).resolves.toBeUndefined();
-    // Third call must also not throw
-    await expect(stopWebServer()).resolves.toBeUndefined();
-  });
-
-  it("stopWebServer is safe to call before startWebServer ever bound", async () => {
-    const { stopWebServer } = await import("../src/web/server.js");
-    // Module just imported — nothing started yet
-    await expect(stopWebServer()).resolves.toBeUndefined();
-  });
-
-  it("when the primary port is taken, startWebServer still returns cleanly (climbs the ladder)", async () => {
-    const originalPort = Number(process.env.WEB_PORT);
-    // Plant a hog on the primary port BEFORE startWebServer
-    const hog = http.createServer();
-    await new Promise<void>((r) => hog.listen(originalPort, () => r()));
-
-    try {
-      const { startWebServer } = await import("../src/web/server.js");
-      // Must NOT throw even though the port is occupied
-      expect(() => startWebServer()).not.toThrow();
-
-      // The bot should have climbed the ladder — one port higher should
-      // now be serving HTTP.
-      const climbed = await waitForPortBound(originalPort + 1, 3000);
-      expect(climbed).toBe(true);
-    } finally {
-      await new Promise<void>((r) => hog.close(() => r()));
-    }
-  });
-
-  it("closeHttpServerGracefully closes a server that's holding an open socket", async () => {
-    const { closeHttpServerGracefully } = await import("../src/web/server.js");
-    const port = await getFreePort();
-    const server = http.createServer((_req, res) => {
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.write("chunk");
-      // never res.end — client hangs forever
-    });
-    await new Promise<void>((r) => server.listen(port, () => r()));
-
-    const req = http.get(`http://127.0.0.1:${port}/hang`);
-    req.on("error", () => { /* expected */ });
-    await new Promise((r) => setTimeout(r, 100));
-
-    const t0 = Date.now();
-    await closeHttpServerGracefully(server);
-    expect(Date.now() - t0).toBeLessThan(2000);
-
-    // Port is reusable
-    const reuse = http.createServer();
-    await new Promise<void>((resolve, reject) => {
-      reuse.once("error", reject);
-      reuse.listen(port, () => resolve());
-    });
-    await new Promise<void>((r) => reuse.close(() => r()));
-  });
-});