talon-agent 1.3.0 → 1.5.0

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

@@ -125,9 +125,6 @@ describe("gateway shared actions", () => {
     originalFetch = globalThis.fetch;
     originalEnv = { ...process.env };
     vi.clearAllMocks();
-    // Reset env vars used by web_search
-    delete process.env.TALON_BRAVE_API_KEY;
-    delete process.env.TALON_SEARXNG_URL;
   });
 
   afterEach(() => {
@@ -276,377 +273,6 @@ describe("gateway shared actions", () => {
     });
   });
 
-  // ════════════════════════════════════════════════════════════════════════
-  // web_search
-  // ════════════════════════════════════════════════════════════════════════
-
-  describe("web_search", () => {
-    it("returns error for missing query", async () => {
-      const result = await handleSharedAction({ action: "web_search" }, 123);
-      expect(result).toEqual({ ok: false, error: "Missing query" });
-    });
-
-    it("returns error for empty query string", async () => {
-      const result = await handleSharedAction(
-        { action: "web_search", query: "" },
-        123,
-      );
-      expect(result).toEqual({ ok: false, error: "Missing query" });
-    });
-
-    it("uses Brave API when key is configured", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-brave-key";
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          contentType: "application/json",
-          json: {
-            web: {
-              results: [
-                {
-                  title: "Result 1",
-                  url: "https://example.com/1",
-                  description: "Description 1",
-                },
-                {
-                  title: "Result 2",
-                  url: "https://example.com/2",
-                  description: "Description 2",
-                },
-              ],
-            },
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "test query" },
-        123,
-      );
-
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toContain("via Brave");
-      expect(result?.text).toContain("Result 1");
-      expect(result?.text).toContain("https://example.com/1");
-      expect(result?.text).toContain("Description 1");
-      expect(result?.text).toContain("Result 2");
-
-      // Verify Brave API was called correctly
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const [url, opts] = mockFetch.mock.calls[0];
-      expect(url).toContain("api.search.brave.com");
-      expect(url).toContain("q=test%20query");
-      expect(url).toContain("count=5");
-      expect(opts.headers["X-Subscription-Token"]).toBe("test-brave-key");
-    });
-
-    it("respects custom limit for Brave API", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-brave-key";
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          json: {
-            web: {
-              results: [{ title: "R", url: "https://r.com", description: "d" }],
-            },
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      await handleSharedAction(
-        { action: "web_search", query: "test", limit: 8 },
-        123,
-      );
-      const [url] = mockFetch.mock.calls[0];
-      expect(url).toContain("count=8");
-    });
-
-    it("clamps search limit to 10", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-brave-key";
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          json: {
-            web: {
-              results: [{ title: "R", url: "https://r.com", description: "d" }],
-            },
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      await handleSharedAction(
-        { action: "web_search", query: "test", limit: 50 },
-        123,
-      );
-      const [url] = mockFetch.mock.calls[0];
-      expect(url).toContain("count=10");
-    });
-
-    it("falls back to SearXNG when Brave returns non-ok", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-brave-key";
-      const mockFetch = vi
-        .fn()
-        .mockResolvedValueOnce(mockResponse({ ok: false, status: 429 })) // Brave fails
-        .mockResolvedValueOnce(
-          mockResponse({
-            ok: true,
-            json: {
-              results: [
-                {
-                  title: "SearX Result",
-                  url: "https://searx.example.com",
-                  content: "SearX snippet",
-                },
-              ],
-            },
-          }),
-        );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "fallback test" },
-        123,
-      );
-
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toContain("via SearXNG");
-      expect(result?.text).toContain("SearX Result");
-    });
-
-    it("falls back to SearXNG when Brave throws an error", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-brave-key";
-      const mockFetch = vi
-        .fn()
-        .mockRejectedValueOnce(new Error("network error")) // Brave throws
-        .mockResolvedValueOnce(
-          mockResponse({
-            ok: true,
-            json: {
-              results: [
-                {
-                  title: "Fallback",
-                  url: "https://fb.com",
-                  content: "snippet",
-                },
-              ],
-            },
-          }),
-        );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "test" },
-        123,
-      );
-
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toContain("via SearXNG");
-    });
-
-    it("uses SearXNG directly when no Brave key", async () => {
-      // No TALON_BRAVE_API_KEY set
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          json: {
-            results: [
-              {
-                title: "Direct SearX",
-                url: "https://searx.com/r",
-                content: "content here",
-              },
-            ],
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "direct" },
-        123,
-      );
-
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const [url] = mockFetch.mock.calls[0];
-      expect(url).toContain("localhost:8080");
-      expect(url).toContain("format=json");
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toContain("via SearXNG");
-    });
-
-    it("uses custom SearXNG URL from env", async () => {
-      process.env.TALON_SEARXNG_URL = "http://my-searx:9090";
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          json: {
-            results: [{ title: "T", url: "https://t.com", content: "c" }],
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      await handleSharedAction({ action: "web_search", query: "custom" }, 123);
-
-      const [url] = mockFetch.mock.calls[0];
-      expect(url).toContain("my-searx:9090");
-    });
-
-    it("returns 'no results' when both providers fail", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-key";
-      const mockFetch = vi
-        .fn()
-        .mockRejectedValueOnce(new Error("brave fail"))
-        .mockRejectedValueOnce(new Error("searx fail"));
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "nothing" },
-        123,
-      );
-
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toBe('No results for "nothing".');
-    });
-
-    it("returns 'no results' when both return non-ok", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-key";
-      const mockFetch = vi
-        .fn()
-        .mockResolvedValueOnce(mockResponse({ ok: false, status: 500 }))
-        .mockResolvedValueOnce(mockResponse({ ok: false, status: 503 }));
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "failing" },
-        123,
-      );
-
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toBe('No results for "failing".');
-    });
-
-    it("returns 'no results' when Brave returns empty results array", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-key";
-      const mockFetch = vi
-        .fn()
-        .mockResolvedValueOnce(
-          mockResponse({ ok: true, json: { web: { results: [] } } }),
-        )
-        .mockResolvedValueOnce(
-          mockResponse({ ok: true, json: { results: [] } }),
-        );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "empty" },
-        123,
-      );
-
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toBe('No results for "empty".');
-    });
-
-    it("handles Brave response with missing web field", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-key";
-      const mockFetch = vi
-        .fn()
-        .mockResolvedValueOnce(mockResponse({ ok: true, json: {} })) // no web field
-        .mockResolvedValueOnce(
-          mockResponse({
-            ok: true,
-            json: {
-              results: [
-                { title: "FallbackR", url: "https://f.com", content: "fb" },
-              ],
-            },
-          }),
-        );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "test" },
-        123,
-      );
-      expect(result?.text).toContain("via SearXNG");
-    });
-
-    it("truncates long snippets to 200 chars", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-key";
-      const longDesc = "A".repeat(500);
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          json: {
-            web: {
-              results: [
-                { title: "Long", url: "https://l.com", description: longDesc },
-              ],
-            },
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "long" },
-        123,
-      );
-      // The snippet should be sliced to 200 chars
-      expect(result?.text).not.toContain("A".repeat(201));
-      expect(result?.text).toContain("A".repeat(200));
-    });
-
-    it("handles missing description in Brave results", async () => {
-      process.env.TALON_BRAVE_API_KEY = "test-key";
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          json: {
-            web: { results: [{ title: "NoDesc", url: "https://nd.com" }] },
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "nodesc" },
-        123,
-      );
-      expect(result?.ok).toBe(true);
-      expect(result?.text).toContain("NoDesc");
-    });
-
-    it("slices SearXNG results to limit", async () => {
-      const mockFetch = vi.fn().mockResolvedValueOnce(
-        mockResponse({
-          ok: true,
-          json: {
-            results: Array.from({ length: 20 }, (_, i) => ({
-              title: `R${i}`,
-              url: `https://r${i}.com`,
-              content: `c${i}`,
-            })),
-          },
-        }),
-      );
-      vi.stubGlobal("fetch", mockFetch);
-
-      const result = await handleSharedAction(
-        { action: "web_search", query: "many", limit: 3 },
-        123,
-      );
-      // Should only contain 3 results (numbered 1-3)
-      expect(result?.text).toContain("1. R0");
-      expect(result?.text).toContain("3. R2");
-      expect(result?.text).not.toContain("4. R3");
-    });
-  });
-
   // ════════════════════════════════════════════════════════════════════════
   // fetch_url
   // ════════════════════════════════════════════════════════════════════════
