alvin-bot 4.18.0 → 4.18.2

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

@@ -1,118 +0,0 @@
-/**
- * Fix #16 — Web server must never crash the bot.
- *
- * Colleague feedback (WhatsApp voice note, 2026-04-13):
- *   > The gateway binds to port 3100 like OpenClaw. When the bot
- *   > restarts, the port is often still held → catastrophic crash.
- *   > I ended up decoupling the gateway process completely, because
- *   > the actual bot runs independently of the gateway — it can still
- *   > answer Telegram even if the web endpoint isn't reachable yet.
- *   > It's weird that the main routine crashes when the port is busy.
- *   > It should just run in the background, watch for the port to
- *   > become free, and connect then. Zero impact on the main routine.
- *
- * This file tests the pure decision helper that the new startWebServer
- * uses to choose between "try the next port immediately" and "retry
- * the default port in the background after a delay".
- *
- * Contract:
- *   decideNextBindAction(err, attempt, opts)
- *
- *   err.code = "EADDRINUSE", attempt < maxPortTries
- *     → { type: "retry-port", port: opts.originalPort + attempt + 1, attempt: attempt + 1 }
- *
- *   err.code = "EADDRINUSE", attempt >= maxPortTries
- *     → { type: "retry-background", delayMs: opts.backgroundRetryMs, port: opts.originalPort }
- *
- *   err.code = anything else (EACCES, ECONNRESET, "Listen method called twice"…)
- *     → { type: "retry-background", delayMs: opts.backgroundRetryMs, port: opts.originalPort }
- *
- *   Pure function, no side effects, no timers, no I/O.
- */
-import { describe, it, expect } from "vitest";
-import { decideNextBindAction } from "../src/web/bind-strategy.js";
-
-const defaultOpts = {
-  originalPort: 3100,
-  maxPortTries: 20,
-  backgroundRetryMs: 30_000,
-};
-
-describe("decideNextBindAction (Fix #16)", () => {
-  it("retries on the next port when EADDRINUSE and attempts remain", () => {
-    const err = Object.assign(new Error("EADDRINUSE"), { code: "EADDRINUSE" });
-    const result = decideNextBindAction(err, 0, defaultOpts);
-    expect(result).toEqual({ type: "retry-port", port: 3101, attempt: 1 });
-  });
-
-  it("walks the port ladder across multiple attempts", () => {
-    const err = Object.assign(new Error("EADDRINUSE"), { code: "EADDRINUSE" });
-    expect(decideNextBindAction(err, 5, defaultOpts)).toEqual({
-      type: "retry-port",
-      port: 3106,
-      attempt: 6,
-    });
-    expect(decideNextBindAction(err, 18, defaultOpts)).toEqual({
-      type: "retry-port",
-      port: 3119,
-      attempt: 19,
-    });
-  });
-
-  it("switches to background retry when all port attempts are exhausted", () => {
-    const err = Object.assign(new Error("EADDRINUSE"), { code: "EADDRINUSE" });
-    const result = decideNextBindAction(err, 19, defaultOpts); // 20th failure
-    expect(result).toEqual({
-      type: "retry-background",
-      delayMs: 30_000,
-      port: 3100,
-    });
-  });
-
-  it("goes straight to background retry on non-EADDRINUSE errors", () => {
-    const err = Object.assign(new Error("EACCES"), { code: "EACCES" });
-    const result = decideNextBindAction(err, 0, defaultOpts);
-    expect(result).toEqual({
-      type: "retry-background",
-      delayMs: 30_000,
-      port: 3100,
-    });
-  });
-
-  it("handles errors without a .code field by doing background retry", () => {
-    const err = new Error("Listen method has been called more than once");
-    const result = decideNextBindAction(err, 3, defaultOpts);
-    expect(result.type).toBe("retry-background");
-    if (result.type === "retry-background") {
-      expect(result.port).toBe(3100);
-    }
-  });
-
-  it("respects custom maxPortTries", () => {
-    const err = Object.assign(new Error("EADDRINUSE"), { code: "EADDRINUSE" });
-    const opts = { ...defaultOpts, maxPortTries: 3 };
-    // attempts 0, 1 still retry; attempt 2 is the LAST retry; attempt 3 -> background
-    expect(decideNextBindAction(err, 0, opts).type).toBe("retry-port");
-    expect(decideNextBindAction(err, 1, opts).type).toBe("retry-port");
-    expect(decideNextBindAction(err, 2, opts).type).toBe("retry-background");
-  });
-
-  it("respects custom backgroundRetryMs", () => {
-    const err = Object.assign(new Error("EACCES"), { code: "EACCES" });
-    const opts = { ...defaultOpts, backgroundRetryMs: 5_000 };
-    const result = decideNextBindAction(err, 0, opts);
-    expect(result).toEqual({
-      type: "retry-background",
-      delayMs: 5_000,
-      port: 3100,
-    });
-  });
-
-  it("is pure — same input, same output, no mutation", () => {
-    const err = Object.assign(new Error("EADDRINUSE"), { code: "EADDRINUSE" });
-    const snapshot = JSON.stringify({ ...defaultOpts });
-    decideNextBindAction(err, 5, defaultOpts);
-    decideNextBindAction(err, 5, defaultOpts);
-    expect(JSON.stringify({ ...defaultOpts })).toBe(snapshot);
-  });
-});

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

