talon-agent 1.6.1 → 1.7.0

package/src/plugins/playwright/index.ts

@@ -10,9 +10,16 @@
  *     "browser": "chromium",     // optional, default "chromium"
  *     "headless": true           // optional, default true
  *   }
+ *
+ * For Camoufox (anti-detect browser):
+ *   "playwright": {
+ *     "enabled": true,
+ *     "browser": "firefox",
+ *     "endpointFile": "/home/dylan/camoufox-endpoint.txt"
+ *   }
  */
 
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import type { TalonPlugin } from "../../core/plugin.js";
 import { log } from "../../util/log.js";
@@ -20,29 +27,51 @@ import { log } from "../../util/log.js";
 export function createPlaywrightPlugin(config: {
   browser?: string;
   headless?: boolean;
+  endpoint?: string;
+  endpointFile?: string;
 }): TalonPlugin {
   const browser = config.browser ?? "chromium";
   const headless = config.headless !== false; // default true
 
+  // Resolve endpoint: direct string or read from file
+  let endpoint = config.endpoint;
+  if (!endpoint && config.endpointFile) {
+    try {
+      endpoint = readFileSync(config.endpointFile, "utf-8").trim();
+    } catch {
+      log(
+        "playwright",
+        `Warning: could not read endpoint file ${config.endpointFile}`,
+      );
+    }
+  }
+
   // Resolve path from Talon's node_modules
   const mcpBin = resolve(
     import.meta.dirname ?? ".",
     "../../../node_modules/@playwright/mcp/cli.js",
   );
 
-  const args = ["--no-sandbox"];
+  const args: string[] = [];
 
-  if (headless) {
-    args.push("--headless");
-  }
+  if (endpoint) {
+    // Connect to existing browser (e.g. Camoufox websocket server)
+    args.push("--endpoint", endpoint);
+  } else {
+    args.push("--no-sandbox");
+
+    if (headless) {
+      args.push("--headless");
+    }
 
-  if (browser !== "chromium") {
-    args.push("--browser", browser);
+    if (browser !== "chromium") {
+      args.push("--browser", browser);
+    }
   }
 
   return {
     name: "playwright",
-    description: "Browser automation via Playwright MCP (headless Chromium)",
+    description: `Browser automation via Playwright MCP (${endpoint ? "Camoufox" : browser})`,
     version: "1.0.0",
 
     mcpServer: {
@@ -53,17 +82,19 @@ export function createPlaywrightPlugin(config: {
     validateConfig() {
       const errors: string[] = [];
 
-      const validBrowsers = [
-        "chromium",
-        "chrome",
-        "firefox",
-        "webkit",
-        "msedge",
-      ];
-      if (!validBrowsers.includes(browser)) {
-        errors.push(
-          `Invalid browser "${browser}". Valid options: ${validBrowsers.join(", ")}`,
-        );
+      if (!endpoint) {
+        const validBrowsers = [
+          "chromium",
+          "chrome",
+          "firefox",
+          "webkit",
+          "msedge",
+        ];
+        if (!validBrowsers.includes(browser)) {
+          errors.push(
+            `Invalid browser "${browser}". Valid options: ${validBrowsers.join(", ")}`,
+          );
+        }
       }
 
       if (!existsSync(mcpBin)) {
@@ -76,7 +107,10 @@ export function createPlaywrightPlugin(config: {
     },
 
     async init() {
-      log("playwright", `Ready (${browser}, headless=${headless})`);
+      log(
+        "playwright",
+        `Ready (${endpoint ? `Camoufox @ ${endpoint}` : `${browser}, headless=${headless}`})`,
+      );
     },
   };
 }

package/src/util/config.ts

@@ -14,19 +14,110 @@ import { log } from "./log.js";
 
 // ── Config schema ───────────────────────────────────────────────────────────
 
-const pluginEntrySchema = z.object({
-  path: z.string(),
-  config: z.record(z.string(), z.unknown()).optional(),
-});
+/** Path-based Talon plugin (loaded as a Node module). */
+const pluginPathSchema = z
+  .object({
+    path: z.string(),
+    config: z.record(z.string(), z.unknown()).optional(),
+  })
+  .strict();
+
+/** Standalone MCP server (command + args, not a Talon plugin module). */
+const pluginMcpSchema = z
+  .object({
+    name: z.string(),
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+  })
+  .strict();
+
+const pluginEntrySchema = z
+  .object({
+    path: z.string().optional(),
+    config: z.record(z.string(), z.unknown()).optional(),
+    name: z.string().optional(),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+  })
+  .strict()
+  .superRefine((value, ctx) => {
+    const hasPath = value.path !== undefined;
+    const hasMcpFields =
+      value.name !== undefined ||
+      value.command !== undefined ||
+      value.args !== undefined ||
+      value.env !== undefined;
+
+    if (hasPath && hasMcpFields) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "Plugin entry must use exactly one format: either 'path' (with optional 'config') or MCP fields ('name', 'command', optional 'args'/'env'), but not both.",
+      });
+      return;
+    }
+
+    if (!hasPath && !hasMcpFields) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "Plugin entry must provide either 'path' or both 'name' and 'command'.",
+      });
+      return;
+    }
+
+    if (hasMcpFields) {
+      if (value.config !== undefined) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["config"],
+          message: "MCP plugin entries cannot include 'config'.",
+        });
+      }
+
+      if (value.name === undefined) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["name"],
+          message: "MCP plugin entries must include 'name'.",
+        });
+      }
+
+      if (value.command === undefined) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["command"],
+          message: "MCP plugin entries must include 'command'.",
+        });
+      }
+
+      return;
+    }
+  })
+  .pipe(z.union([pluginPathSchema, pluginMcpSchema]));
 
 const frontendEnum = z.enum(["telegram", "terminal", "teams"]);
 
