alvin-bot 4.8.9 → 4.9.0

package/test/subagent-final-text.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Fix #5 — runSubAgent must preserve the full final text, even when the
+ * stream ends on a tool_use or is aborted mid-stream.
+ *
+ * Regressions this closes:
+ *
+ *   (a) The SDK yields `text` chunks as accumulated strings, then tool
+ *       calls, then more text, then finally a `done` chunk that ALSO
+ *       carries the final accumulated text. The old runSubAgent read
+ *       `text` from text-chunks only and ignored `done.text`. If the
+ *       assistant's very last action was a tool call with no trailing
+ *       text block, `finalText` kept the pre-tool text and the
+ *       cron-jobs.json `lastResult` ended mid-sentence.
+ *
+ *   (b) When queryWithFallback threw mid-stream (provider aborted,
+ *       network error, etc.), the catch block set `output: ""` —
+ *       throwing away whatever text had already streamed in before the
+ *       failure. Users saw an empty "(empty output)" delivery.
+ *
+ * Contract:
+ *   - Output = last non-empty value observed from (text.text | done.text)
+ *   - On error / abort: output = whatever we'd buffered so far (never "")
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+import type { StreamChunk } from "../src/providers/types.js";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-finaltext-${process.pid}-${Date.now()}`);
+
+beforeEach(() => {
+  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;
+  delete process.env.MAX_SUBAGENTS;
+  vi.resetModules();
+});
+
+function mockStream(chunks: StreamChunk[] | (() => AsyncIterable<StreamChunk>)) {
+  vi.doMock("../src/engine.js", () => ({
+    getRegistry: () => ({
+      queryWithFallback: typeof chunks === "function"
+        ? chunks
+        : async function* () { for (const c of chunks) yield c; },
+    }),
+  }));
+  vi.doMock("../src/services/subagent-delivery.js", () => ({
+    deliverSubAgentResult: async () => { /* no-op */ },
+    attachBotApi: () => {},
+    __setBotApiForTest: () => {},
+  }));
+}
+
+async function runAndGetResult(prompt = "test") {
+  const mod = await import("../src/services/subagents.js");
+  return new Promise<{ output: string; status: string; tokensUsed: { input: number; output: number } }>((resolveResult) => {
+    mod.spawnSubAgent({
+      name: "test-agent",
+      prompt,
+      source: "cron",
+      parentChatId: 1,
+      onComplete: (r) => resolveResult({
+        output: r.output,
+        status: r.status,
+        tokensUsed: r.tokensUsed,
+      }),
+    }).catch(() => { /* spawn errors handled elsewhere */ });
+  });
+}
+
+describe("runSubAgent finalText (Fix #5)", () => {
+  it("uses done.text as the authoritative final output", async () => {
+    mockStream([
+      { type: "text", text: "Working on it…" },
+      { type: "tool_use", toolName: "Bash" },
+      { type: "text", text: "Intermediate finding: 5 results." },
+      { type: "tool_use", toolName: "Write" },
+      // No trailing text chunk — the assistant ended on a tool call,
+      // then the done chunk carries the authoritative final text.
+      { type: "done", text: "Job complete. Report at /tmp/out.html", inputTokens: 100, outputTokens: 50 },
+    ]);
+    const r = await runAndGetResult();
+    expect(r.status).toBe("completed");
+    expect(r.output).toBe("Job complete. Report at /tmp/out.html");
+    expect(r.tokensUsed).toEqual({ input: 100, output: 50 });
+  });
+
+  it("falls back to last text chunk when done has no text", async () => {
+    mockStream([
+      { type: "text", text: "First sentence." },
+      { type: "text", text: "Second sentence." },
+      { type: "done", inputTokens: 10, outputTokens: 5 },
+    ]);
+    const r = await runAndGetResult();
+    expect(r.output).toBe("Second sentence.");
+  });
+
+  it("preserves buffered text when stream errors mid-way", async () => {
+    mockStream(async function* () {
+      yield { type: "text", text: "Partial progress so far…" };
+      yield { type: "tool_use", toolName: "Bash" };
+      throw new Error("network: socket hang up");
+    });
+    const r = await runAndGetResult();
+    // Status can legitimately be "error" or "cancelled" — but output
+    // must NOT be an empty string. That's the regression.
+    expect(r.output.length).toBeGreaterThan(0);
+    expect(r.output).toContain("Partial progress");
+  });
+
+  it("preserves buffered text when the provider yields an error chunk", async () => {
+    mockStream([
+      { type: "text", text: "Started the task." },
+      { type: "text", text: "Started the task. More detail here." },
+      { type: "error", error: "Provider 'claude-sdk' failed: Request aborted" },
+    ]);
+    const r = await runAndGetResult();
+    expect(r.output).toContain("More detail");
+  });
+
+  it("returns empty output gracefully when nothing was buffered", async () => {
+    mockStream(async function* () {
+      throw new Error("immediate failure");
+    });
+    const r = await runAndGetResult();
+    // No text at all → empty is acceptable (nothing to preserve), but
+    // status must reflect the failure.
+    expect(r.output).toBe("");
+    expect(["error", "cancelled", "timeout"]).toContain(r.status);
+  });
+});

package/test/telegram-error-filter.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Fix #12 — grammy error noise filter.
+ *
+ * Regression: chunks like
+ *   Fehler: Call to 'editMessageText' failed! (400: Bad Request:
+ *   message is not modified: specified new message content and reply
+ *   markup are exactly the same as a current content and reply markup
+ *   of the message)
+ * were being sent to end users 2-3 times per day whenever a live-stream
+ * edit raced against itself. The v4.8.8 `bot.catch()` fix swallowed
+ * these at the middleware layer, but `telegram.ts` finalize() and
+ * `handlers/message.ts` error paths bypass bot.catch completely —
+ * they surface the raw grammy error via `ctx.reply()`.
+ *
+ * Contract: `isHarmlessTelegramError(err)` returns true for:
+ *   - "message is not modified" (any language, any prefix)
+ *   - "Call to 'editMessageText' failed" combined with the above
+ *   - "query is too old" (harmless callback-answer race)
+ *   - "MESSAGE_ID_INVALID" (user deleted the message before we edited it)
+ *
+ * Returns false for all other errors — they still need surfacing.
+ */
+import { describe, it, expect } from "vitest";
+import { isHarmlessTelegramError } from "../src/util/telegram-error-filter.js";
+
+describe("isHarmlessTelegramError (Fix #12)", () => {
+  it("matches the exact production message", () => {
+    const err = new Error(
+      "Call to 'editMessageText' failed! (400: Bad Request: message is not modified: " +
+      "specified new message content and reply markup are exactly the same as a current " +
+      "content and reply markup of the message)",
+    );
+    expect(isHarmlessTelegramError(err)).toBe(true);
+  });
+
+  it("matches just the 'message is not modified' substring", () => {
+    expect(isHarmlessTelegramError(new Error("400: message is not modified"))).toBe(true);
+  });
+
+  it("matches 'specified new message content ... exactly the same'", () => {
+    expect(
+      isHarmlessTelegramError(
+        new Error("specified new message content and reply markup are exactly the same"),
+      ),
+    ).toBe(true);
+  });
+
+  it("matches 'query is too old' (answerCallbackQuery race)", () => {
+    expect(
+      isHarmlessTelegramError(new Error("Bad Request: query is too old and response timeout expired")),
+    ).toBe(true);
+  });
+
+  it("matches 'message to edit not found' (user deleted)", () => {
+    expect(
+      isHarmlessTelegramError(new Error("Bad Request: message to edit not found")),
+    ).toBe(true);
+  });
+
+  it("matches MESSAGE_ID_INVALID", () => {
+    expect(isHarmlessTelegramError(new Error("Bad Request: MESSAGE_ID_INVALID"))).toBe(true);
+  });
+
+  it("accepts plain strings as well as Error objects", () => {
+    expect(isHarmlessTelegramError("message is not modified")).toBe(true);
+  });
+
+  it("accepts undefined / null as not harmless (caller decides)", () => {
+    expect(isHarmlessTelegramError(undefined)).toBe(false);
+    expect(isHarmlessTelegramError(null)).toBe(false);
+  });
+
+  it("does NOT swallow real errors", () => {
+    expect(isHarmlessTelegramError(new Error("Unauthorized"))).toBe(false);
+    expect(isHarmlessTelegramError(new Error("Too Many Requests: retry after 5"))).toBe(false);
+    expect(isHarmlessTelegramError(new Error("chat not found"))).toBe(false);
+    expect(isHarmlessTelegramError(new Error("stream error: provider timeout"))).toBe(false);
+  });
+
+  it("handles nested err.description from grammy", () => {
+    const err = new Error("anything") as Error & { description?: string };
+    err.description = "Bad Request: message is not modified";
+    expect(isHarmlessTelegramError(err)).toBe(true);
+  });
+});

package/test/watchdog-brake.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Fix #4 — Watchdog brake must actually engage on chronic crashes.
+ *
+ * Regression: the previous logic reset crashCount after 5 min of clean
+ * uptime. Production logs showed the bot crashing ~5 times per hour, but
+ * each boot lived just long enough (>5 min, <10 min) to reset the counter.
+ * Result: `crashCount` never reached the brake threshold, the bot cycled
+ * for hours, and the daily job-alert silently lost its scheduled runs.
+ *
+ * New contract (pure function pair extracted to watchdog-brake.ts):
+ *
+ *   decideBrakeAction(prevBeacon, now, opts)
+ *     - returns `{ action: "proceed", crashCount, crashWindowStart }`
+ *       on clean start or old previous beacon
+ *     - returns `{ action: "proceed", crashCount: N }` when the last run
+ *       exited recently but we're still under the brake threshold
+ *     - returns `{ action: "brake", reason }` when either
+ *         (a) N+1 crashes in a short window, or
+ *         (b) the daily crash cap (default 20) is exceeded
+ *
+ *   shouldResetCrashCounter(uptimeMs, opts) → boolean
+ *     - default policy: only reset after 1 h of clean uptime (NOT 5 min)
+ */
+import { describe, it, expect } from "vitest";
+import {
+  decideBrakeAction,
+  shouldResetCrashCounter,
+  DEFAULTS,
+  type BeaconData,
+} from "../src/services/watchdog-brake.js";
+
+const ONE_MIN = 60_000;
+const ONE_HOUR = 60 * ONE_MIN;
+
+function beacon(partial: Partial<BeaconData> = {}): BeaconData {
+  return {
+    lastBeat: 0,
+    pid: 1,
+    bootTime: 0,
+    crashCount: 0,
+    crashWindowStart: 0,
+    dailyCrashCount: 0,
+    dailyCrashWindowStart: 0,
+    version: "test",
+    ...partial,
+  };
+}
+
+describe("decideBrakeAction (Fix #4)", () => {
+  it("proceeds on first boot (no previous beacon)", () => {
+    const now = 1_000_000;
+    const result = decideBrakeAction(null, now);
+    expect(result.action).toBe("proceed");
+    if (result.action === "proceed") {
+      expect(result.crashCount).toBe(0);
+      expect(result.crashWindowStart).toBe(now);
+      expect(result.dailyCrashCount).toBe(0);
+    }
+  });
+
+  it("proceeds when previous beacon is old (>STALE_MS) — clean exit", () => {
+    const now = 1_000_000_000;
+    const prev = beacon({ lastBeat: now - 10 * ONE_MIN, crashCount: 3 });
+    const result = decideBrakeAction(prev, now);
+    expect(result.action).toBe("proceed");
+    if (result.action === "proceed") {
+      // Old beacon → treat as clean, reset window counter (but keep daily)
+      expect(result.crashCount).toBe(0);
+    }
+  });
+
+  it("counts a restart after a fresh beacon as a crash", () => {
+    const now = 1_000_000_000;
+    const prev = beacon({
+      lastBeat: now - 15_000, // 15 s ago
+      crashCount: 2,
+      crashWindowStart: now - 5 * ONE_MIN,
+      dailyCrashCount: 2,
+      dailyCrashWindowStart: now - 2 * ONE_HOUR,
+    });
+    const result = decideBrakeAction(prev, now);
+    expect(result.action).toBe("proceed");
+    if (result.action === "proceed") {
+      expect(result.crashCount).toBe(3);
+      expect(result.dailyCrashCount).toBe(3);
+    }
+  });
+
+  it("engages brake when short-window threshold is crossed", () => {
+    const now = 1_000_000_000;
+    const prev = beacon({
+      lastBeat: now - 10_000,
+      crashCount: DEFAULTS.SHORT_BRAKE_THRESHOLD - 1, // one more = brake
+      crashWindowStart: now - 2 * ONE_MIN,
+      dailyCrashCount: 5,
+      dailyCrashWindowStart: now - ONE_HOUR,
+    });
+    const result = decideBrakeAction(prev, now);
+    expect(result.action).toBe("brake");
+    if (result.action === "brake") {
+      expect(result.reason).toMatch(/short.*window|threshold|crashes/i);
+    }
+  });
+
+  it("engages brake when daily cap is exceeded", () => {
+    const now = 1_000_000_000;
+    const prev = beacon({
+      lastBeat: now - 10_000,
+      crashCount: 1, // short window fine
+      crashWindowStart: now - 30 * ONE_MIN,
+      dailyCrashCount: DEFAULTS.DAILY_BRAKE_THRESHOLD - 1,
+      dailyCrashWindowStart: now - 12 * ONE_HOUR,
+    });
+    const result = decideBrakeAction(prev, now);
+    expect(result.action).toBe("brake");
+    if (result.action === "brake") {
+      expect(result.reason).toMatch(/daily|day/i);
+    }
+  });
+
+  it("rolls over daily counter when 24h window expires", () => {
+    const now = 1_000_000_000;
+    const prev = beacon({
+      lastBeat: now - 10_000,
+      crashCount: 1,
+      crashWindowStart: now - 30 * ONE_MIN,
+      dailyCrashCount: 18,                  // high
+      dailyCrashWindowStart: now - 25 * ONE_HOUR, // but window rolled over
+    });
+    const result = decideBrakeAction(prev, now);
+    expect(result.action).toBe("proceed");
+    if (result.action === "proceed") {
+      expect(result.dailyCrashCount).toBe(1); // fresh window
+      expect(result.dailyCrashWindowStart).toBe(now);
+    }
+  });
+});
+
+describe("shouldResetCrashCounter (Fix #4)", () => {
+  it("does NOT reset after 5 min of uptime (old buggy behaviour)", () => {
+    expect(shouldResetCrashCounter(5 * ONE_MIN)).toBe(false);
+  });
+
+  it("does NOT reset after 30 min of uptime", () => {
+    expect(shouldResetCrashCounter(30 * ONE_MIN)).toBe(false);
+  });
+
+  it("resets after 1 h of clean uptime", () => {
+    expect(shouldResetCrashCounter(ONE_HOUR)).toBe(true);
+    expect(shouldResetCrashCounter(ONE_HOUR + 1)).toBe(true);
+  });
+
+  it("can be overridden via opts.resetAfterMs", () => {
+    expect(shouldResetCrashCounter(10 * ONE_MIN, { resetAfterMs: 10 * ONE_MIN })).toBe(true);
+    expect(shouldResetCrashCounter(10 * ONE_MIN - 1, { resetAfterMs: 10 * ONE_MIN })).toBe(false);
+  });
+});

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

@@ -0,0 +1,111 @@
+/**
+ * Fix #1 — Web server must release port on shutdown.
+ *
+ * Regression: on bot restart the previous http.Server kept listening on
+ * :3100 (because shutdown() never called server.close()). launchd then
+ * restarted the bot, the next boot tried server.listen(3100), hit
+ * EADDRINUSE, and the bot crashed uncaught. Crash-loop.
+ *
+ * Contract we're establishing:
+ *   - src/web/server.ts must export `stopWebServer(server, opts?)`
+ *   - It must resolve once `server.close()` finishes.
+ *   - It must force-close idle/active sockets so close() can't hang
+ *     forever (otherwise shutdown would block on the 5s launchd grace).
+ *   - After stopWebServer() returns, a fresh http.Server must be able
+ *     to listen(port) on the same port without EADDRINUSE.
+ */
+import { describe, it, expect } from "vitest";
+import http from "http";
+import { once } from "events";
+import { startWebServer, stopWebServer } from "../src/web/server.js";
+
+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"));
+      }
+    });
+  });
+}
+
+describe("stopWebServer (Fix #1)", () => {
+  it("closes an http.Server so the port becomes reusable", async () => {
+    const port = await getFreePort();
+
+    const server = http.createServer((_req, res) => {
+      res.end("ok");
+    });
+    await new Promise<void>((r) => server.listen(port, () => r()));
+
+    // Hold an open idle keep-alive socket — this is the exact state that
+    // prevented server.close() from resolving in production. A real
+    // stopWebServer() must break this stall.
+    const hanger = http.get(`http://127.0.0.1:${port}/`, () => { /* body */ });
+    await once(hanger, "response").catch(() => { /* swallow */ });
+
+    const t0 = Date.now();
+    await stopWebServer(server);
+    const elapsed = Date.now() - t0;
+
+    expect(elapsed).toBeLessThan(2000);
+
+    // Prove the port is actually free: a new server must be able to bind it.
+    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("is safe to call on an already-closed server", async () => {
+    const port = await getFreePort();
+    const server = http.createServer();
+    await new Promise<void>((r) => server.listen(port, () => r()));
+    await stopWebServer(server);
+    // Calling twice must not throw
+    await expect(stopWebServer(server)).resolves.toBeUndefined();
+  });
+
+  it("is safe to call on a server that never listened", async () => {
+    const server = http.createServer();
+    await expect(stopWebServer(server)).resolves.toBeUndefined();
+  });
+
+  it("closes even when a client is holding a long-lived connection", async () => {
+    // Production-mirror: a long-polling /api/cron?wait=1 or similar.
+    // Before the fix, server.close() would hang on these sockets and the
+    // 5s launchd grace would kill the bot before the port was released.
+    const port = await getFreePort();
+    const server = http.createServer((_req, res) => {
+      // Never send a full response — keep the socket open until close.
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.write("chunk-1");
+      // intentionally do NOT call res.end()
+    });
+    await new Promise<void>((r) => server.listen(port, () => r()));
+
+    const req = http.get(`http://127.0.0.1:${port}/hang`);
+    // Swallow the inevitable socket-close error once the server is torn down
+    req.on("error", () => { /* expected */ });
+    await once(req, "response").catch(() => { /* swallow */ });
+
+    const t0 = Date.now();
+    await stopWebServer(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()));
+  });
+});

