talon-agent 1.0.0

package/src/__tests__/integration.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Integration test: dispatcher → backend (mocked) → result.
+ * Tests the full query lifecycle without spawning actual SDK processes.
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { initDispatcher, execute } from "../core/dispatcher.js";
+import type { QueryBackend, ContextManager } from "../core/types.js";
+import { TalonError } from "../core/errors.js";
+
+function setup(overrides: { queryResult?: Record<string, unknown>; queryError?: Error } = {}) {
+  const acquired: number[] = [];
+  const released: number[] = [];
+  const typingCalls: number[] = [];
+  let activityCount = 0;
+
+  const backend: QueryBackend = {
+    query: vi.fn(async () => {
+      if (overrides.queryError) throw overrides.queryError;
+      return {
+        text: "test response",
+        durationMs: 50,
+        inputTokens: 10,
+        outputTokens: 20,
+        cacheRead: 5,
+        cacheWrite: 3,
+        ...overrides.queryResult,
+      };
+    }),
+  };
+
+  const context: ContextManager = {
+    acquire: vi.fn((id: number) => acquired.push(id)),
+    release: vi.fn((id: number) => released.push(id)),
+    getMessageCount: vi.fn(() => 0),
+  };
+
+  initDispatcher({
+    backend,
+    context,
+    sendTyping: vi.fn(async (id: number) => { typingCalls.push(id); }),
+    onActivity: vi.fn(() => { activityCount++; }),
+  });
+
+  return { backend, context, acquired, released, typingCalls, getActivityCount: () => activityCount };
+}
+
+describe("integration: dispatcher lifecycle", () => {
+  it("full happy path: acquire → type → query → activity → release", async () => {
+    const { backend, acquired, released, typingCalls, getActivityCount } = setup();
+
+    const result = await execute({
+      chatId: "123",
+      numericChatId: 123,
+      prompt: "hello world",
+      senderName: "TestUser",
+      isGroup: false,
+      source: "message",
+    });
+
+    expect(result.text).toBe("test response");
+    expect(result.durationMs).toBe(50);
+    expect(result.bridgeMessageCount).toBe(0);
+
+    // Context lifecycle
+    expect(acquired).toEqual([123]);
+    expect(released).toEqual([123]);
+
+    // Typing was sent
+    expect(typingCalls).toEqual([123]);
+
+    // Activity callback fired
+    expect(getActivityCount()).toBe(1);
+
+    // Backend was called with correct params
+    expect(backend.query).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: "123",
+        text: "hello world",
+        senderName: "TestUser",
+        isGroup: false,
+      }),
+    );
+  });
+
+  it("error path: context released even on failure", async () => {
+    const { released } = setup({ queryError: new Error("SDK crashed") });
+
+    await expect(
+      execute({
+        chatId: "456",
+        numericChatId: 456,
+        prompt: "will fail",
+        senderName: "User",
+        isGroup: false,
+        source: "message",
+      }),
+    ).rejects.toThrow("SDK crashed");
+
+    expect(released).toEqual([456]);
+  });
+
+  it("classified error path: TalonError propagated", async () => {
+    const { released } = setup({
+      queryError: new TalonError("rate limited", {
+        reason: "rate_limit",
+        retryable: true,
+        retryAfterMs: 5000,
+      }),
+    });
+
+    try {
+      await execute({
+        chatId: "789",
+        numericChatId: 789,
+        prompt: "will rate limit",
+        senderName: "User",
+        isGroup: false,
+        source: "message",
+      });
+      expect.unreachable();
+    } catch (err) {
+      expect(err).toBeInstanceOf(TalonError);
+      const te = err as TalonError;
+      expect(te.reason).toBe("rate_limit");
+      expect(te.retryable).toBe(true);
+    }
+
+    expect(released).toEqual([789]);
+  });
+
+  it("cross-chat parallel execution", async () => {
+    const order: string[] = [];
+    const backend: QueryBackend = {
+      query: vi.fn(async (params) => {
+        order.push(`start:${params.chatId}`);
+        await new Promise((r) => setTimeout(r, 20));
+        order.push(`end:${params.chatId}`);
+        return { text: "", durationMs: 20, inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheWrite: 0 };
+      }),
+    };
+
+    initDispatcher({
+      backend,
+      context: {
+        acquire: () => {},
+        release: () => {},
+        getMessageCount: () => 0,
+      },
+      sendTyping: async () => {},
+      onActivity: () => {},
+    });
+
+    // Fire two queries simultaneously
+    await Promise.all([
+      execute({ chatId: "A", numericChatId: 1, prompt: "a", senderName: "U", isGroup: false, source: "message" }),
+      execute({ chatId: "B", numericChatId: 2, prompt: "b", senderName: "U", isGroup: false, source: "message" }),
+    ]);
+
+    // True concurrency — both start before either ends
+    expect(order[0]).toBe("start:A");
+    expect(order[1]).toBe("start:B");
+  });
+
+  it("stream callbacks are passed through to backend", async () => {
+    const { backend } = setup();
+    const onStreamDelta = vi.fn();
+    const onTextBlock = vi.fn();
+
+    await execute({
+      chatId: "999",
+      numericChatId: 999,
+      prompt: "stream test",
+      senderName: "User",
+      isGroup: true,
+      source: "pulse",
+      onStreamDelta,
+      onTextBlock,
+    });
+
+    expect(backend.query).toHaveBeenCalledWith(
+      expect.objectContaining({
+        onStreamDelta,
+        onTextBlock,
+        isGroup: true,
+      }),
+    );
+  });
+});