@@ -1,117 +0,0 @@
-/**
- * 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";
-// Fix #1 shipped as stopWebServer(server) — Fix #16 (v4.9.4) promoted
-// that to `closeHttpServerGracefully(server)` and reserved the name
-// `stopWebServer()` for the module-state-aware shutdown. The underlying
-// contract (close an http.Server even when clients hold open sockets,
-// release the port, idempotent, never throw) is unchanged — these
-// tests now exercise the renamed helper.
-import { closeHttpServerGracefully as 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

@@ -1,96 +0,0 @@
-/**
- * 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);
-  });
-});

package/test/workspaces.test.ts

@@ -1,196 +0,0 @@
-/**
- * v4.12.0 — Workspace registry tests.
- *
- * A workspace is a markdown file under ~/.alvin-bot/workspaces/<name>.md
- * with YAML frontmatter defining name, purpose, cwd, color, emoji, and
- * an optional "channels" array for explicit channel-ID mapping. The
- * markdown body (below the frontmatter) is the persona instruction
- * that gets injected into the system prompt for that workspace.
- */
-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-workspaces-${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 });
-  fs.mkdirSync(resolve(TEST_DATA_DIR, "workspaces"), { recursive: true });
-  process.env.ALVIN_DATA_DIR = TEST_DATA_DIR;
-  vi.resetModules();
-});
-
-afterEach(() => {
-  try { fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-});
-
-function writeWorkspace(name: string, frontmatter: Record<string, unknown>, body: string): void {
-  const fm = Object.entries(frontmatter)
-    .map(([k, v]) => `${k}: ${Array.isArray(v) ? JSON.stringify(v) : JSON.stringify(v)}`)
-    .join("\n");
-  const content = `---\n${fm}\n---\n${body}`;
-  fs.writeFileSync(resolve(TEST_DATA_DIR, "workspaces", `${name}.md`), content, "utf-8");
-}
-
-describe("workspace registry (v4.12.0)", () => {
-  it("returns a default workspace when nothing is configured", async () => {
-    const { loadWorkspaces, getDefaultWorkspace } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const def = getDefaultWorkspace();
-    expect(def.name).toBe("default");
-    expect(def.purpose).toBe("");
-    expect(def.systemPromptOverride).toBe("");
-  });
-
-  it("loads a workspace from a markdown file with frontmatter", async () => {
-    writeWorkspace(
-      "my-project",
-      { purpose: "my-project consulting website dev", cwd: "~/Projects/my-project-website", emoji: "🏢", color: "#6366f1" },
-      "You are the my-project dev assistant. Stack: React + Express + Drizzle.",
-    );
-    const { loadWorkspaces, getWorkspace } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const ws = getWorkspace("my-project");
-    expect(ws).not.toBeNull();
-    expect(ws!.name).toBe("my-project");
-    expect(ws!.purpose).toBe("my-project consulting website dev");
-    expect(ws!.cwd).toContain("my-project-website");
-    expect(ws!.emoji).toBe("🏢");
-    expect(ws!.color).toBe("#6366f1");
-    expect(ws!.systemPromptOverride).toContain("my-project dev assistant");
-  });
-
-  it("loads multiple workspaces and listWorkspaces returns all of them", async () => {
-    writeWorkspace("my-project", { purpose: "p1" }, "body1");
-    writeWorkspace("homes", { purpose: "p2" }, "body2");
-    writeWorkspace("my-landing", { purpose: "p3" }, "body3");
-    const { loadWorkspaces, listWorkspaces } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const names = listWorkspaces().map(w => w.name).sort();
-    expect(names).toEqual(["homes", "my-landing", "my-project"]);
-  });
-
-  it("expands ~ in cwd to the user's home directory", async () => {
-    writeWorkspace("tilde", { purpose: "p", cwd: "~/some/path" }, "");
-    const { loadWorkspaces, getWorkspace } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const ws = getWorkspace("tilde");
-    expect(ws!.cwd).toBe(resolve(os.homedir(), "some/path"));
-    expect(ws!.cwd).not.toContain("~");
-  });
-
-  it("matchWorkspaceForChannel matches by explicit channel ID in frontmatter", async () => {
-    writeWorkspace(
-      "my-project",
-      { purpose: "p", channels: ["C01ALEVABC", "C01ALEVXYZ"] },
-      "",
-    );
-    const { loadWorkspaces, matchWorkspaceForChannel } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const ws = matchWorkspaceForChannel("slack", "C01ALEVABC", undefined);
-    expect(ws?.name).toBe("my-project");
-  });
-
-  it("matchWorkspaceForChannel falls back to channel name match (case-insensitive, # stripped)", async () => {
-    writeWorkspace("my-project", { purpose: "p" }, "");
-    const { loadWorkspaces, matchWorkspaceForChannel } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const byHash = matchWorkspaceForChannel("slack", "C_UNKNOWN", "#my-project");
-    const noHash = matchWorkspaceForChannel("slack", "C_UNKNOWN", "MY-PROJECT");
-    expect(byHash?.name).toBe("my-project");
-    expect(noHash?.name).toBe("my-project");
-  });
-
-  it("matchWorkspaceForChannel returns null for unknown channel with no name match", async () => {
-    writeWorkspace("my-project", { purpose: "p" }, "");
-    const { loadWorkspaces, matchWorkspaceForChannel } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const ws = matchWorkspaceForChannel("slack", "C_MYSTERY", "#unmapped");
-    expect(ws).toBeNull();
-  });
-
-  it("resolveWorkspaceOrDefault returns the matched workspace when one is found", async () => {
-    writeWorkspace("my-project", { purpose: "p" }, "persona body");
-    const { loadWorkspaces, resolveWorkspaceOrDefault } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const ws = resolveWorkspaceOrDefault("slack", "C_UNKNOWN", "#my-project");
-    expect(ws.name).toBe("my-project");
-    expect(ws.systemPromptOverride).toContain("persona body");
-  });
-
-  it("resolveWorkspaceOrDefault returns the default workspace when no match", async () => {
-    const { loadWorkspaces, resolveWorkspaceOrDefault } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const ws = resolveWorkspaceOrDefault("slack", "C_UNKNOWN", "#whatever");
-    expect(ws.name).toBe("default");
-  });
-
-  it("reloadWorkspaces picks up a newly created file", async () => {
-    const { loadWorkspaces, reloadWorkspaces, listWorkspaces } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    expect(listWorkspaces()).toHaveLength(0);
-    writeWorkspace("new-one", { purpose: "p" }, "body");
-    reloadWorkspaces();
-    expect(listWorkspaces()).toHaveLength(1);
-    expect(listWorkspaces()[0].name).toBe("new-one");
-  });
-
-  it("skips files that aren't .md", async () => {
-    fs.writeFileSync(resolve(TEST_DATA_DIR, "workspaces", "notes.txt"), "ignored");
-    writeWorkspace("real", { purpose: "p" }, "body");
-    const { loadWorkspaces, listWorkspaces } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    expect(listWorkspaces()).toHaveLength(1);
-    expect(listWorkspaces()[0].name).toBe("real");
-  });
-
-  it("malformed frontmatter: workspace is skipped or loaded with defaults, other workspaces still load", async () => {
-    fs.writeFileSync(
-      resolve(TEST_DATA_DIR, "workspaces", "broken.md"),
-      "---\nthis is: not: valid: yaml:\n---\nbody",
-    );
-    writeWorkspace("good", { purpose: "p" }, "body");
-    const { loadWorkspaces, listWorkspaces } = await import("../src/services/workspaces.js");
-    loadWorkspaces();
-    const names = listWorkspaces().map(w => w.name);
-    expect(names).toContain("good");
-  });
-
-  it("missing workspaces directory is handled gracefully", async () => {
-    fs.rmSync(resolve(TEST_DATA_DIR, "workspaces"), { recursive: true, force: true });
-    const { loadWorkspaces, listWorkspaces } = await import("../src/services/workspaces.js");
-    const count = loadWorkspaces();
-    expect(count).toBe(0);
-    expect(listWorkspaces()).toEqual([]);
-  });
-});
-
-describe("workspace resolver integration with session (v4.12.0)", () => {
-  it("two channels resolve to two different workspaces", async () => {
-    fs.writeFileSync(
-      resolve(TEST_DATA_DIR, "workspaces", "my-project.md"),
-      `---\npurpose: project-a\ncwd: ~/tmp/project-a\nchannels: ["C_PROJECT_A"]\n---\nproject-a persona`,
-    );
-    fs.writeFileSync(
-      resolve(TEST_DATA_DIR, "workspaces", "project-b.md"),
-      `---\npurpose: project-b\ncwd: ~/tmp/project-b\nchannels: ["C_PROJECT_B"]\n---\nproject-b persona`,
-    );
-
-    vi.resetModules();
-    const { initWorkspaces, resolveWorkspaceOrDefault } = await import("../src/services/workspaces.js");
-    initWorkspaces();
-
-    const a = resolveWorkspaceOrDefault("slack", "C_PROJECT_A", undefined);
-    const b = resolveWorkspaceOrDefault("slack", "C_PROJECT_B", undefined);
-    const unknown = resolveWorkspaceOrDefault("slack", "C_MYSTERY", undefined);
-
-    expect(a.name).toBe("my-project");
-    expect(a.systemPromptOverride).toBe("project-a persona");
-    expect(b.name).toBe("project-b");
-    expect(b.systemPromptOverride).toBe("project-b persona");
-    expect(unknown.name).toBe("default");
-    expect(unknown.systemPromptOverride).toBe("");
-  });
-});

package/vitest.config.ts

@@ -1,17 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    // Tests live alongside source as *.test.ts, plus a dedicated test/ dir
-    include: ["src/**/*.test.ts", "test/**/*.test.ts"],
-    // Node environment — no DOM
-    environment: "node",
-    // Keep individual tests fast; fail loudly if any hang
-    testTimeout: 10_000,
-    hookTimeout: 5_000,
-    // ESM-only project — vitest handles this natively
-    globals: false,
-    // Don't try to run electron or build artifacts
-    exclude: ["node_modules/**", "dist/**", "electron/**"],
-  },
-});