talon-agent 1.0.0

package/src/__tests__/gateway-context.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+  logDebug: vi.fn(),
+}));
+
+vi.mock("../core/gateway-actions.js", () => ({
+  handleSharedAction: vi.fn(async () => null),
+}));
+
+import { Gateway } from "../core/gateway.js";
+
+describe("gateway per-chat context", () => {
+  let gateway: Gateway;
+
+  beforeEach(() => {
+    gateway = new Gateway();
+  });
+
+  it("sets context for a chat", () => {
+    gateway.setContext(12345);
+    expect(gateway.isChatBusy(12345)).toBe(true);
+    expect(gateway.getActiveChats()).toBe(1);
+  });
+
+  it("returns false for unknown chat", () => {
+    expect(gateway.isChatBusy(99999)).toBe(false);
+  });
+
+  it("clears context on release", () => {
+    gateway.setContext(200);
+    gateway.clearContext(200);
+    expect(gateway.isChatBusy(200)).toBe(false);
+    expect(gateway.getActiveChats()).toBe(0);
+  });
+
+  it("ref counting: same chat twice needs two clears", () => {
+    gateway.setContext(300);
+    gateway.setContext(300); // ref++
+
+    gateway.clearContext(300);
+    expect(gateway.isChatBusy(300)).toBe(true); // still active
+
+    gateway.clearContext(300);
+    expect(gateway.isChatBusy(300)).toBe(false); // now released
+  });
+
+  it("multiple chats can be active simultaneously", () => {
+    gateway.setContext(100);
+    gateway.setContext(200);
+    gateway.setContext(300);
+
+    expect(gateway.isChatBusy(100)).toBe(true);
+    expect(gateway.isChatBusy(200)).toBe(true);
+    expect(gateway.isChatBusy(300)).toBe(true);
+    expect(gateway.getActiveChats()).toBe(3);
+
+    gateway.clearContext(200);
+    expect(gateway.isChatBusy(100)).toBe(true);
+    expect(gateway.isChatBusy(200)).toBe(false);
+    expect(gateway.isChatBusy(300)).toBe(true);
+    expect(gateway.getActiveChats()).toBe(2);
+  });
+
+  it("message count is per-chat", () => {
+    gateway.setContext(500);
+    gateway.setContext(600);
+
+    expect(gateway.getMessageCount(500)).toBe(0);
+    expect(gateway.getMessageCount(600)).toBe(0);
+
+    gateway.incrementMessages(500);
+    gateway.incrementMessages(500);
+    gateway.incrementMessages(600);
+
+    expect(gateway.getMessageCount(500)).toBe(2);
+    expect(gateway.getMessageCount(600)).toBe(1);
+  });
+
+  it("message count resets when context is released and re-acquired", () => {
+    gateway.setContext(700);
+    gateway.incrementMessages(700);
+    expect(gateway.getMessageCount(700)).toBe(1);
+
+    gateway.clearContext(700);
+    gateway.setContext(700);
+    expect(gateway.getMessageCount(700)).toBe(0);
+  });
+
+  it("message count returns 0 for unknown chat", () => {
+    expect(gateway.getMessageCount(99999)).toBe(0);
+  });
+
+  it("clearContext with no chatId does nothing", () => {
+    gateway.setContext(800);
+    gateway.clearContext();
+    expect(gateway.isChatBusy(800)).toBe(true);
+  });
+});

