talon-agent 1.3.0 → 1.4.0

package/src/bootstrap.ts

@@ -58,13 +58,12 @@ export async function bootstrap(
 ): Promise<BootstrapResult> {
   const config = loadConfig();
 
-  // Expose search config as env vars for gateway-actions
-  if (config.braveApiKey) process.env.TALON_BRAVE_API_KEY = config.braveApiKey;
-  if (config.searxngUrl) process.env.TALON_SEARXNG_URL = config.searxngUrl;
-
-  // Load plugins (external tool packages + built-in mempalace)
+  // Load plugins (external tool packages + built-in GitHub, MemPalace, Playwright)
   const hasPlugins =
-    config.plugins.length > 0 || config.mempalace?.enabled === true;
+    config.plugins.length > 0 ||
+    config.github?.enabled === true ||
+    config.mempalace?.enabled === true ||
+    config.playwright?.enabled === true;
   if (hasPlugins) {
     const { loadPlugins, getPluginPromptAdditions, registerPlugin } =
       await import("./core/plugin.js");
@@ -77,6 +76,35 @@ export async function bootstrap(
       await loadPlugins(config.plugins, frontends);
     }
 
+    // Built-in: GitHub
+    if (config.github?.enabled) {
+      const { createGitHubPlugin } = await import("./plugins/github/index.js");
+      const { getPlugin } = await import("./core/plugin.js");
+      const githubConfig = config.github as unknown as Record<string, unknown>;
+      const gh = createGitHubPlugin({ token: config.github.token });
+      registerPlugin(gh, githubConfig);
+
+      if (getPlugin("github")) {
+        try {
+          const GITHUB_INIT_TIMEOUT_MS = 15_000;
+          await Promise.race([
+            gh.init?.(githubConfig),
+            new Promise((_, reject) =>
+              setTimeout(
+                () => reject(new Error("GitHub init timed out after 15s")),
+                GITHUB_INIT_TIMEOUT_MS,
+              ),
+            ),
+          ]);
+        } catch (err) {
+          log(
+            "github",
+            `Init warning: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+      }
+    }
+
     // Built-in: MemPalace
     if (config.mempalace?.enabled) {
       const { createMempalacePlugin } =
@@ -115,6 +143,42 @@ export async function bootstrap(
       }
     }
 
+    // Built-in: Playwright
+    if (config.playwright?.enabled) {
+      const { createPlaywrightPlugin } =
+        await import("./plugins/playwright/index.js");
+      const { getPlugin } = await import("./core/plugin.js");
+      const playwrightConfig = config.playwright as unknown as Record<
+        string,
+        unknown
+      >;
+      const pw = createPlaywrightPlugin({
+        browser: config.playwright.browser,
+        headless: config.playwright.headless,
+      });
+      registerPlugin(pw, playwrightConfig);
+
+      if (getPlugin("playwright")) {
+        try {
+          const PW_INIT_TIMEOUT_MS = 15_000;
+          await Promise.race([
+            pw.init?.(playwrightConfig),
+            new Promise((_, reject) =>
+              setTimeout(
+                () => reject(new Error("Playwright init timed out after 15s")),
+                PW_INIT_TIMEOUT_MS,
+              ),
+            ),
+          ]);
+        } catch (err) {
+          log(
+            "playwright",
+            `Init warning: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+      }
+    }
+
     rebuildSystemPrompt(config, getPluginPromptAdditions());
   }
 

package/src/core/gateway-actions.ts

@@ -87,93 +87,6 @@ export async function handleSharedAction(
         ),
       };
 
-    // ── Web search (SearXNG) ────────────────────────────────────────────
-
-    case "web_search": {
-      const query = String(body.query ?? "");
-      if (!query) return { ok: false, error: "Missing query" };
-      const limit = Math.min(10, Number(body.limit ?? 5));
-
-      // Try Brave first (if API key configured), fall back to SearXNG
-      const braveKey = process.env.TALON_BRAVE_API_KEY;
-      const searxUrl = process.env.TALON_SEARXNG_URL || "http://localhost:8080";
-
-      type SearchResult = { title: string; url: string; snippet: string };
-      let results: SearchResult[] = [];
-      let provider = "";
-
-      // Brave Search API
-      if (braveKey) {
-        try {
-          const resp = await fetch(
-            `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${limit}`,
-            {
-              signal: AbortSignal.timeout(8_000),
-              headers: {
-                "X-Subscription-Token": braveKey,
-                Accept: "application/json",
-              },
-            },
-          );
-          if (resp.ok) {
-            const data = (await resp.json()) as {
-              web?: {
-                results?: Array<{
-                  title: string;
-                  url: string;
-                  description: string;
-                }>;
-              };
-            };
-            results = (data.web?.results ?? []).map((r) => ({
-              title: r.title,
-              url: r.url,
-              snippet: r.description ?? "",
-            }));
-            provider = "Brave";
-          }
-        } catch {
-          /* fall through to SearXNG */
-        }
-      }
-
-      // SearXNG fallback
-      if (results.length === 0) {
-        try {
-          const resp = await fetch(
-            `${searxUrl}/search?q=${encodeURIComponent(query)}&format=json`,
-            { signal: AbortSignal.timeout(10_000) },
-          );
-          if (resp.ok) {
-            const data = (await resp.json()) as {
-              results?: Array<{ title: string; url: string; content: string }>;
-            };
-            results = (data.results ?? []).slice(0, limit).map((r) => ({
-              title: r.title,
-              url: r.url,
-              snippet: r.content ?? "",
-            }));
-            provider = "SearXNG";
-          }
-        } catch {
-          /* both failed */
-        }
-      }
-
-      if (results.length === 0)
-        return { ok: true, text: `No results for "${query}".` };
-      const formatted = results
-        .map(
-          (r, i) =>
-            `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet.slice(0, 200)}`,
-        )
-        .join("\n\n");
-      return {
-        ok: true,
-        text: `Search results for "${query}" (via ${provider}):\n\n${formatted}`,
-      };
-    }
-
     // ── Web fetch ────────────────────────────────────────────────────────
 
     case "fetch_url": {

package/src/core/tools/bridge.ts

@@ -0,0 +1,40 @@
+/**
+ * Bridge utilities — shared by the unified MCP server.
+ *
+ * Extracted from the old per-backend tools.ts files so there's
+ * exactly one copy of callBridge / textResult.
+ */
+
+import type { BridgeFunction } from "./types.js";
+
+/** Create a bridge caller bound to a specific URL and chat. */
+export function createBridge(
+  bridgeUrl: string,
+  chatId: string,
+): BridgeFunction {
+  return async (action, params) => {
+    const resp = await fetch(`${bridgeUrl}/action`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ action, ...params, _chatId: chatId }),
+      signal: AbortSignal.timeout(120_000),
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`Bridge error (${resp.status}): ${text}`);
+    }
+    return resp.json();
+  };
+}
+
+/** Wrap a bridge result into the MCP content format. */
+export function textResult(result: unknown): {
+  content: Array<{ type: "text"; text: string }>;
+} {
+  const r = result as { text?: string; error?: string };
+  return {
+    content: [
+      { type: "text" as const, text: r.text ?? JSON.stringify(result) },
+    ],
+  };
+}