@@ -2082,14 +1708,13 @@ describe("gateway shared actions", () => {
   });
 });
 
-// ── Additional branch coverage for fetch_url and web_search ──────────────
+// ── Additional branch coverage for fetch_url ──────────────────────────────
 
 describe("gateway-actions — additional branch coverage", () => {
   let originalFetch: typeof globalThis.fetch;
 
   beforeEach(() => {
     originalFetch = globalThis.fetch;
-    delete process.env.TALON_BRAVE_API_KEY;
   });
 
   afterEach(() => {
@@ -2144,51 +1769,4 @@ describe("gateway-actions — additional branch coverage", () => {
     // Should succeed (downloaded as bin), covering ct ?? "" right side and ct.split("/")[1] ?? "file" right side
     expect(result?.ok).toBe(true);
   });
-
-  it("handles search result with missing content field (line 113 r.content ?? '' branch)", async () => {
-    const mockFetch = vi.fn().mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers(),
-      json: async () => ({
-        results: [
-          { title: "Result", url: "https://example.com", content: undefined },
-        ],
-      }),
-      text: async () => "",
-      arrayBuffer: async () => new ArrayBuffer(0),
-    } as unknown as Response);
-    vi.stubGlobal("fetch", mockFetch);
-    process.env.TALON_SEARXNG_URL = "http://localhost:8080";
-
-    const result = await handleSharedAction(
-      { action: "web_search", query: "test" },
-      123,
-    );
-    expect(result?.ok).toBe(true);
-    // snippet should be "" (from ?? "")
-    expect(result?.text).toBeDefined();
-  });
-
-  it("handles search response with no results array (line 113 data.results ?? [] branch)", async () => {
-    const mockFetch = vi.fn().mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      headers: new Headers(),
-      json: async () => ({
-        /* no results property */
-      }),
-      text: async () => "",
-      arrayBuffer: async () => new ArrayBuffer(0),
-    } as unknown as Response);
-    vi.stubGlobal("fetch", mockFetch);
-    process.env.TALON_SEARXNG_URL = "http://localhost:8080";
-
-    const result = await handleSharedAction(
-      { action: "web_search", query: "empty" },
-      123,
-    );
-    expect(result?.ok).toBe(true);
-    expect(result?.text).toContain("No results for");
-  });
 });