package/src/__tests__/gateway-http.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, vi } from "vitest";
+
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(), logError: vi.fn(), logWarn: vi.fn(), logDebug: vi.fn(),
+}));
+
+vi.mock("../core/plugin.js", () => ({
+  handlePluginAction: vi.fn(async () => null),
+}));
+
+vi.mock("../util/watchdog.js", () => ({
+  getHealthStatus: vi.fn(() => ({
+    healthy: true, totalMessagesProcessed: 0, recentErrorCount: 0, msSinceLastMessage: 0,
+  })),
+}));
+
+vi.mock("../storage/sessions.js", () => ({
+  getActiveSessionCount: vi.fn(() => 0),
+}));
+
+vi.mock("../core/dispatcher.js", () => ({
+  getActiveCount: vi.fn(() => 0),
+}));
+
+// Mock cron-store for shared actions
+vi.mock("../storage/cron-store.js", () => ({
+  addCronJob: vi.fn(),
+  getCronJob: vi.fn(),
+  getCronJobsForChat: vi.fn(() => []),
+  updateCronJob: vi.fn(),
+  deleteCronJob: vi.fn(),
+  validateCronExpression: vi.fn(() => ({ valid: true, next: new Date().toISOString() })),
+  generateCronId: vi.fn(() => "test-id"),
+  loadCronJobs: vi.fn(),
+}));
+
+vi.mock("write-file-atomic", () => ({
+  default: { sync: vi.fn() },
+}));
+
+import { Gateway } from "../core/gateway.js";
+
+let gateway: Gateway;
+let port: number;
+
+// Mock frontend handler
+const mockFrontendHandler = vi.fn(async (body: Record<string, unknown>) => {
+  const action = body.action as string;
+  if (action === "send_message") return { ok: true, message_id: 42, text: "sent" };
+  if (action === "get_chat_info") return { ok: true, id: 123, type: "private" };
+  return null;
+});
+
+beforeAll(async () => {
+  gateway = new Gateway();
+  gateway.setFrontendHandler(mockFrontendHandler);
+  port = await gateway.start(19899); // test port
+});
+
+afterAll(async () => {
+  await gateway.stop();
+});
+
+beforeEach(() => {
+  // Clear contexts for known test chatIds
+  for (const id of [123, 999]) {
+    gateway.clearContext(id);
+    gateway.clearContext(id);
+  }
+  mockFrontendHandler.mockClear();
+});
+
+async function post(body: Record<string, unknown>): Promise<{ status: number; body: Record<string, unknown> }> {
+  const resp = await fetch(`http://127.0.0.1:${port}/action`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  return { status: resp.status, body: await resp.json() as Record<string, unknown> };
+}
+
+describe("gateway HTTP server", () => {
+  describe("health endpoint", () => {
+    it("returns health JSON", async () => {
+      const resp = await fetch(`http://127.0.0.1:${port}/health`);
+      expect(resp.status).toBe(200);
+      const data = await resp.json() as Record<string, unknown>;
+      expect(data.ok).toBeDefined();
+      expect(data.uptime).toBeDefined();
+      expect(data.memory).toBeDefined();
+    });
+  });
+
+  describe("404 handling", () => {
+    it("returns 404 for unknown paths", async () => {
+      const resp = await fetch(`http://127.0.0.1:${port}/nonexistent`);
+      expect(resp.status).toBe(404);
+    });
+
+    it("returns 404 for GET /action", async () => {
+      const resp = await fetch(`http://127.0.0.1:${port}/action`);
+      expect(resp.status).toBe(404);
+    });
+  });
+
+  describe("malformed requests", () => {
+    it("returns 400 for invalid JSON", async () => {
+      const resp = await fetch(`http://127.0.0.1:${port}/action`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: "not valid json{{{",
+      });
+      expect(resp.status).toBe(400);
+      const data = await resp.json() as Record<string, unknown>;
+      expect(data.ok).toBe(false);
+      expect(data.error).toContain("Invalid JSON");
+    });
+  });
+
+  describe("action routing", () => {
+    it("returns error when no active context", async () => {
+      const { body } = await post({ action: "send_message", text: "hi" });
+      expect(body.ok).toBe(false);
+      expect(body.error).toContain("No active chat context");
+    });
+
+    it("routes to shared actions (cron)", async () => {
+      gateway.setContext(123);
+      const { body } = await post({ action: "list_cron_jobs", _chatId: "123" });
+      expect(body.ok).toBe(true);
+      gateway.clearContext(123);
+    });
+
+    it("routes to frontend handler", async () => {
+      gateway.setContext(123);
+      const { body } = await post({ action: "send_message", _chatId: "123", text: "hello" });
+      expect(body.ok).toBe(true);
+      expect(body.message_id).toBe(42);
+      expect(mockFrontendHandler).toHaveBeenCalled();
+      gateway.clearContext(123);
+    });
+
+    it("returns error for unknown action", async () => {
+      gateway.setContext(123);
+      const { body } = await post({ action: "completely_unknown_action", _chatId: "123" });
+      expect(body.ok).toBe(false);
+      expect(body.error).toContain("Unknown action");
+      gateway.clearContext(123);
+    });
+
+    it("returns error for missing action field", async () => {
+      gateway.setContext(123);
+      const { body } = await post({ _chatId: "123", text: "no action" });
+      expect(body.ok).toBe(false);
+      expect(body.error).toContain("Missing action");
+      gateway.clearContext(123);
+    });
+
+    it("rejects unknown chatId (no active context)", async () => {
+      const { body } = await post({ action: "send_message", _chatId: "999" });
+      expect(body.ok).toBe(false);
+      expect(body.error).toContain("No active chat context");
+    });
+  });
+
+  describe("concurrent chat contexts via HTTP", () => {
+    it("handles two chats simultaneously", async () => {
+      gateway.setContext(100);
+      gateway.setContext(200);
+
+      const [r1, r2] = await Promise.all([
+        post({ action: "send_message", _chatId: "100", text: "from chat 100" }),
+        post({ action: "send_message", _chatId: "200", text: "from chat 200" }),
+      ]);
+
+      expect(r1.body.ok).toBe(true);
+      expect(r2.body.ok).toBe(true);
+      expect(mockFrontendHandler).toHaveBeenCalledTimes(2);
+
+      gateway.clearContext(100);
+      gateway.clearContext(200);
+    });
+
+    it("one chat's context doesn't affect another", async () => {
+      gateway.setContext(300);
+      // Chat 400 has no context
+      const { body } = await post({ action: "send_message", _chatId: "400", text: "no context" });
+      expect(body.ok).toBe(false);
+      expect(body.error).toContain("No active chat context");
+      // Chat 300 still works
+      const r2 = await post({ action: "send_message", _chatId: "300", text: "still works" });
+      expect(r2.body.ok).toBe(true);
+      gateway.clearContext(300);
+    });
+
+    it("frontend handler error returns error result (doesn't crash server)", async () => {
+      const errorHandler = vi.fn(async () => { throw new Error("handler exploded"); });
+      gateway.setFrontendHandler(errorHandler);
+      gateway.setContext(123);
+
+      const { status, body } = await post({ action: "send_message", _chatId: "123", text: "boom" });
+
+      expect(status).toBe(200); // HTTP 200, error in body
+      expect(body.ok).toBe(false);
+      expect(body.error).toContain("handler exploded");
+
+      gateway.clearContext(123);
+      gateway.setFrontendHandler(mockFrontendHandler); // restore
+    });
+
+    it("request without _chatId is rejected", async () => {
+      gateway.setContext(123);
+      const { body } = await post({ action: "send_message", text: "no chatId" });
+      expect(body.ok).toBe(false);
+      expect(body.error).toContain("No active chat context");
+      gateway.clearContext(123);
+    });
+  });
+
+  describe("shared actions via HTTP", () => {
+    it("fetch_url rejects invalid URLs", async () => {
+      gateway.setContext(123);
+      const { body } = await post({ action: "fetch_url", _chatId: "123", url: "not-a-url" });
+      expect(body.ok).toBe(false);
+      gateway.clearContext(123);
+    });
+
+    it("read_history returns ok", async () => {
+      gateway.setContext(123);
+      const { body } = await post({ action: "read_history", _chatId: "123" });
+      expect(body.ok).toBe(true);
+      gateway.clearContext(123);
+    });
+
+    it("create_cron_job works", async () => {
+      gateway.setContext(123);
+      const { body } = await post({
+        action: "create_cron_job", _chatId: "123",
+        name: "test", schedule: "0 9 * * *", type: "message", content: "hello",
+      });
+      expect(body.ok).toBe(true);
+      gateway.clearContext(123);
+    });
+  });
+});