package/src/core/tools/chat.ts

@@ -0,0 +1,52 @@
+/**
+ * Chat info tools — metadata, admins, settings.
+ */
+
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+
+export const chatTools: ToolDefinition[] = [
+  {
+    name: "get_chat_info",
+    description: "Get chat title, type, member count.",
+    schema: {},
+    execute: (_params, bridge) => bridge("get_chat_info", {}),
+    tag: "chat",
+  },
+
+  {
+    name: "get_chat_admins",
+    description: "List chat administrators.",
+    schema: {},
+    execute: (_params, bridge) => bridge("get_chat_admins", {}),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+
+  {
+    name: "get_chat_member_count",
+    description: "Get total member count.",
+    schema: {},
+    execute: (_params, bridge) => bridge("get_chat_member_count", {}),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+
+  {
+    name: "set_chat_title",
+    description: "Change chat title (admin).",
+    schema: { title: z.string() },
+    execute: (params, bridge) => bridge("set_chat_title", params),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+
+  {
+    name: "set_chat_description",
+    description: "Change chat description (admin).",
+    schema: { description: z.string() },
+    execute: (params, bridge) => bridge("set_chat_description", params),
+    frontends: ["telegram"],
+    tag: "chat",
+  },
+];

package/src/core/tools/history.ts

@@ -0,0 +1,80 @@
+/**
+ * Chat history tools — read, search, get messages, download media.
+ */
+
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+
+export const historyTools: ToolDefinition[] = [
+  {
+    name: "read_chat_history",
+    description:
+      "Read messages from the chat. Use 'before' to go back in time (e.g. '2026-03-13').",
+    schema: {
+      limit: z
+        .number()
+        .optional()
+        .describe("Number of messages (default 30, max 100)"),
+      before: z
+        .string()
+        .optional()
+        .describe("Fetch messages before this date (ISO format)"),
+      offset_id: z.number().optional().describe("Fetch before this message ID"),
+    },
+    execute: (params, bridge) =>
+      bridge("read_history", {
+        limit: params.limit ?? 30,
+        before: params.before,
+        offset_id: params.offset_id,
+      }),
+    frontends: ["telegram"],
+    tag: "history",
+  },
+
+  {
+    name: "search_chat_history",
+    description: "Search messages by keyword.",
+    schema: {
+      query: z.string(),
+      limit: z.number().optional(),
+    },
+    execute: (params, bridge) => bridge("search_history", params),
+    frontends: ["telegram"],
+    tag: "history",
+  },
+
+  {
+    name: "get_user_messages",
+    description: "Get messages from a specific user.",
+    schema: {
+      user_name: z.string(),
+      limit: z.number().optional(),
+    },
+    execute: (params, bridge) => bridge("get_user_messages", params),
+    frontends: ["telegram"],
+    tag: "history",
+  },
+
+  {
+    name: "get_message_by_id",
+    description: "Get a specific message by ID.",
+    schema: { message_id: z.number() },
+    execute: (params, bridge) => bridge("get_message_by_id", params),
+    frontends: ["telegram"],
+    tag: "history",
+  },
+
+  {
+    name: "download_media",
+    description:
+      "Download a photo, document, or other media from a message by its ID. Saves the file to the workspace and returns the file path so you can read/analyze it. Use this when you see a [photo] or [document] in chat history but don't have the file.",
+    schema: {
+      message_id: z
+        .number()
+        .describe("Message ID containing the media to download"),
+    },
+    execute: (params, bridge) => bridge("download_media", params),
+    frontends: ["telegram"],
+    tag: "history",
+  },
+];

package/src/core/tools/index.ts

@@ -0,0 +1,82 @@
+/**
+ * Tool registry — compose filtered tool sets at runtime.
+ *
+ * Import domain modules, expose a single composeTools() API
+ * that backends and the MCP server use to get the right tool set.
+ */
+
+import type { ToolDefinition, ToolFrontend, ToolTag } from "./types.js";
+
+import { messagingTools } from "./messaging.js";
+import { chatTools } from "./chat.js";
+import { historyTools } from "./history.js";
+import { memberTools } from "./members.js";
+import { mediaTools } from "./media.js";
+import { stickerTools } from "./stickers.js";
+import { schedulingTools } from "./scheduling.js";
+import { webTools } from "./web.js";
+
+/** All built-in tool definitions. */
+export const ALL_TOOLS: readonly ToolDefinition[] = [
+  ...messagingTools,
+  ...chatTools,
+  ...historyTools,
+  ...memberTools,
+  ...mediaTools,
+  ...stickerTools,
+  ...schedulingTools,
+  ...webTools,
+];
+
+/** Filter options for composing a tool set. */
+export interface ComposeOptions {
+  /** Include only tools available on this frontend. */
+  frontend?: ToolFrontend;
+  /** Include only tools with these tags. */
+  tags?: ToolTag[];
+  /** Exclude tools with these tags. */
+  excludeTags?: ToolTag[];
+  /** Exclude specific tools by name. */
+  excludeNames?: string[];
+}
+
+/**
+ * Compose a filtered set of tools at runtime.
+ *
+ * When no options are provided, returns ALL_TOOLS unchanged.
+ * Callers describe what they need and get back matching definitions.
+ */
+export function composeTools(options: ComposeOptions = {}): ToolDefinition[] {
+  let tools = [...ALL_TOOLS];
+
+  if (options.frontend) {
+    tools = tools.filter(
+      (t) =>
+        !t.frontends ||
+        t.frontends.includes("all") ||
+        t.frontends.includes(options.frontend!),
+    );
+  }
+
+  if (options.tags?.length) {
+    tools = tools.filter((t) => options.tags!.includes(t.tag));
+  }
+
+  if (options.excludeTags?.length) {
+    tools = tools.filter((t) => !options.excludeTags!.includes(t.tag));
+  }
+
+  if (options.excludeNames?.length) {
+    tools = tools.filter((t) => !options.excludeNames!.includes(t.name));
+  }
+
+  return tools;
+}
+
+// Re-export types for convenience
+export type {
+  ToolDefinition,
+  ToolFrontend,
+  ToolTag,
+  BridgeFunction,
+} from "./types.js";

package/src/core/tools/mcp-server.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * Unified MCP server — replaces per-backend tools.ts files.
+ *
+ * Reads TALON_FRONTEND env var to compose the right tool set,
+ * then registers them all on a single MCP server over stdio.
+ *
+ * Environment:
+ *   TALON_BRIDGE_URL  — HTTP bridge URL (default: http://127.0.0.1:19876)
+ *   TALON_CHAT_ID     — Current chat ID
+ *   TALON_FRONTEND    — Frontend type: "telegram" | "teams" | "terminal" (default: "telegram")
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { composeTools } from "./index.js";
+import { createBridge, textResult } from "./bridge.js";
+import type { ToolFrontend } from "./types.js";
+
+const VALID_FRONTENDS = new Set<ToolFrontend>([
+  "telegram",
+  "teams",
+  "terminal",
+]);
+const BRIDGE_URL = process.env.TALON_BRIDGE_URL || "http://127.0.0.1:19876";
+const CHAT_ID = process.env.TALON_CHAT_ID || "";
+const rawFrontend = (process.env.TALON_FRONTEND || "telegram") as ToolFrontend;
+
+if (!CHAT_ID) {
+  console.warn(
+    "TALON_CHAT_ID is not set — bridge calls will fail without a valid chat context.",
+  );
+}
+
+if (!VALID_FRONTENDS.has(rawFrontend)) {
+  console.error(
+    `Invalid TALON_FRONTEND: "${rawFrontend}". Must be one of: ${[...VALID_FRONTENDS].join(", ")}`,
+  );
+  process.exit(1);
+}
+const FRONTEND = rawFrontend;
+
+const bridge = createBridge(BRIDGE_URL, CHAT_ID);
+const serverName = `${FRONTEND}-tools`;
+const server = new McpServer({ name: serverName, version: "3.0.0" });
+
+// Compose and register all tools for the active frontend
+const tools = composeTools({ frontend: FRONTEND });
+
+for (const tool of tools) {
+  server.tool(tool.name, tool.description, tool.schema, async (params) =>
+    textResult(await tool.execute(params, bridge)),
+  );
+}
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  console.error("MCP server error:", err);
+  process.exit(1);
+});

package/src/core/tools/media.ts

@@ -0,0 +1,23 @@
+/**
+ * Media tools — list recent media in a chat.
+ */
+
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+
+export const mediaTools: ToolDefinition[] = [
+  {
+    name: "list_media",
+    description:
+      "List recent photos, documents, and other media in the current chat with file paths. Use this to find a previously sent photo or file to re-read or reference.",
+    schema: {
+      limit: z
+        .number()
+        .optional()
+        .describe("Number of entries (default 10, max 20)"),
+    },
+    execute: (params, bridge) => bridge("list_media", { limit: params.limit }),
+    frontends: ["telegram"],
+    tag: "media",
+  },
+];

package/src/core/tools/members.ts

@@ -0,0 +1,46 @@
+/**
+ * Member tools — list members, user info, online count, pinned messages.
+ */
+
+import { z } from "zod";
+import type { ToolDefinition } from "./types.js";
+
+export const memberTools: ToolDefinition[] = [
+  {
+    name: "list_chat_members",
+    description: "List chat members with names, IDs, online status, badges.",
+    schema: { limit: z.number().optional() },
+    execute: (params, bridge) =>
+      bridge("list_known_users", { limit: params.limit }),
+    frontends: ["telegram"],
+    tag: "members",
+  },
+
+  {
+    name: "get_member_info",
+    description: "Get detailed info about a user by ID.",
+    schema: { user_id: z.number() },
+    execute: (params, bridge) => bridge("get_member_info", params),
+    frontends: ["telegram"],
+    tag: "members",
+  },
+
+  {
+    name: "online_count",
+    description:
+      "Get how many members are currently online or recently active.",
+    schema: {},
+    execute: (_params, bridge) => bridge("online_count", {}),
+    frontends: ["telegram"],
+    tag: "members",
+  },
+
+  {
+    name: "get_pinned_messages",
+    description: "Get all pinned messages in the current chat.",
+    schema: {},
+    execute: (_params, bridge) => bridge("get_pinned_messages", {}),
+    frontends: ["telegram"],
+    tag: "members",
+  },
+];