package/src/__tests__/log.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock pino before importing log module
+const mockInfo = vi.fn();
+const mockError = vi.fn();
+const mockWarn = vi.fn();
+const mockDebug = vi.fn();
+
+vi.mock("pino", () => ({
+  default: () => ({
+    info: mockInfo,
+    error: mockError,
+    warn: mockWarn,
+    debug: mockDebug,
+  }),
+}));
+
+const { log, logError, logWarn, logDebug } = await import("../util/log.js");
+
+describe("log", () => {
+  beforeEach(() => {
+    mockInfo.mockClear();
+    mockError.mockClear();
+    mockWarn.mockClear();
+    mockDebug.mockClear();
+  });
+
+  describe("log(component, message)", () => {
+    it("calls pino.info with component and message", () => {
+      log("bot", "started successfully");
+      expect(mockInfo).toHaveBeenCalledOnce();
+      expect(mockInfo).toHaveBeenCalledWith({ component: "bot" }, "started successfully");
+    });
+
+    it("works with all valid component types", () => {
+      const components = [
+        "bot", "bridge", "agent", "pulse", "userbot", "users",
+        "watchdog", "workspace", "shutdown", "file", "sessions",
+        "settings", "commands", "cron", "dispatcher",
+      ] as const;
+      for (const component of components) {
+        mockInfo.mockClear();
+        log(component, "test");
+        expect(mockInfo).toHaveBeenCalledWith({ component }, "test");
+      }
+    });
+  });
+
+  describe("logError(component, message, err?)", () => {
+    it("calls pino.error with component and message", () => {
+      logError("bot", "failed to start");
+      expect(mockError).toHaveBeenCalledOnce();
+      expect(mockError).toHaveBeenCalledWith({ component: "bot" }, "failed to start");
+    });
+
+    it("includes Error message in context", () => {
+      logError("bridge", "request failed", new Error("timeout"));
+      expect(mockError).toHaveBeenCalledWith(
+        { component: "bridge", err: "timeout" },
+        "request failed",
+      );
+    });
+
+    it("stringifies non-Error err values", () => {
+      logError("sessions", "save failed", "disk full");
+      expect(mockError).toHaveBeenCalledWith(
+        { component: "sessions", err: "disk full" },
+        "save failed",
+      );
+    });
+
+    it("handles numeric err values", () => {
+      logError("sessions", "exit code", 1);
+      expect(mockError).toHaveBeenCalledWith(
+        { component: "sessions", err: "1" },
+        "exit code",
+      );
+    });
+
+    it("omits err field when err is undefined", () => {
+      logError("settings", "something wrong");
+      expect(mockError).toHaveBeenCalledWith(
+        { component: "settings" },
+        "something wrong",
+      );
+    });
+  });
+
+  describe("logWarn(component, message)", () => {
+    it("calls pino.warn with component and message", () => {
+      logWarn("watchdog", "inactivity detected");
+      expect(mockWarn).toHaveBeenCalledOnce();
+      expect(mockWarn).toHaveBeenCalledWith(
+        { component: "watchdog" },
+        "inactivity detected",
+      );
+    });
+  });
+
+  describe("logDebug(component, message)", () => {
+    it("calls pino.debug with component and message", () => {
+      logDebug("agent", "processing query");
+      expect(mockDebug).toHaveBeenCalledOnce();
+      expect(mockDebug).toHaveBeenCalledWith(
+        { component: "agent" },
+        "processing query",
+      );
+    });
+  });
+});