package/src/__tests__/handlers.test.ts

@@ -0,0 +1,351 @@
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("../../core/dispatcher.js", () => ({
+  execute: vi.fn(),
+}));
+vi.mock("../../core/prompt-builder.js", () => ({
+  enrichDMPrompt: vi.fn((p: string) => p),
+  enrichGroupPrompt: vi.fn((p: string) => p),
+}));
+vi.mock("../../storage/daily-log.js", () => ({
+  appendDailyLog: vi.fn(),
+}));
+vi.mock("../../util/watchdog.js", () => ({
+  recordMessageProcessed: vi.fn(),
+  recordError: vi.fn(),
+}));
+vi.mock("../../util/log.js", () => ({
+  log: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+  logDebug: vi.fn(),
+}));
+vi.mock("../../core/errors.js", () => ({
+  classify: vi.fn((e: unknown) => e),
+  friendlyMessage: vi.fn(() => "error"),
+}));
+
+vi.mock("../../storage/history.js", () => ({
+  setMessageFilePath: vi.fn(),
+  getRecentBySenderId: vi.fn(() => []),
+}));
+vi.mock("../../storage/media-index.js", () => ({
+  addMedia: vi.fn(),
+}));
+vi.mock("node:fs", () => ({
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+const { shouldHandleInGroup, getSenderName, getReplyContext, getForwardContext } = await import(
+  "../frontend/telegram/handlers.js"
+);
+
+describe("shouldHandleInGroup", () => {
+  const makeCtx = (overrides: {
+    type?: string;
+    text?: string;
+    username?: string;
+    replyFromId?: number;
+    botId?: number;
+  } = {}) => ({
+    chat: { type: overrides.type ?? "supergroup" },
+    me: { id: overrides.botId ?? 999, username: overrides.username ?? "testbot" },
+    message: {
+      text: overrides.text ?? "",
+      caption: undefined,
+      reply_to_message: overrides.replyFromId
+        ? { from: { id: overrides.replyFromId } }
+        : undefined,
+    },
+  });
+
+  // Cast partial objects to any — we only test the mention/reply logic, not the full Context
+  const ctx = (overrides: Parameters<typeof makeCtx>[0] = {}) =>
+    makeCtx(overrides) as any;
+
+  it("returns true for DMs (not a group)", () => {
+    expect(shouldHandleInGroup({ ...ctx(), chat: { type: "private" } })).toBe(true);
+  });
+
+  it("returns true when bot is mentioned with @", () => {
+    expect(shouldHandleInGroup(ctx({ text: "hey @testbot what's up" }))).toBe(true);
+  });
+
+  it("returns true when bot is mentioned case-insensitively", () => {
+    expect(shouldHandleInGroup(ctx({ text: "Hey @TestBot!" }))).toBe(true);
+  });
+
+  it("returns false when a different bot is mentioned", () => {
+    expect(shouldHandleInGroup(ctx({ text: "hey @testbot123 what's up" }))).toBe(false);
+  });
+
+  it("returns false when bot name appears without @", () => {
+    expect(shouldHandleInGroup(ctx({ text: "testbot is cool" }))).toBe(false);
+  });
+
+  it("returns true when replying to the bot", () => {
+    expect(shouldHandleInGroup(ctx({ replyFromId: 999, botId: 999 }))).toBe(true);
+  });
+
+  it("returns false when replying to someone else", () => {
+    expect(shouldHandleInGroup(ctx({ replyFromId: 123, botId: 999 }))).toBe(false);
+  });
+
+  it("returns false for plain group message without mention or reply", () => {
+    expect(shouldHandleInGroup(ctx({ text: "hello everyone" }))).toBe(false);
+  });
+
+  it("handles @mention at end of message", () => {
+    expect(shouldHandleInGroup(ctx({ text: "what do you think @testbot" }))).toBe(true);
+  });
+
+  it("handles @mention with punctuation after", () => {
+    expect(shouldHandleInGroup(ctx({ text: "@testbot, help me" }))).toBe(true);
+  });
+});
+
+describe("getSenderName", () => {
+  it("returns first + last name", () => {
+    expect(getSenderName({ first_name: "John", last_name: "Doe" })).toBe("John Doe");
+  });
+
+  it("returns first name only when no last name", () => {
+    expect(getSenderName({ first_name: "Alice" })).toBe("Alice");
+  });
+
+  it("returns 'User' when undefined", () => {
+    expect(getSenderName(undefined)).toBe("User");
+  });
+
+  it("returns 'User' when empty names", () => {
+    expect(getSenderName({})).toBe("User");
+  });
+});
+
+describe("getReplyContext", () => {
+  it("returns empty for no reply", () => {
+    expect(getReplyContext(undefined, 999)).toBe("");
+  });
+
+  it("includes 'bot' as author when replying to bot itself", () => {
+    const result = getReplyContext({ from: { id: 999 }, text: "hi" }, 999);
+    expect(result).toContain("bot");
+    expect(result).toContain("hi");
+  });
+
+  it("includes author, text, and message_id for reply to others", () => {
+    const result = getReplyContext(
+      { message_id: 42, from: { id: 123, first_name: "Alice" }, text: "original message" },
+      999,
+    );
+    expect(result).toContain("Alice");
+    expect(result).toContain("original message");
+    expect(result).toContain("Replying to");
+    expect(result).toContain("msg_id:42");
+  });
+
+  it("truncates long reply text to 500 chars", () => {
+    const longText = "x".repeat(600);
+    const result = getReplyContext(
+      { from: { id: 123, first_name: "Bob" }, text: longText },
+      999,
+    );
+    expect(result.length).toBeLessThan(600);
+  });
+});
+
+describe("getForwardContext", () => {
+  it("returns empty for non-forwarded messages", () => {
+    expect(getForwardContext({})).toBe("");
+  });
+
+  it("handles forwarded from user", () => {
+    const result = getForwardContext({
+      forward_origin: {
+        type: "user",
+        sender_user: { first_name: "Charlie", last_name: "D" },
+      },
+    });
+    expect(result).toContain("Charlie D");
+    expect(result).toContain("Forwarded");
+  });
+
+  it("handles forwarded from channel", () => {
+    const result = getForwardContext({
+      forward_origin: { type: "channel", chat: { title: "News" } },
+    });
+    expect(result).toContain("News");
+  });
+
+  it("handles hidden user", () => {
+    const result = getForwardContext({
+      forward_origin: { type: "hidden_user", sender_user_name: "anon" },
+    });
+    expect(result).toContain("anon");
+  });
+
+  it("handles chat type forward", () => {
+    const result = getForwardContext({
+      forward_origin: { type: "chat", chat: { title: "Support Group" } },
+    });
+    expect(result).toContain("Support Group");
+  });
+
+  it("handles channel with no title", () => {
+    const result = getForwardContext({
+      forward_origin: { type: "channel", chat: {} },
+    });
+    expect(result).toContain("a chat");
+  });
+
+  it("handles unknown forward type", () => {
+    const result = getForwardContext({
+      forward_origin: { type: "unknown_type" },
+    });
+    expect(result).toContain("someone");
+  });
+});
+
+describe("getReplyContext — edge cases", () => {
+  it("returns empty when reply has no text, caption, media, or message_id", () => {
+    expect(getReplyContext({ from: { id: 123 } }, 999)).toBe("");
+  });
+
+  it("includes message_id and media type even without text", () => {
+    const result = getReplyContext(
+      { message_id: 100, from: { id: 123, first_name: "Dan" }, photo: [{}] as unknown[] },
+      999,
+    );
+    expect(result).toContain("msg_id:100");
+    expect(result).toContain("[photo]");
+    expect(result).toContain("Dan");
+  });
+
+  it("uses caption when text is missing", () => {
+    const result = getReplyContext(
+      { from: { id: 123, first_name: "Eve" }, caption: "photo caption" },
+      999,
+    );
+    expect(result).toContain("photo caption");
+  });
+
+  it("includes full name from first and last", () => {
+    const result = getReplyContext(
+      { from: { id: 123, first_name: "Jane", last_name: "Smith" }, text: "hello" },
+      999,
+    );
+    expect(result).toContain("Jane Smith");
+  });
+});
+
+describe("shouldHandleInGroup — edge cases", () => {
+  const ctx = (overrides: Record<string, unknown> = {}) => ({
+    chat: { type: overrides.type ?? "supergroup" },
+    me: { id: overrides.botId ?? 999, username: overrides.username ?? "testbot" },
+    message: {
+      text: overrides.text ?? "",
+      caption: overrides.caption ?? undefined,
+      reply_to_message: overrides.replyFromId
+        ? { from: { id: overrides.replyFromId } }
+        : undefined,
+    },
+  }) as any;
+
+  it("returns false when no chat", () => {
+    expect(shouldHandleInGroup({ chat: null, message: {} } as any)).toBe(false);
+  });
+
+  it("returns false when no message", () => {
+    expect(shouldHandleInGroup({ chat: { type: "group" }, message: null } as any)).toBe(false);
+  });
+
+  it("detects bot mention in caption", () => {
+    expect(shouldHandleInGroup(ctx({ caption: "look @testbot", text: "" }))).toBe(true);
+  });
+
+  it("handles 'group' type (not just supergroup)", () => {
+    expect(shouldHandleInGroup(ctx({ type: "group", text: "@testbot hi" }))).toBe(true);
+  });
+
+  it("returns false for group with @mention as part of longer username", () => {
+    // @testbot123 should NOT match @testbot (word boundary check)
+    expect(shouldHandleInGroup(ctx({ text: "hey @testbot_extra" }))).toBe(false);
+  });
+});
+
+describe("getSenderName — edge cases", () => {
+  it("returns last name only when no first name", () => {
+    expect(getSenderName({ last_name: "Doe" })).toBe("Doe");
+  });
+
+  it("trims whitespace from names", () => {
+    // filter(Boolean) handles empty strings
+    expect(getSenderName({ first_name: "", last_name: "Smith" })).toBe("Smith");
+  });
+});
+
+const { handleTextMessage, handlePhotoMessage, handleCallbackQuery } = await import(
+  "../frontend/telegram/handlers.js"
+);
+
+describe("handleTextMessage — integration via mock Context", () => {
+
+  const mockBot = {
+    api: {
+      sendMessage: vi.fn(async () => ({ message_id: 1 })),
+      sendChatAction: vi.fn(async () => {}),
+      setMessageReaction: vi.fn(async () => {}),
+      sendMessageDraft: vi.fn(async () => {}),
+    },
+  } as any;
+
+  const mockConfig = {
+    botToken: "test",
+    model: "claude-sonnet-4-6",
+    maxMessageLength: 4000,
+    workspace: "/tmp/test-workspace",
+  } as any;
+
+  it("silently returns when ctx.message is missing", async () => {
+    await handleTextMessage({ chat: { id: 1 } } as any, mockBot, mockConfig);
+    // Should not throw
+  });
+
+  it("silently returns when ctx.chat is missing", async () => {
+    await handleTextMessage({ message: { text: "hi" } } as any, mockBot, mockConfig);
+    // Should not throw
+  });
+
+  it("silently returns for group message without mention", async () => {
+    const ctx = {
+      chat: { id: 1, type: "supergroup" },
+      message: { text: "hello everyone", message_id: 1, reply_to_message: null },
+      me: { id: 999, username: "testbot" },
+      from: { id: 1, first_name: "User" },
+    } as any;
+    await handleTextMessage(ctx, mockBot, mockConfig);
+    // Should not enqueue (no mention or reply to bot)
+  });
+
+  it("silently returns when photo has no photos array", async () => {
+    const ctx = {
+      chat: { id: 1, type: "private" },
+      message: { photo: null, message_id: 1 },
+      me: { id: 999, username: "testbot" },
+      from: { id: 1, first_name: "User" },
+    } as any;
+    await handlePhotoMessage(ctx, mockBot, mockConfig);
+  });
+
+  it("silently returns when callback query has no data", async () => {
+    const ctx = {
+      callbackQuery: { message: { message_id: 1 } },  // no 'data' property
+      chat: { id: 1 },
+      from: { id: 1, first_name: "User" },
+    } as any;
+    await handleCallbackQuery(ctx, mockBot, mockConfig);
+  });
+});
+