+const playwrightConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  /** Browser engine: chromium (default), chrome, firefox, webkit, msedge */
+  browser: z.string().optional(),
+  /** Run headless (default: true) */
+  headless: z.boolean().default(true),
+  /** Connect to an existing browser websocket endpoint. */
+  endpoint: z.string().optional(),
+  /** Read the browser websocket endpoint from a file. */
+  endpointFile: z.string().optional(),
+});
+
 const configSchema = z.object({
   frontend: z.union([frontendEnum, z.array(frontendEnum)]).default("telegram"),
   botToken: z.string().optional(),
   backend: z.enum(["claude", "opencode"]).default("claude"),
   claudeBinary: z.string().optional(),
-  model: z.string().default("claude-sonnet-4-6"),
+  model: z.string().default("default"),
   dreamModel: z.string().optional(), // Model used for background memory consolidation (defaults to main model)
   maxMessageLength: z.number().int().min(100).default(4000),
   concurrency: z.number().int().min(1).max(20).default(1),
@@ -64,15 +155,7 @@ const configSchema = z.object({
     .optional(),
 
   // Playwright — headless browser automation via MCP
-  playwright: z
-    .object({
-      enabled: z.boolean().default(false),
-      /** Browser engine: chromium (default), chrome, firefox, webkit, msedge */
-      browser: z.string().optional(),
-      /** Run headless (default: true) */
-      headless: z.boolean().default(true),
-    })
-    .optional(),
+  playwright: playwrightConfigSchema.optional(),
 
   // Display name shown in terminal UI (defaults to "Talon")
   botDisplayName: z.string().default("Talon"),
@@ -104,7 +187,7 @@ const CONFIG_FILE = pathFiles.config;
 
 const DEFAULT_CONFIG = {
   botToken: "",
-  model: "claude-sonnet-4-6",
+  model: "default",
   maxMessageLength: 4000,
   concurrency: 1,
   pulse: true,