package/src/__tests__/media-index.test.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(), logError: vi.fn(), logWarn: vi.fn(), logDebug: vi.fn(),
+}));
+
+const existsSyncMock = vi.fn(() => false);
+const readFileSyncMock = vi.fn(() => "[]");
+const mkdirSyncMock = vi.fn();
+const unlinkSyncMock = vi.fn();
+
+vi.mock("node:fs", () => ({
+  existsSync: existsSyncMock,
+  readFileSync: readFileSyncMock,
+  mkdirSync: mkdirSyncMock,
+  unlinkSync: unlinkSyncMock,
+}));
+
+const writeFileSyncMock = vi.fn();
+
+vi.mock("write-file-atomic", () => ({
+  default: { sync: (...args: unknown[]) => writeFileSyncMock(...args) },
+}));
+
+const { addMedia, getRecentMedia, getMediaByType, formatMediaIndex, loadMediaIndex, flushMediaIndex } = await import("../storage/media-index.js");
+
+describe("media-index", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    existsSyncMock.mockReturnValue(false);
+    readFileSyncMock.mockReturnValue("[]");
+    loadMediaIndex(); // reset state
+  });
+
+  it("adds and retrieves media", () => {
+    const cid = `add-${Date.now()}`;
+    addMedia({
+      chatId: cid, msgId: 1, senderName: "Alice", type: "photo",
+      filePath: "/tmp/photo.jpg", timestamp: Date.now(),
+    });
+    const media = getRecentMedia(cid);
+    expect(media).toHaveLength(1);
+    expect(media[0].type).toBe("photo");
+    expect(media[0].filePath).toBe("/tmp/photo.jpg");
+  });
+
+  it("returns empty for unknown chat", () => {
+    expect(getRecentMedia(`unknown-${Date.now()}`)).toHaveLength(0);
+  });
+
+  it("filters by type", () => {
+    const cid = `type-${Date.now()}`;
+    addMedia({ chatId: cid, msgId: 1, senderName: "A", type: "photo", filePath: "/a.jpg", timestamp: Date.now() });
+    addMedia({ chatId: cid, msgId: 2, senderName: "A", type: "document", filePath: "/b.pdf", timestamp: Date.now() });
+    addMedia({ chatId: cid, msgId: 3, senderName: "A", type: "photo", filePath: "/c.jpg", timestamp: Date.now() });
+
+    expect(getMediaByType(cid, "photo")).toHaveLength(2);
+    expect(getMediaByType(cid, "document")).toHaveLength(1);
+  });
+
+  it("deduplicates by chatId:msgId", () => {
+    const chatId = `dedup-${Date.now()}`;
+    addMedia({ chatId, msgId: 1, senderName: "A", type: "photo", filePath: "/a.jpg", timestamp: 1000 });
+    addMedia({ chatId, msgId: 1, senderName: "A", type: "photo", filePath: "/b.jpg", timestamp: 2000 });
+
+    const media = getRecentMedia(chatId);
+    expect(media).toHaveLength(1);
+    expect(media[0].filePath).toBe("/b.jpg");
+  });
+
+  it("formats index as text", () => {
+    addMedia({ chatId: "456", msgId: 10, senderName: "Bob", type: "photo", filePath: "/photo.jpg", caption: "sunset", timestamp: Date.now() });
+    const text = formatMediaIndex("456");
+    expect(text).toContain("photo");
+    expect(text).toContain("Bob");
+    expect(text).toContain("/photo.jpg");
+    expect(text).toContain("sunset");
+  });
+
+  it("returns 'no recent media' for empty chat", () => {
+    expect(formatMediaIndex("empty")).toContain("No recent media");
+  });
+
+  it("limits results", () => {
+    for (let i = 0; i < 15; i++) {
+      addMedia({ chatId: "789", msgId: i, senderName: "C", type: "photo", filePath: `/p${i}.jpg`, timestamp: Date.now() + i });
+    }
+    expect(getRecentMedia("789", 5)).toHaveLength(5);
+  });
+
+  it("returns newest first", () => {
+    addMedia({ chatId: "100", msgId: 1, senderName: "A", type: "photo", filePath: "/old.jpg", timestamp: 1000 });
+    addMedia({ chatId: "100", msgId: 2, senderName: "A", type: "photo", filePath: "/new.jpg", timestamp: 2000 });
+
+    const media = getRecentMedia("100");
+    expect(media[0].filePath).toBe("/new.jpg");
+  });
+
+  describe("addMedia with all media types", () => {
+    it("supports all media type variants", () => {
+      const cid = `types-${Date.now()}`;
+      const types = ["photo", "document", "voice", "video", "animation", "audio", "sticker"] as const;
+      types.forEach((type, i) => {
+        addMedia({ chatId: cid, msgId: i + 1, senderName: "User", type, filePath: `/tmp/${type}.bin`, timestamp: Date.now() + i });
+      });
+      const media = getRecentMedia(cid, 20);
+      expect(media).toHaveLength(7);
+      const returnedTypes = media.map((m) => m.type).sort();
+      expect(returnedTypes).toEqual([...types].sort());
+    });
+
+    it("supports caption field", () => {
+      const cid = `cap-${Date.now()}`;
+      addMedia({ chatId: cid, msgId: 1, senderName: "User", type: "photo", filePath: "/a.jpg", caption: "My caption", timestamp: Date.now() });
+      const media = getRecentMedia(cid);
+      expect(media[0].caption).toBe("My caption");
+    });
+
+    it("generates correct id from chatId:msgId", () => {
+      const cid = `id-${Date.now()}`;
+      addMedia({ chatId: cid, msgId: 42, senderName: "User", type: "photo", filePath: "/a.jpg", timestamp: Date.now() });
+      const media = getRecentMedia(cid);
+      expect(media[0].id).toBe(`${cid}:42`);
+    });
+  });
+
+  describe("formatMediaIndex output format", () => {
+    it("includes timestamp in readable format", () => {
+      const ts = new Date("2025-03-15T14:30:00Z").getTime();
+      addMedia({ chatId: "fmt-1", msgId: 1, senderName: "Alice", type: "document", filePath: "/doc.pdf", timestamp: ts });
+      const text = formatMediaIndex("fmt-1");
+      expect(text).toContain("2025-03-15 14:30");
+      expect(text).toContain("[document]");
+      expect(text).toContain("msg:1");
+      expect(text).toContain("by Alice");
+      expect(text).toContain("file: /doc.pdf");
+    });
+
+    it("truncates long captions at 50 characters", () => {
+      const longCaption = "A".repeat(100);
+      addMedia({ chatId: "fmt-2", msgId: 1, senderName: "Bob", type: "photo", filePath: "/p.jpg", caption: longCaption, timestamp: Date.now() });
+      const text = formatMediaIndex("fmt-2");
+      // Caption should be truncated to 50 chars
+      expect(text).toContain(`"${"A".repeat(50)}"`);
+      expect(text).not.toContain(`"${"A".repeat(51)}"`);
+    });
+
+    it("omits caption when not provided", () => {
+      addMedia({ chatId: "fmt-3", msgId: 1, senderName: "Bob", type: "photo", filePath: "/p.jpg", timestamp: Date.now() });
+      const text = formatMediaIndex("fmt-3");
+      // Should not contain empty quotes
+      expect(text).not.toContain('""');
+    });
+
+    it("respects limit parameter", () => {
+      for (let i = 0; i < 20; i++) {
+        addMedia({ chatId: "fmt-4", msgId: i, senderName: "C", type: "photo", filePath: `/p${i}.jpg`, timestamp: Date.now() + i });
+      }
+      const text = formatMediaIndex("fmt-4", 3);
+      // Each entry has 2 lines (info + file path), so 3 entries
+      const entryCount = (text.match(/\[photo\]/g) || []).length;
+      expect(entryCount).toBe(3);
+    });
+  });
+
+  describe("getMediaByType", () => {
+    it("returns empty array when no entries match type", () => {
+      const cid = `type-none-${Date.now()}`;
+      addMedia({ chatId: cid, msgId: 1, senderName: "A", type: "photo", filePath: "/a.jpg", timestamp: Date.now() });
+      expect(getMediaByType(cid, "voice")).toHaveLength(0);
+    });
+
+    it("respects limit parameter", () => {
+      const cid = `type-limit-${Date.now()}`;
+      for (let i = 0; i < 15; i++) {
+        addMedia({ chatId: cid, msgId: i, senderName: "A", type: "photo", filePath: `/p${i}.jpg`, timestamp: Date.now() + i });
+      }
+      expect(getMediaByType(cid, "photo", 5)).toHaveLength(5);
+    });
+
+    it("returns newest first", () => {
+      const cid = `type-order-${Date.now()}`;
+      addMedia({ chatId: cid, msgId: 1, senderName: "A", type: "voice", filePath: "/old.ogg", timestamp: 1000 });
+      addMedia({ chatId: cid, msgId: 2, senderName: "A", type: "voice", filePath: "/new.ogg", timestamp: 2000 });
+      const result = getMediaByType(cid, "voice");
+      expect(result[0].filePath).toBe("/new.ogg");
+    });
+  });
+
+  describe("loadMediaIndex", () => {
+    it("loads entries from existing file", () => {
+      const stored = [
+        { id: "load-1:1", chatId: "load-1", msgId: 1, senderName: "Alice", type: "photo", filePath: "/a.jpg", timestamp: Date.now() },
+        { id: "load-1:2", chatId: "load-1", msgId: 2, senderName: "Bob", type: "document", filePath: "/b.pdf", timestamp: Date.now() },
+      ];
+      existsSyncMock.mockReturnValue(true);
+      readFileSyncMock.mockReturnValue(JSON.stringify(stored));
+
+      loadMediaIndex();
+
+      const media = getRecentMedia("load-1");
+      expect(media).toHaveLength(2);
+    });
+
+    it("handles JSON parse errors gracefully", () => {
+      existsSyncMock.mockReturnValue(true);
+      readFileSyncMock.mockReturnValue("not valid json{{{");
+
+      // Should not throw, entries should be reset to []
+      expect(() => loadMediaIndex()).not.toThrow();
+    });
+
+    it("purges expired entries on load", () => {
+      const oldTimestamp = Date.now() - 8 * 24 * 60 * 60 * 1000; // 8 days ago (expired)
+      const recentTimestamp = Date.now() - 1000; // 1 second ago (fresh)
+      const stored = [
+        { id: "purge:1", chatId: "purge", msgId: 1, senderName: "A", type: "photo", filePath: "/old.jpg", timestamp: oldTimestamp },
+        { id: "purge:2", chatId: "purge", msgId: 2, senderName: "A", type: "photo", filePath: "/new.jpg", timestamp: recentTimestamp },
+      ];
+      existsSyncMock.mockReturnValue(true);
+      readFileSyncMock.mockReturnValue(JSON.stringify(stored));
+
+      loadMediaIndex();
+
+      const media = getRecentMedia("purge");
+      expect(media).toHaveLength(1);
+      expect(media[0].filePath).toBe("/new.jpg");
+    });
+
+    it("deletes expired media files from disk during purge", () => {
+      const oldTimestamp = Date.now() - 8 * 24 * 60 * 60 * 1000;
+      const stored = [
+        { id: "del:1", chatId: "del", msgId: 1, senderName: "A", type: "photo", filePath: "/expired.jpg", timestamp: oldTimestamp },
+      ];
+      // existsSync: first call for STORE_FILE=true, then for filePath during purge=true
+      existsSyncMock.mockReturnValue(true);
+      readFileSyncMock.mockReturnValue(JSON.stringify(stored));
+
+      loadMediaIndex();
+
+      expect(unlinkSyncMock).toHaveBeenCalledWith("/expired.jpg");
+    });
+  });
+
+  describe("flushMediaIndex", () => {
+    it("writes entries to disk", () => {
+      addMedia({ chatId: "flush-1", msgId: 1, senderName: "A", type: "photo", filePath: "/a.jpg", timestamp: Date.now() });
+
+      existsSyncMock.mockReturnValue(true);
+      flushMediaIndex();
+
+      expect(writeFileSyncMock).toHaveBeenCalled();
+      const writtenData = writeFileSyncMock.mock.calls[0][1] as string;
+      const parsed = JSON.parse(writtenData.trim());
+      expect(Array.isArray(parsed)).toBe(true);
+      expect(parsed.length).toBeGreaterThan(0);
+    });
+
+    it("creates workspace directory if it does not exist", () => {
+      addMedia({ chatId: "flush-2", msgId: 1, senderName: "A", type: "photo", filePath: "/a.jpg", timestamp: Date.now() });
+
+      existsSyncMock.mockReturnValue(false);
+      flushMediaIndex();
+
+      expect(mkdirSyncMock).toHaveBeenCalledWith(expect.any(String), { recursive: true });
+    });
+
+    it("handles write errors gracefully", () => {
+      addMedia({ chatId: "flush-3", msgId: 1, senderName: "A", type: "photo", filePath: "/a.jpg", timestamp: Date.now() });
+
+      existsSyncMock.mockReturnValue(true);
+      writeFileSyncMock.mockImplementationOnce(() => { throw new Error("disk full"); });
+
+      expect(() => flushMediaIndex()).not.toThrow();
+    });
+  });
+});