alvin-bot 4.5.1 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alvin-bot",
-  "version": "4.5.1",
+  "version": "4.7.0",
   "description": "Alvin Bot — Your personal AI agent on Telegram, WhatsApp, Discord, Signal, and Web.",
   "type": "module",
   "main": "dist/index.js",
@@ -12,6 +12,9 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "setup": "node bin/cli.js setup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
     "electron:compile": "tsc -p electron/tsconfig.json",
     "electron:dev": "npm run electron:compile && electron .",
     "electron:build": "npm run build && npm run electron:compile && electron-builder --publish never",
@@ -176,9 +179,11 @@
     "ws": "^8.19.0"
   },
   "devDependencies": {
+    "@vitest/ui": "^4.1.4",
     "electron": "^35.7.5",
     "electron-builder": "^26.8.1",
-    "tsx": "^4.19.0"
+    "tsx": "^4.19.0",
+    "vitest": "^4.1.4"
   },
   "homepage": "https://github.com/alvbln/Alvin-Bot",
   "engines": {

package/test/claude-sdk-provider.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock child_process BEFORE importing the provider, so the provider's
+// top-level `promisify(execFile)` binds to our mock.
+const execFileMock = vi.fn();
+vi.mock("child_process", () => ({
+  execFile: (
+    path: string,
+    args: string[],
+    opts: unknown,
+    cb: (err: Error | null, stdout: { stdout: string; stderr: string }) => void,
+  ) => {
+    execFileMock(path, args, opts, cb);
+  },
+}));
+
+// Stub findClaudeBinary to return a fake path — we don't want real FS
+vi.mock("../src/find-claude-binary.js", () => ({
+  findClaudeBinary: () => "/fake/claude",
+}));
+
+describe("ClaudeSDKProvider.isAvailable", () => {
+  beforeEach(() => {
+    execFileMock.mockReset();
+    vi.resetModules();
+  });
+
+  it("returns false when `claude -p` returns 'Not logged in'", async () => {
+    // First call: --version succeeds
+    // Second call: -p 'ping' returns "Not logged in · Please run /login"
+    execFileMock
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, { stdout: "1.0.0\n", stderr: "" }),
+      )
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, { stdout: "Not logged in · Please run /login", stderr: "" }),
+      );
+
+    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
+    const p = new ClaudeSDKProvider();
+    const result = await p.isAvailable();
+    expect(result).toBe(false);
+  });
+
+  it("returns true when `claude -p` returns a normal response", async () => {
+    execFileMock
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, { stdout: "1.0.0\n", stderr: "" }),
+      )
+      .mockImplementationOnce((_p, _a, _o, cb) =>
+        cb(null, { stdout: "pong", stderr: "" }),
+      );
+
+    const { ClaudeSDKProvider } = await import("../src/providers/claude-sdk-provider.js");
+    const p = new ClaudeSDKProvider();
+    const result = await p.isAvailable();
+    expect(result).toBe(true);
+  });
+});
+
+describe("ClaudeSDKProvider — isAuthErrorOutput helper", () => {
+  it("detects 'Not logged in' text as auth error", async () => {
+    const { isAuthErrorOutput } = await import("../src/providers/claude-sdk-provider.js");
+    expect(isAuthErrorOutput("Not logged in · Please run /login")).toBe(true);
+    expect(isAuthErrorOutput("   not logged in · Please run /login  ")).toBe(true);
+    expect(isAuthErrorOutput("Hello! Here is the result")).toBe(false);
+    expect(isAuthErrorOutput("")).toBe(false);
+  });
+});