package/test/whatsapp-auth-resilience.test.ts

@@ -0,0 +1,96 @@
+/**
+ * Fix #2 — WhatsApp saveCreds must survive a vanished auth directory.
+ *
+ * Regression: `Unhandled rejection: ENOENT creds.json` in err.log when
+ * baileys fired a delayed `creds.update` event after the auth dir was
+ * gone (crash mid-init, trash, manual cleanup, etc.).
+ *
+ * Contract: we export a helper `makeResilientSaveCreds(authDir, inner)`
+ * from src/platforms/whatsapp-auth-helpers.ts. It wraps baileys' raw
+ * saveCreds so that an ENOENT triggers a mkdir-p + one retry before
+ * surfacing the error. Any other error bubbles up unchanged.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve, join } from "path";
+import { makeResilientSaveCreds } from "../src/platforms/whatsapp-auth-helpers.js";
+
+let authDir: string;
+
+beforeEach(() => {
+  authDir = resolve(os.tmpdir(), `alvin-wa-auth-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(authDir, { recursive: true });
+});
+
+afterEach(() => {
+  if (fs.existsSync(authDir)) fs.rmSync(authDir, { recursive: true, force: true });
+});
+
+describe("makeResilientSaveCreds (Fix #2)", () => {
+  it("calls the inner saveCreds on the happy path", async () => {
+    let calls = 0;
+    const inner = async () => { calls++; };
+    const wrapped = makeResilientSaveCreds(authDir, inner);
+    await wrapped();
+    expect(calls).toBe(1);
+  });
+
+  it("recreates the auth dir and retries when inner throws ENOENT", async () => {
+    let calls = 0;
+    const inner = async () => {
+      calls++;
+      if (calls === 1) {
+        // Mirror baileys fs.promises.writeFile behaviour
+        const err = new Error(
+          `ENOENT: no such file or directory, open '${join(authDir, "creds.json")}'`,
+        ) as NodeJS.ErrnoException;
+        err.code = "ENOENT";
+        throw err;
+      }
+    };
+    // Simulate the vanished dir
+    fs.rmSync(authDir, { recursive: true, force: true });
+    expect(fs.existsSync(authDir)).toBe(false);
+
+    const wrapped = makeResilientSaveCreds(authDir, inner);
+    await wrapped();
+
+    expect(calls).toBe(2);
+    expect(fs.existsSync(authDir)).toBe(true);
+  });
+
+  it("only retries once — a second ENOENT surfaces as error", async () => {
+    let calls = 0;
+    const inner = async () => {
+      calls++;
+      const err = new Error("ENOENT: no such file or directory") as NodeJS.ErrnoException;
+      err.code = "ENOENT";
+      throw err;
+    };
+    const wrapped = makeResilientSaveCreds(authDir, inner);
+    await expect(wrapped()).rejects.toThrow(/ENOENT/);
+    expect(calls).toBe(2);
+  });
+
+  it("surfaces non-ENOENT errors unchanged", async () => {
+    const inner = async () => {
+      const err = new Error("EACCES: permission denied") as NodeJS.ErrnoException;
+      err.code = "EACCES";
+      throw err;
+    };
+    const wrapped = makeResilientSaveCreds(authDir, inner);
+    await expect(wrapped()).rejects.toThrow(/EACCES/);
+  });
+
+  it("is safe to call concurrently", async () => {
+    let calls = 0;
+    const inner = async () => {
+      calls++;
+      await new Promise((r) => setTimeout(r, 5));
+    };
+    const wrapped = makeResilientSaveCreds(authDir, inner);
+    await Promise.all([wrapped(), wrapped(), wrapped()]);
+    expect(calls).toBe(3);
+  });
+});