talon-agent 1.6.1 → 1.7.0

package/src/__tests__/plugin.test.ts

@@ -1,3 +1,4 @@
+import type { TalonConfig } from "../util/config.js";
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
 vi.mock("../util/log.js", () => ({
@@ -27,6 +28,27 @@ describe("plugin system", () => {
     };
   }
 
+  function createTestConfig(overrides: Partial<TalonConfig> = {}): TalonConfig {
+    return {
+      frontend: "terminal",
+      backend: "claude",
+      model: "default",
+      maxMessageLength: 4000,
+      concurrency: 1,
+      pulse: true,
+      pulseIntervalMs: 300000,
+      heartbeat: false,
+      heartbeatIntervalMinutes: 60,
+      plugins: [],
+      botDisplayName: "Talon",
+      teamsWebhookPort: 19878,
+      teamsGraphPollMs: 10000,
+      systemPrompt: "test prompt",
+      workspace: "/tmp/workspace",
+      ...overrides,
+    };
+  }
+
   /** Import fresh plugin module with fs mocked to find entry + dynamic import returning plugin. */
   async function setup(plugin: ReturnType<typeof createMockPlugin>) {
     vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
@@ -247,6 +269,75 @@ describe("plugin system", () => {
       );
     });
 
+    it("does not let plugin env vars override bridge metadata", async () => {
+      const plugin = createMockPlugin({
+        mcpServer: {
+          command: "/usr/bin/python3",
+          args: ["-m", "my_server"],
+        },
+        getEnvVars: () => ({
+          TALON_BRIDGE_URL: "http://malicious.example",
+          TALON_CHAT_ID: "wrong-chat",
+          MY_KEY: "val",
+        }),
+      });
+      delete (plugin as Record<string, unknown>).mcpServerPath;
+      const { loadPlugins, getPluginMcpServers } = await setup(plugin);
+      await loadPlugins([{ path: "/fake/plugin" }]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      expect(servers["test-plugin-tools"].env).toMatchObject({
+        TALON_BRIDGE_URL: "http://localhost:19876",
+        TALON_CHAT_ID: "chat1",
+        MY_KEY: "val",
+      });
+    });
+
+    it("builds standalone MCP server entries from config", async () => {
+      const { loadPlugins, getPluginMcpServers } =
+        await setup(createMockPlugin());
+      await loadPlugins([
+        {
+          name: "standalone",
+          command: "node",
+          args: ["/tmp/server.js"],
+          env: {
+            API_KEY: "secret",
+            TALON_BRIDGE_URL: "http://malicious.example",
+            TALON_CHAT_ID: "wrong-chat",
+          },
+        },
+      ]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      expect(servers["standalone-tools"]).toEqual({
+        command: "node",
+        args: ["/tmp/server.js"],
+        env: {
+          API_KEY: "secret",
+          TALON_BRIDGE_URL: "http://localhost:19876",
+          TALON_CHAT_ID: "chat1",
+        },
+      });
+    });
+
+    it("skips path plugins that collide with standalone MCP names", async () => {
+      const initFn = vi.fn();
+      const plugin = createMockPlugin({ init: initFn });
+      const { loadPlugins, getPluginCount, getPluginMcpServers } =
+        await setup(plugin);
+      await loadPlugins([
+        { name: "test-plugin", command: "node", args: ["/tmp/server.js"] },
+        { path: "/fake/plugin" },
+      ]);
+
+      expect(getPluginCount()).toBe(0);
+      expect(initFn).not.toHaveBeenCalled();
+      expect(
+        getPluginMcpServers("http://localhost:19876", "chat1"),
+      ).toHaveProperty("test-plugin-tools");
+    });
+
     it("mcpServer takes priority over mcpServerPath when both are set", async () => {
       const plugin = createMockPlugin({
         mcpServerPath: "/fake/tools.ts",
@@ -276,12 +367,42 @@ describe("plugin system", () => {
     });
   });
 
+  describe("reload", () => {
+    it("clears standalone MCP entries on hot reload", async () => {
+      vi.resetModules();
+      vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+      vi.doMock("../util/config.js", () => ({
+        loadConfig: () => ({
+          frontend: "terminal",
+          model: "default",
+          plugins: [],
+          systemPrompt: "test prompt",
+          workspace: "/tmp/workspace",
+        }),
+        getFrontends: () => ["terminal"],
+      }));
+
+      const mod = await import("../core/plugin.js");
+      await mod.loadPlugins([{ name: "standalone", command: "node" }]);
+      expect(
+        mod.getPluginMcpServers("http://localhost:19876", "chat1"),
+      ).toHaveProperty("standalone-tools");
+
+      await mod.reloadPlugins();
+
+      expect(
+        mod.getPluginMcpServers("http://localhost:19876", "chat1"),
+      ).toEqual({});
+    });
+  });
+
   describe("registerPlugin (built-in)", () => {
     it("registers a built-in plugin directly", async () => {
       const plugin = createMockPlugin({ name: "built-in-test" });
       const { registerPlugin, getPlugin } = await setup(createMockPlugin());
 
-      registerPlugin(plugin, { key: "val" });
+      const loaded = registerPlugin(plugin, { key: "val" });
+      expect(loaded?.path).toBe("(built-in)");
       expect(getPlugin("built-in-test")).toBeDefined();
       expect(getPlugin("built-in-test")!.path).toBe("(built-in)");
     });
@@ -306,9 +427,27 @@ describe("plugin system", () => {
       });
       const { registerPlugin, getPlugin } = await setup(createMockPlugin());
 
-      registerPlugin(plugin, {});
+      expect(registerPlugin(plugin, {})).toBeNull();
       expect(getPlugin("builtin-invalid")).toBeUndefined();
     });
+
+    it("does not init a built-in plugin when duplicate registration is skipped", async () => {
+      const init = vi.fn();
+      const githubPlugin = createMockPlugin({ name: "github", init });
+
+      vi.doMock("../plugins/github/index.js", () => ({
+        createGitHubPlugin: () => githubPlugin,
+      }));
+
+      const mod = await import("../core/plugin.js");
+      await mod.loadPlugins([{ name: "github", command: "node" }]);
+      await mod.loadBuiltinPlugins(
+        createTestConfig({ github: { enabled: true } }),
+      );
+
+      expect(init).not.toHaveBeenCalled();
+      expect(mod.getPlugin("github")).toBeUndefined();
+    });
   });
 
   describe("system prompt additions", () => {
@@ -366,6 +505,20 @@ describe("plugin system", () => {
       expect(getPluginCount()).toBe(1);
     });
 
+    it("does not leave an init timeout running for plugins without init", async () => {
+      vi.useFakeTimers();
+      try {
+        const plugin = createMockPlugin();
+        const { loadPlugins } = await setup(plugin);
+
+        await loadPlugins([{ path: "/fake/plugin" }]);
+
+        expect(vi.getTimerCount()).toBe(0);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
     it("catches destroy errors without crashing", async () => {
       const plugin = createMockPlugin({
         destroy: () => {

package/src/__tests__/telegram-helpers.test.ts

@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { clearModels, registerModels } from "../core/models.js";
+import {
+  formatCompactModelLabel,
+  formatModelLabel,
+  formatModelOptionLabel,
+  getTelegramModelOptions,
+  isSelectedModel,
+  renderSettingsKeyboard,
+} from "../frontend/telegram/helpers.js";
+
+describe("telegram helpers", () => {
+  beforeEach(() => {
+    clearModels();
+    registerModels([
+      {
+        id: "default",
+        displayName: "Default (recommended)",
+        description: "Sonnet 4.6 · Best for everyday tasks",
+        aliases: ["sonnet", "claude-sonnet-4-6"],
+        provider: "anthropic",
+        capabilities: {
+          supports1mContext: true,
+          oneMillionContextModelId: "sonnet[1m]",
+        },
+        tier: "balanced",
+        fallback: "haiku",
+      },
+      {
+        id: "sonnet[1m]",
+        displayName: "Sonnet (1M context)",
+        description:
+          "Sonnet 4.6 with 1M context · Billed as extra usage · $3/$15 per Mtok",
+        aliases: ["claude-sonnet-4-6[1m]"],
+        provider: "anthropic",
+        capabilities: { supports1mContext: true },
+        tier: "balanced",
+        fallback: "haiku",
+      },
+      {
+        id: "opus",
+        displayName: "Opus",
+        description: "Opus 4.6 · Most capable for complex work",
+        aliases: ["claude-opus-4-6"],
+        provider: "anthropic",
+        capabilities: {
+          supports1mContext: true,
+          oneMillionContextModelId: "opus[1m]",
+        },
+        tier: "premium",
+        fallback: "default",
+      },
+      {
+        id: "opus[1m]",
+        displayName: "Opus (1M context)",
+        description:
+          "Opus 4.6 with 1M context · Billed as extra usage · $5/$25 per Mtok",
+        aliases: ["claude-opus-4-6[1m]"],
+        provider: "anthropic",
+        capabilities: { supports1mContext: true },
+        tier: "premium",
+        fallback: "default",
+      },
+      {
+        id: "haiku",
+        displayName: "Haiku",
+        description: "Haiku 4.5 · Fastest for quick answers",
+        aliases: ["claude-haiku-4-5"],
+        provider: "anthropic",
+        capabilities: { supports1mContext: false },
+        tier: "economy",
+      },
+    ]);
+  });
+
+  it("matches legacy aliases to the canonical selected model", () => {
+    expect(isSelectedModel("claude-sonnet-4-6", "default")).toBe(true);
+    expect(isSelectedModel("sonnet[1m]", "default")).toBe(true);
+    expect(isSelectedModel("claude-sonnet-4-6", "haiku")).toBe(false);
+  });
+
+  it("formats clean model labels for telegram users", () => {
+    expect(formatModelLabel("default")).toBe("Sonnet 4.6");
+    expect(formatModelLabel("claude-sonnet-4-6")).toBe("Sonnet 4.6");
+    expect(formatModelLabel("sonnet[1m]")).toBe("Sonnet 4.6");
+    expect(formatModelOptionLabel(getTelegramModelOptions()[0]!)).toBe(
+      "Opus 4.6",
+    );
+    expect(formatCompactModelLabel(getTelegramModelOptions()[1]!)).toBe(
+      "Sonnet",
+    );
+  });
+
+  it("shows a single clean option per model family", () => {
+    expect(getTelegramModelOptions().map((model) => model.id)).toEqual([
+      "opus",
+      "default",
+      "haiku",
+    ]);
+  });
+
+  it("marks the canonical model button as selected for legacy aliases", () => {
+    const buttons = renderSettingsKeyboard(
+      "claude-sonnet-4-6",
+      "adaptive",
+      true,
+    )
+      .flat()
+      .map((button) => button.text);
+
+    expect(buttons).toContain("\u2713 Sonnet");
+  });
+});