package/test/i18n.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { t, initI18n, setLocale, getLocale, LOCALE_NAMES, LOCALE_FLAGS } from "../src/i18n.js";
+
+describe("i18n", () => {
+  beforeEach(() => {
+    // Reset to a known state before each test
+    setLocale("en");
+  });
+
+  describe("LOCALE_NAMES", () => {
+    it("exposes all four supported locales", () => {
+      expect(LOCALE_NAMES.en).toBe("English");
+      expect(LOCALE_NAMES.de).toBe("Deutsch");
+      expect(LOCALE_NAMES.es).toBe("Español");
+      expect(LOCALE_NAMES.fr).toBe("Français");
+    });
+  });
+
+  describe("LOCALE_FLAGS", () => {
+    it("has a flag emoji for every locale", () => {
+      expect(LOCALE_FLAGS.en).toBe("🇬🇧");
+      expect(LOCALE_FLAGS.de).toBe("🇩🇪");
+      expect(LOCALE_FLAGS.es).toBe("🇪🇸");
+      expect(LOCALE_FLAGS.fr).toBe("🇫🇷");
+    });
+  });
+
+  describe("t() — translation lookup", () => {
+    it("returns the English string when locale is en", () => {
+      const msg = t("bot.cancel.cancelling", "en");
+      expect(msg).toContain("Cancelling");
+    });
+
+    it("returns the German string when locale is de", () => {
+      const msg = t("bot.cancel.cancelling", "de");
+      expect(msg).toContain("abgebrochen");
+    });
+
+    it("returns the Spanish string when locale is es", () => {
+      const msg = t("bot.cancel.cancelling", "es");
+      expect(msg.toLowerCase()).toContain("cancelando");
+    });
+
+    it("returns the French string when locale is fr", () => {
+      const msg = t("bot.cancel.cancelling", "fr");
+      expect(msg.toLowerCase()).toContain("annulation");
+    });
+
+    it("falls back to English when locale is missing for a key", () => {
+      // Use a TUI key which only has en+de — request es, should fall through
+      // to en since tui.* keys aren't translated for es/fr.
+      const msg = t("tui.title", "es");
+      expect(msg).toContain("Alvin Bot TUI");
+    });
+
+    it("returns the key itself if no locale has it at all", () => {
+      const msg = t("bot.nonexistent.key.for.test", "en");
+      expect(msg).toBe("bot.nonexistent.key.for.test");
+    });
+
+    it("uses the global currentLocale when no locale is passed", () => {
+      setLocale("de");
+      const msg = t("bot.cancel.cancelling");
+      expect(msg).toContain("abgebrochen");
+    });
+  });
+
+  describe("t() — interpolation", () => {
+    it("substitutes a single {var} placeholder", () => {
+      const msg = t("bot.error.timeoutStuck", "en", { min: 10 });
+      expect(msg).toContain("10 minutes");
+    });
+
+    it("substitutes multiple {var} placeholders", () => {
+      const msg = t("bot.error.midStream", "en", {
+        name: "claude-sdk",
+        detail: "connection reset",
+      });
+      expect(msg).toContain("claude-sdk");
+      expect(msg).toContain("connection reset");
+    });
+
+    it("interpolation works in all four locales", () => {
+      const vars = { min: 7 };
+      expect(t("bot.error.timeoutStuck", "en", vars)).toContain("7");
+      expect(t("bot.error.timeoutStuck", "de", vars)).toContain("7");
+      expect(t("bot.error.timeoutStuck", "es", vars)).toContain("7");
+      expect(t("bot.error.timeoutStuck", "fr", vars)).toContain("7");
+    });
+
+    it("leaves {placeholder} visible if the var is not provided", () => {
+      const msg = t("bot.error.timeoutStuck", "en", {});
+      expect(msg).toContain("{min}");
+    });
+  });
+
+  describe("initI18n / setLocale / getLocale", () => {
+    it("initI18n with explicit locale sets currentLocale", () => {
+      initI18n("fr");
+      expect(getLocale()).toBe("fr");
+    });
+
+    it("setLocale updates the global locale", () => {
+      setLocale("es");
+      expect(getLocale()).toBe("es");
+    });
+  });
+});