package/src/__tests__/heartbeat.test.ts

@@ -48,6 +48,10 @@ vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
   query: queryMock,
 }));
 
+vi.mock("../core/plugin.js", () => ({
+  getPluginMcpServers: vi.fn(() => ({})),
+}));
+
 vi.mock("../util/paths.js", () => ({
   files: {
     heartbeatState: "/fake/.talon/workspace/memory/heartbeat_state.json",
@@ -184,6 +188,23 @@ describe("forceHeartbeat", () => {
     expect(finalState.status).toBe("idle");
   });
 
+  it("passes plugin MCP servers to the agent via getPluginMcpServers", async () => {
+    const { getPluginMcpServers } = await import("../core/plugin.js");
+    const mockServers = {
+      "email-tools": { command: "node", args: ["email.js"], env: {} },
+    };
+    vi.mocked(getPluginMcpServers).mockReturnValue(mockServers);
+
+    await forceHeartbeat();
+
+    expect(getPluginMcpServers).toHaveBeenCalledWith("", "heartbeat");
+    // Verify mcpServers was passed through to query()
+    const queryCall = queryMock.mock.calls[0] as unknown as [
+      { options: { mcpServers: Record<string, unknown> } },
+    ];
+    expect(queryCall[0].options.mcpServers).toEqual(mockServers);
+  });
+
   it("preserves previous last_run on failure", async () => {
     const previousLastRun = Date.now() - 3600_000;
     existsSyncMock.mockReturnValue(true);

package/src/__tests__/reload-plugins.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ── Module mocks ──────────────────────────────────────────────────────────
+
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+  logDebug: vi.fn(),
+}));
+
+vi.mock("write-file-atomic", () => ({
+  default: { sync: vi.fn() },
+}));
+
+// Mock cheerio (required by gateway-actions via extractText)
+vi.mock("cheerio", () => ({
+  load: vi.fn(() => {
+    const $ = (sel: string) => ({
+      remove: vi.fn(),
+      text: () => "",
+    });
+    ($ as any).root = vi.fn();
+    return $;
+  }),
+}));
+
+// Mock storage modules required by gateway-actions
+vi.mock("../storage/history.js", () => ({
+  getRecentFormatted: vi.fn(() => ""),
+  searchHistory: vi.fn(() => ""),
+  getMessagesByUser: vi.fn(() => ""),
+  getKnownUsers: vi.fn(() => ""),
+}));
+vi.mock("../storage/media-index.js", () => ({
+  formatMediaIndex: vi.fn(() => ""),
+}));
+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 })),
+  generateCronId: vi.fn(() => "test-id"),
+}));
+
+// ── Plugin mocking ──────────────────────────────────────────────────────
+
+const DEFAULT_CONFIG = {
+  model: "claude-opus-4-6",
+  frontend: "telegram",
+  plugins: [],
+  systemPrompt: "test prompt",
+};
+
+const mockReloadPlugins = vi.fn(async () => ({
+  names: ["extras", "brave-search"],
+  config: { ...DEFAULT_CONFIG },
+}));
+const mockGetPluginPromptAdditions = vi.fn(() => "prompt additions");
+const mockRebuildSystemPrompt = vi.fn();
+const mockUpdateSystemPrompt = vi.fn();
+
+vi.mock("../core/plugin.js", () => ({
+  reloadPlugins: (...args: unknown[]) =>
+    mockReloadPlugins(...(args as Parameters<typeof mockReloadPlugins>)),
+  getPluginPromptAdditions: () => mockGetPluginPromptAdditions(),
+}));
+
+vi.mock("../util/config.js", () => ({
+  rebuildSystemPrompt: (...args: unknown[]) =>
+    mockRebuildSystemPrompt(
+      ...(args as Parameters<typeof mockRebuildSystemPrompt>),
+    ),
+}));
+
+vi.mock("../backend/claude-sdk/index.js", () => ({
+  updateSystemPrompt: (...args: unknown[]) =>
+    mockUpdateSystemPrompt(
+      ...(args as Parameters<typeof mockUpdateSystemPrompt>),
+    ),
+}));
+
+// ── Import after mocks ────────────────────────────────────────────────────
+
+import { handleSharedAction } from "../core/gateway-actions.js";
+
+// ── Tests ─────────────────────────────────────────────────────────────────
+
+describe("reload_plugins gateway action", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    // Re-establish default implementations after reset
+    mockReloadPlugins.mockImplementation(async () => ({
+      names: ["extras", "brave-search"],
+      config: { ...DEFAULT_CONFIG },
+    }));
+    mockGetPluginPromptAdditions.mockReturnValue("prompt additions");
+    mockRebuildSystemPrompt.mockImplementation(() => {});
+    mockUpdateSystemPrompt.mockImplementation(() => {});
+  });
+
+  it("returns loaded plugin names on success", async () => {
+    const result = await handleSharedAction(
+      { action: "reload_plugins" },
+      12345,
+    );
+    expect(result).not.toBeNull();
+    expect(result!.ok).toBe(true);
+    expect(result!.text).toContain("Plugins reloaded successfully");
+    expect(result!.text).toContain("extras");
+    expect(result!.text).toContain("brave-search");
+    expect(result!.text).toContain("(2)");
+  });
+
+  it("calls reloadPlugins without explicit frontends (derived from config)", async () => {
+    await handleSharedAction({ action: "reload_plugins" }, 12345);
+    // Gateway no longer passes frontends — reloadPlugins derives them from config
+    expect(mockReloadPlugins).toHaveBeenCalledWith();
+  });
+
+  it("rebuilds system prompt after reloading", async () => {
+    await handleSharedAction({ action: "reload_plugins" }, 12345);
+    expect(mockRebuildSystemPrompt).toHaveBeenCalledTimes(1);
+    expect(mockGetPluginPromptAdditions).toHaveBeenCalledTimes(1);
+  });
+
+  it("updates backend system prompt after rebuild", async () => {
+    await handleSharedAction({ action: "reload_plugins" }, 12345);
+    expect(mockUpdateSystemPrompt).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns error when reloadPlugins throws", async () => {
+    mockReloadPlugins.mockRejectedValueOnce(
+      new Error("Config validation failed"),
+    );
+    const result = await handleSharedAction(
+      { action: "reload_plugins" },
+      12345,
+    );
+    expect(result).not.toBeNull();
+    expect(result!.ok).toBe(false);
+    expect(result!.error).toContain("Config validation failed");
+  });
+
+  it("returns error when config is malformed", async () => {
+    mockReloadPlugins.mockRejectedValueOnce(
+      new Error("Invalid JSON in config"),
+    );
+    const result = await handleSharedAction(
+      { action: "reload_plugins" },
+      12345,
+    );
+    expect(result!.ok).toBe(false);
+    expect(result!.error).toContain("Invalid JSON in config");
+  });
+
+  it("reports zero plugins when none configured", async () => {
+    mockReloadPlugins.mockImplementation(async () => ({
+      names: [],
+      config: { ...DEFAULT_CONFIG },
+    }));
+    const result = await handleSharedAction(
+      { action: "reload_plugins" },
+      12345,
+    );
+    expect(result!.ok).toBe(true);
+    expect(result!.text).toContain("(0)");
+    expect(result!.text).toContain("(none)");
+  });
+});
+
+// ── Admin tool description tests ──────────────────────────────────────────
+
+describe("admin tool description", () => {
+  it("does not mention session reset or MCP subprocesses", async () => {
+    const { adminTools } = await import("../core/tools/admin.js");
+    const reloadTool = adminTools.find((t) => t.name === "reload_plugins");
+    expect(reloadTool).toBeDefined();
+    expect(reloadTool!.description).not.toContain("resets sessions");
+    expect(reloadTool!.description).not.toContain("sessions reset");
+    expect(reloadTool!.description).not.toContain("MCP subprocesses");
+    expect(reloadTool!.description).toContain("without restarting");
+    expect(reloadTool!.description).toContain("without downtime");
+  });
+
+  it("mentions env var cleanup", async () => {
+    const { adminTools } = await import("../core/tools/admin.js");
+    const reloadTool = adminTools.find((t) => t.name === "reload_plugins");
+    expect(reloadTool!.description).toContain("env vars");
+  });
+
+  it("has admin tag", async () => {
+    const { adminTools } = await import("../core/tools/admin.js");
+    const reloadTool = adminTools.find((t) => t.name === "reload_plugins");
+    expect(reloadTool!.tag).toBe("admin");
+  });
+});