package/test/registry.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect, vi } from "vitest";
+import { ProviderRegistry } from "../src/providers/registry.js";
+import type { Provider, QueryOptions, StreamChunk } from "../src/providers/types.js";
+
+/**
+ * Registry tests — focused on the queryWithFallback behaviour, which is
+ * the core of today's reliability work:
+ *   1. Silent retry on mid-stream transient aborts
+ *   2. No mid-stream failover after visible text has already streamed
+ *   3. Lifecycle boot on asleep providers
+ *   4. Fallback chain traversal when providers are unavailable
+ */
+
+// Mock provider factory — lets each test craft the exact chunk sequence
+function createMockProvider(opts: {
+  key?: string;
+  available?: boolean;
+  chunks: StreamChunk[];
+  attempts?: number[]; // per-attempt chunk sets (for retry tests)
+}): Provider {
+  let attemptIndex = 0;
+  return {
+    config: {
+      type: "openai-compatible",
+      name: opts.key || "mock",
+      model: "mock-model",
+    },
+    isAvailable: async () => opts.available ?? true,
+    getInfo: () => ({
+      name: opts.key || "mock",
+      model: "mock-model",
+      status: "mock",
+    }),
+    async *query(_options: QueryOptions): AsyncGenerator<StreamChunk> {
+      // If per-attempt sequences provided, use them in order
+      if (opts.attempts && opts.attempts.length > 0) {
+        const idx = Math.min(attemptIndex, opts.attempts.length - 1);
+        const count = opts.attempts[idx];
+        attemptIndex++;
+        for (let i = 0; i < count; i++) {
+          yield opts.chunks[i];
+        }
+      } else {
+        for (const c of opts.chunks) yield c;
+      }
+    },
+  };
+}
+
+describe("ProviderRegistry.queryWithFallback", () => {
+  it("yields chunks from the active provider on a happy path", async () => {
+    const provider = createMockProvider({
+      chunks: [
+        { type: "text", text: "hello world" },
+        { type: "done", text: "hello world", inputTokens: 10, outputTokens: 5 },
+      ],
+    });
+
+    const registry = new ProviderRegistry({
+      primary: "mock",
+      fallbacks: [],
+      providers: { mock: provider.config },
+    });
+    // Manually wire the mock provider — createProvider dispatches by type,
+    // which would create a real OpenAICompatibleProvider. We inject directly.
+    (registry as unknown as { providers: Map<string, Provider> }).providers.set("mock", provider);
+
+    const chunks: StreamChunk[] = [];
+    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
+      chunks.push(c);
+    }
+    expect(chunks.length).toBe(2);
+    expect(chunks[0]?.type).toBe("text");
+    expect(chunks[1]?.type).toBe("done");
+  });
+
+  it("falls back to the next provider when the active one has no visible text and errors", async () => {
+    const primary = createMockProvider({
+      chunks: [{ type: "error", error: "rate limit" }],
+    });
+    const fallback = createMockProvider({
+      chunks: [
+        { type: "text", text: "fallback answer" },
+        { type: "done", text: "fallback answer" },
+      ],
+    });
+
+    const registry = new ProviderRegistry({
+      primary: "primary",
+      fallbacks: ["fallback"],
+      providers: {
+        primary: primary.config,
+        fallback: fallback.config,
+      },
+    });
+    const internal = (registry as unknown as { providers: Map<string, Provider> }).providers;
+    internal.set("primary", primary);
+    internal.set("fallback", fallback);
+
+    const chunks: StreamChunk[] = [];
+    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
+      chunks.push(c);
+    }
+
+    // Expect: fallback chunk (switching notification), then text + done from fallback
+    const types = chunks.map((c) => c.type);
+    expect(types).toContain("fallback");
+    expect(types).toContain("text");
+    expect(types).toContain("done");
+  });
+
+  it("surfaces a terminal error (no fallback) when the active provider fails mid-stream", async () => {
+    const primary = createMockProvider({
+      chunks: [
+        { type: "text", text: "I'm starting the an" },
+        { type: "error", error: "Request aborted" },
+      ],
+    });
+    const fallback = createMockProvider({
+      chunks: [
+        { type: "text", text: "different answer" },
+        { type: "done", text: "different answer" },
+      ],
+    });
+
+    const registry = new ProviderRegistry({
+      primary: "primary",
+      fallbacks: ["fallback"],
+      providers: {
+        primary: primary.config,
+        fallback: fallback.config,
+      },
+    });
+    const internal = (registry as unknown as { providers: Map<string, Provider> }).providers;
+    internal.set("primary", primary);
+    internal.set("fallback", fallback);
+
+    const chunks: StreamChunk[] = [];
+    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
+      chunks.push(c);
+    }
+
+    // We SHOULD get the first text chunk (visible text)
+    // We SHOULD NOT get any fallback-provider chunks
+    // We SHOULD get a final error chunk with the "mid-stream" message
+    const texts = chunks.filter((c) => c.type === "text");
+    expect(texts.length).toBeGreaterThanOrEqual(1);
+    expect(texts.some((c) => c.text?.includes("different answer"))).toBe(false);
+
+    const errors = chunks.filter((c) => c.type === "error");
+    expect(errors.length).toBe(1);
+    // Mid-stream message is localised, just check it mentions the provider name
+    expect(errors[0]?.error).toContain("mock");
+  });
+
+  it("retries the SAME provider on mid-stream abort before giving up", async () => {
+    // First attempt: emits text then aborts mid-stream
+    // Second attempt: emits text and completes successfully
+    const querySpy = vi.fn();
+    let attemptCount = 0;
+    const provider: Provider = {
+      config: {
+        type: "openai-compatible",
+        name: "retry-test",
+        model: "m",
+      },
+      isAvailable: async () => true,
+      getInfo: () => ({ name: "retry-test", model: "m", status: "ok" }),
+      async *query() {
+        querySpy();
+        attemptCount++;
+        if (attemptCount === 1) {
+          yield { type: "text", text: "first partial" } as StreamChunk;
+          yield { type: "error", error: "Request aborted" } as StreamChunk;
+        } else {
+          yield { type: "text", text: "retry success" } as StreamChunk;
+          yield { type: "done", text: "retry success" } as StreamChunk;
+        }
+      },
+    };
+
+    const registry = new ProviderRegistry({
+      primary: "retry-test",
+      fallbacks: [],
+      providers: { "retry-test": provider.config },
+    });
+    (registry as unknown as { providers: Map<string, Provider> }).providers.set("retry-test", provider);
+
+    const chunks: StreamChunk[] = [];
+    for await (const c of registry.queryWithFallback({ prompt: "hi" })) {
+      chunks.push(c);
+    }
+
+    // query() should have been called twice — original attempt + 1 retry
+    expect(querySpy).toHaveBeenCalledTimes(2);
+    // The final done chunk should reflect the retry's success
+    const done = chunks.find((c) => c.type === "done");
+    expect(done).toBeDefined();
+    expect(done?.text).toBe("retry success");
+  }, 15_000); // allow for the 2s retry delay
+});

package/test/subagent-delivery.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import fs from "fs";
+import os from "os";
+import { resolve } from "path";
+import type { SubAgentInfo, SubAgentResult } from "../src/services/subagents.js";
+
+const TEST_DATA_DIR = resolve(os.tmpdir(), `alvin-bot-delivery-${process.pid}-${Date.now()}`);
+
+const sentMessages: Array<{ chatId: number; text: string }> = [];
+const sentDocuments: Array<{ chatId: number }> = [];
+
+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;
+  sentMessages.length = 0;
+  sentDocuments.length = 0;
+  vi.resetModules();
+});
+
+async function wireFakeApi() {
+  const mod = await import("../src/services/subagent-delivery.js");
+  mod.__setBotApiForTest({
+    sendMessage: async (chatId: number, text: string) => {
+      sentMessages.push({ chatId, text });
+      return {};
+    },
+    sendDocument: async (chatId: number) => {
+      sentDocuments.push({ chatId });
+      return {};
+    },
+  });
+  return mod;
+}
+
+describe("subagent-delivery (I3)", () => {
+  it("does nothing for source='implicit' (parent-stream handles it)", async () => {
+    const mod = await wireFakeApi();
+
+    const info: SubAgentInfo = {
+      id: "x",
+      name: "impl",
+      status: "completed",
+      startedAt: Date.now() - 1000,
+      source: "implicit",
+      depth: 0,
+      parentChatId: 123,
+    };
+    const result: SubAgentResult = {
+      id: "x",
+      name: "impl",
+      status: "completed",
+      output: "anything",
+      tokensUsed: { input: 10, output: 5 },
+      duration: 1000,
+    };
+
+    await mod.deliverSubAgentResult(info, result);
+    expect(sentMessages).toHaveLength(0);
+    expect(sentDocuments).toHaveLength(0);
+  });
+
+  it("sends banner+final to parentChatId for source='user'", async () => {
+    const mod = await wireFakeApi();
+
+    const info: SubAgentInfo = {
+      id: "u",
+      name: "code-review",
+      status: "completed",
+      startedAt: Date.now() - 192000,
+      source: "user",
+      depth: 0,
+      parentChatId: 555,
+    };
+    const result: SubAgentResult = {
+      id: "u",
+      name: "code-review",
+      status: "completed",
+      output: "Found 2 issues:\n1. bug\n2. nit",
+      tokensUsed: { input: 4200, output: 2100 },
+      duration: 192000,
+    };
+
+    await mod.deliverSubAgentResult(info, result);
+    expect(sentMessages.length).toBeGreaterThanOrEqual(1);
+    const all = sentMessages.map((m) => m.text).join("\n");
+    expect(sentMessages[0].chatId).toBe(555);
+    expect(all).toContain("code-review");
+    expect(all).toContain("4.2k"); // token formatting
+    expect(all).toContain("2.1k");
+    expect(all).toContain("Found 2 issues");
+  });
+
+  it("splits long output into chunks (>3800 chars)", async () => {
+    const mod = await wireFakeApi();
+
+    const info: SubAgentInfo = {
+      id: "c",
+      name: "long",
+      status: "completed",
+      startedAt: Date.now() - 1000,
+      source: "user",
+      depth: 0,
+      parentChatId: 1,
+    };
+    const result: SubAgentResult = {
+      id: "c",
+      name: "long",
+      status: "completed",
+      output: "x".repeat(9000),
+      tokensUsed: { input: 0, output: 9000 },
+      duration: 1000,
+    };
+
+    await mod.deliverSubAgentResult(info, result);
+    // Expect: 1 banner + 3 content chunks (9000 / 3800 = 3 chunks)
+    expect(sentMessages.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("silent visibility produces no delivery", async () => {
+    const mod = await wireFakeApi();
+
+    const info: SubAgentInfo = {
+      id: "s",
+      name: "silent-job",
+      status: "completed",
+      startedAt: Date.now() - 1000,
+      source: "user",
+      depth: 0,
+      parentChatId: 1,
+    };
+    const result: SubAgentResult = {
+      id: "s",
+      name: "silent-job",
+      status: "completed",
+      output: "hello",
+      tokensUsed: { input: 1, output: 1 },
+      duration: 1000,
+    };
+
+    await mod.deliverSubAgentResult(info, result, { visibility: "silent" });
+    expect(sentMessages).toHaveLength(0);
+  });
+
+  it("missing parentChatId logs but does not throw", async () => {
+    const mod = await wireFakeApi();
+
+    const info: SubAgentInfo = {
+      id: "noparent",
+      name: "orphan",
+      status: "completed",
+      startedAt: Date.now() - 1000,
+      source: "user",
+      depth: 0,
+      // no parentChatId
+    };
+    const result: SubAgentResult = {
+      id: "noparent",
+      name: "orphan",
+      status: "completed",
+      output: "hi",
+      tokensUsed: { input: 0, output: 0 },
+      duration: 1000,
+    };
+
+    await expect(mod.deliverSubAgentResult(info, result)).resolves.toBeUndefined();
+    expect(sentMessages).toHaveLength(0);
+  });
+});
+
+describe("subagent-delivery LiveStream (A4)", () => {
+  const edits: Array<{ chatId: number; messageId: number; text: string }> = [];
+  let messageCounter = 100;
+
+  beforeEach(() => {
+    edits.length = 0;
+    messageCounter = 100;
+  });
+
+  async function wireLiveApi() {
+    const mod = await import("../src/services/subagent-delivery.js");
+    mod.__setBotApiForTest({
+      sendMessage: async (chatId: number, text: string) => {
+        sentMessages.push({ chatId, text });
+        return { message_id: messageCounter++ };
+      },
+      sendDocument: async (chatId: number) => {
+        sentDocuments.push({ chatId });
+        return {};
+      },
+      editMessageText: async (chatId: number, messageId: number, text: string) => {
+        edits.push({ chatId, messageId, text });
+        return {};
+      },
+    });
+    return mod;
+  }
+
+  it("start posts an initial 'thinking…' message and records messageId", async () => {
+    const mod = await wireLiveApi();
+    const stream = mod.createLiveStream(555, "code-review");
+    expect(stream).not.toBeNull();
+    await stream!.start();
+
+    expect(sentMessages).toHaveLength(1);
+    expect(sentMessages[0].chatId).toBe(555);
+    expect(sentMessages[0].text).toContain("thinking");
+    expect(stream!.failed).toBe(false);
+  });
+
+  it("update coalesces multiple rapid calls into a single throttled edit", async () => {
+    const mod = await wireLiveApi();
+    const stream = mod.createLiveStream(1, "fast");
+    await stream!.start();
+
+    stream!.update("hello");
+    stream!.update("hello world");
+    stream!.update("hello world and more");
+
+    // Wait for the throttle window to elapse
+    await new Promise((r) => setTimeout(r, 900));
+
+    // Should have produced exactly one edit with the LAST text
+    expect(edits.length).toBe(1);
+    expect(edits[0].text).toContain("hello world and more");
+  });
+
+  it("finalize posts a banner as a new message", async () => {
+    const mod = await wireLiveApi();
+    const stream = mod.createLiveStream(42, "done-agent");
+    await stream!.start();
+    stream!.update("final text");
+    await new Promise((r) => setTimeout(r, 900)); // let flush run
+
+    await stream!.finalize(
+      {
+        id: "x",
+        name: "done-agent",
+        status: "completed",
+        startedAt: Date.now() - 5000,
+        source: "user",
+        depth: 0,
+        parentChatId: 42,
+      },
+      {
+        id: "x",
+        name: "done-agent",
+        status: "completed",
+        output: "final text",
+        tokensUsed: { input: 100, output: 50 },
+        duration: 5000,
+      },
+    );
+
+    // Two sends total: initial "thinking…" + final banner
+    expect(sentMessages.length).toBe(2);
+    const banner = sentMessages[sentMessages.length - 1].text;
+    expect(banner).toContain("done-agent");
+    expect(banner).toContain("completed");
+  });
+
+  it("createLiveStream returns null when bot api lacks editMessageText", async () => {
+    const mod = await import("../src/services/subagent-delivery.js");
+    // Set an api that intentionally has no editMessageText
+    mod.__setBotApiForTest({
+      sendMessage: async () => ({ message_id: 1 }),
+      sendDocument: async () => ({}),
+      // no editMessageText
+    });
+    const stream = mod.createLiveStream(1, "no-edit");
+    expect(stream).toBeNull();
+  });
+});