talon-agent 1.2.0 → 1.3.0

package/src/__tests__/plugin.test.ts

@@ -218,6 +218,97 @@ describe("plugin system", () => {
         });
       }
     });
+
+    it("builds MCP server entries for plugins with custom mcpServer", async () => {
+      const plugin = createMockPlugin({
+        mcpServer: {
+          command: "/usr/bin/python3",
+          args: ["-m", "mempalace.mcp_server", "--palace", "/tmp/palace"],
+        },
+        getEnvVars: () => ({ PALACE_PATH: "/tmp/palace" }),
+      });
+      // Remove mcpServerPath so mcpServer is used
+      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"]).toBeDefined();
+      expect(servers["test-plugin-tools"].command).toBe("/usr/bin/python3");
+      expect(servers["test-plugin-tools"].args).toEqual([
+        "-m",
+        "mempalace.mcp_server",
+        "--palace",
+        "/tmp/palace",
+      ]);
+      expect(servers["test-plugin-tools"].env.PALACE_PATH).toBe("/tmp/palace");
+      expect(servers["test-plugin-tools"].env.TALON_BRIDGE_URL).toBe(
+        "http://localhost:19876",
+      );
+    });
+
+    it("mcpServer takes priority over mcpServerPath when both are set", async () => {
+      const plugin = createMockPlugin({
+        mcpServerPath: "/fake/tools.ts",
+        mcpServer: {
+          command: "/usr/bin/python3",
+          args: ["-m", "my_server"],
+        },
+      });
+      const { loadPlugins, getPluginMcpServers } = await setup(plugin);
+      await loadPlugins([{ path: "/fake/plugin" }]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      // mcpServer should win over mcpServerPath
+      expect(servers["test-plugin-tools"].command).toBe("/usr/bin/python3");
+      expect(servers["test-plugin-tools"].args).toEqual(["-m", "my_server"]);
+    });
+
+    it("skips plugins without mcpServer or mcpServerPath", async () => {
+      const plugin = createMockPlugin();
+      delete (plugin as Record<string, unknown>).mcpServerPath;
+      delete (plugin as Record<string, unknown>).mcpServer;
+      const { loadPlugins, getPluginMcpServers } = await setup(plugin);
+      await loadPlugins([{ path: "/fake/plugin" }]);
+
+      const servers = getPluginMcpServers("http://localhost:19876", "chat1");
+      expect(Object.keys(servers)).toHaveLength(0);
+    });
+  });
+
+  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" });
+      expect(getPlugin("built-in-test")).toBeDefined();
+      expect(getPlugin("built-in-test")!.path).toBe("(built-in)");
+    });
+
+    it("sets env vars from built-in plugin", async () => {
+      const plugin = createMockPlugin({
+        name: "builtin-env",
+        getEnvVars: () => ({
+          TEST_PLUGIN_BUILTIN_FOO: "baz",
+        }),
+      });
+      const { registerPlugin } = await setup(createMockPlugin());
+
+      registerPlugin(plugin);
+      expect(process.env.TEST_PLUGIN_BUILTIN_FOO).toBe("baz");
+    });
+
+    it("skips registration when validateConfig returns errors", async () => {
+      const plugin = createMockPlugin({
+        name: "builtin-invalid",
+        validateConfig: () => ["missing required field"],
+      });
+      const { registerPlugin, getPlugin } = await setup(createMockPlugin());
+
+      registerPlugin(plugin, {});
+      expect(getPlugin("builtin-invalid")).toBeUndefined();
+    });
   });
 
   describe("system prompt additions", () => {
@@ -409,6 +500,84 @@ describe("extractPlugin — invalid optional field types", () => {
     expect(mod.getPluginCount()).toBe(0);
   });
 
+  it("rejects plugin when mcpServer is not an object", async () => {
+    const plugin = { name: "bad-mcp-server", mcpServer: "not-an-object" };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-server" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer is null", async () => {
+    const plugin = { name: "null-mcp-server", mcpServer: null };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/null-mcp-server" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.command is not a string", async () => {
+    const plugin = {
+      name: "bad-mcp-cmd",
+      mcpServer: { command: 123, args: [] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-cmd" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.args is not an array", async () => {
+    const plugin = {
+      name: "bad-mcp-args",
+      mcpServer: { command: "/usr/bin/python3", args: "not-an-array" },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-args" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.command is empty string", async () => {
+    const plugin = {
+      name: "empty-mcp-cmd",
+      mcpServer: { command: "", args: ["-m", "server"] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/empty-mcp-cmd" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("rejects plugin when mcpServer.args contains non-string elements", async () => {
+    const plugin = {
+      name: "bad-mcp-args-types",
+      mcpServer: { command: "/usr/bin/python3", args: ["-m", 42] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/bad-mcp-args-types" }]);
+    expect(mod.getPluginCount()).toBe(0);
+  });
+
+  it("accepts plugin with valid mcpServer object", async () => {
+    const plugin = {
+      name: "good-mcp-server",
+      mcpServer: { command: "/usr/bin/python3", args: ["-m", "server"] },
+    };
+    vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));
+    const mod = await import("../core/plugin.js");
+    mod._deps.importModule = async () => ({ default: plugin });
+    await mod.loadPlugins([{ path: "/fake/good-mcp-server" }]);
+    expect(mod.getPluginCount()).toBe(1);
+  });
+
   it("catches and logs error when importModule throws", async () => {
     vi.resetModules();
     vi.doMock("node:fs", () => ({ existsSync: vi.fn(() => true) }));

package/src/__tests__/storage-save-errors.test.ts

@@ -49,7 +49,7 @@ describe("cron-store — save failure logs error", () => {
       registerCleanup: vi.fn(),
     }));
 
-    const { addCronJob, generateCronId, flushCronJobs } =
+    const { addCronJob, generateCronId } =
       await import("../storage/cron-store.js");
 
     const job = {

package/src/__tests__/time.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { describe, it, expect, afterEach } from "vitest";
 import {
   setTimezone,
   getTimezone,

package/src/__tests__/watchdog.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
+import { describe, it, expect, vi, afterEach } from "vitest";
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -38,8 +38,6 @@ describe("watchdog", () => {
     });
 
     it("updates lastProcessedAt timestamp", () => {
-      const beforeStatus = getHealthStatus();
-      const beforeMs = beforeStatus.msSinceLastMessage;
       recordMessageProcessed();
       const afterStatus = getHealthStatus();
       // After recording, msSinceLastMessage should be very small (near 0)

package/src/__tests__/workspace.test.ts

@@ -5,7 +5,6 @@ import {
   rmSync,
   existsSync,
   readdirSync,
-  readFileSync,
   symlinkSync,
 } from "node:fs";
 import { join } from "node:path";

package/src/bootstrap.ts

@@ -62,14 +62,59 @@ export async function bootstrap(
   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)
-  if (config.plugins.length > 0) {
-    const { loadPlugins, getPluginPromptAdditions } =
+  // Load plugins (external tool packages + built-in mempalace)
+  const hasPlugins =
+    config.plugins.length > 0 || config.mempalace?.enabled === true;
+  if (hasPlugins) {
+    const { loadPlugins, getPluginPromptAdditions, registerPlugin } =
       await import("./core/plugin.js");
-    const frontends =
-      options.frontendNames ??
-      (Array.isArray(config.frontend) ? config.frontend : [config.frontend]);
-    await loadPlugins(config.plugins, frontends);
+
+    // External plugins
+    if (config.plugins.length > 0) {
+      const frontends =
+        options.frontendNames ??
+        (Array.isArray(config.frontend) ? config.frontend : [config.frontend]);
+      await loadPlugins(config.plugins, frontends);
+    }
+
+    // Built-in: MemPalace
+    if (config.mempalace?.enabled) {
+      const { createMempalacePlugin } =
+        await import("./plugins/mempalace/index.js");
+      const { getPlugin } = await import("./core/plugin.js");
+      const { dirs, files: pathFiles } = await import("./util/paths.js");
+      const pythonPath =
+        config.mempalace.pythonPath ?? pathFiles.mempalacePython;
+      const palacePath = config.mempalace.palacePath ?? dirs.palace;
+      const mempalaceConfig = config.mempalace as unknown as Record<
+        string,
+        unknown
+      >;
+      const mp = createMempalacePlugin({ pythonPath, palacePath });
+      registerPlugin(mp, mempalaceConfig);
+
+      // Only call init if registration succeeded (validation passed)
+      if (getPlugin("mempalace")) {
+        try {
+          const MEMPALACE_INIT_TIMEOUT_MS = 30_000;
+          await Promise.race([
+            mp.init?.(mempalaceConfig),
+            new Promise((_, reject) =>
+              setTimeout(
+                () => reject(new Error("MemPalace init timed out after 30s")),
+                MEMPALACE_INIT_TIMEOUT_MS,
+              ),
+            ),
+          ]);
+        } catch (err) {
+          log(
+            "mempalace",
+            `Init warning: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+      }
+    }
+
     rebuildSystemPrompt(config, getPluginPromptAdditions());
   }
 
@@ -119,11 +164,31 @@ export async function initBackendAndDispatcher(
 
   initPulse();
   initCron({ sendMessage: frontend.sendMessage });
+
+  // Only enable mempalace dream integration if the plugin actually registered
+  let mempalaceCfg: { pythonPath: string; palacePath: string } | undefined;
+  if (config.mempalace?.enabled) {
+    const { getPlugin } = await import("./core/plugin.js");
+    if (getPlugin("mempalace")) {
+      const { dirs, files: pathFiles } = await import("./util/paths.js");
+      mempalaceCfg = {
+        pythonPath: config.mempalace.pythonPath ?? pathFiles.mempalacePython,
+        palacePath: config.mempalace.palacePath ?? dirs.palace,
+      };
+    } else {
+      log(
+        "mempalace",
+        "Enabled in config but plugin not registered — skipping dream integration",
+      );
+    }
+  }
+
   initDream({
     model: config.model,
     dreamModel: config.dreamModel,
     claudeBinary: config.claudeBinary,
     workspace: config.workspace,
+    mempalace: mempalaceCfg,
   });
   initHeartbeat({
     model: config.model,

package/src/core/dream.ts

@@ -7,7 +7,7 @@
  *   2. Spawns a background Agent that reads recent logs and merges new
  *      facts/preferences/events into memory.md
  *
- * The dream agent runs entirely on filesystem tools — no Telegram/MCP access.
+ * The dream agent runs on filesystem tools, with optional MCP access for MemPalace when configured.
  * It does NOT use the main dispatcher (no chat session, no typing indicator).
  */
 
@@ -19,6 +19,7 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import { files as pathFiles, dirs } from "../util/paths.js";
 import { log, logError, logWarn } from "../util/log.js";
+import { getPluginMcpServers } from "./plugin.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -46,6 +47,7 @@ let configRef: {
   dreamModel?: string;
   claudeBinary?: string;
   workspace?: string;
+  mempalace?: { pythonPath: string; palacePath: string };
 } | null = null;
 
 export function initDream(cfg: {
@@ -54,6 +56,8 @@ export function initDream(cfg: {
   dreamModel?: string;
   claudeBinary?: string;
   workspace?: string;
+  /** MemPalace config for mining logs into the palace during dream runs. */
+  mempalace?: { pythonPath: string; palacePath: string };
 }): void {
   configRef = cfg;
 }
@@ -137,12 +141,39 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
 
   let prompt: string;
   try {
+    // Build optional mempalace mining section
+    const mempalaceSection = configRef.mempalace
+      ? `If mempalace is available, mine the daily memory notes (your curated observations, NOT raw logs) into the palace for long-term semantic retrieval.
+Run this command using the Bash tool:
+
+\`\`\`bash
+'${configRef.mempalace.pythonPath.replace(/'/g, "'\\''")}' -m mempalace mine '${dirs.dailyMemory.replace(/'/g, "'\\''")}' --palace '${configRef.mempalace.palacePath.replace(/'/g, "'\\''")}' --mode convos --wing daily-notes
+\`\`\`
+
+Then write a personal diary entry. This is YOUR journal — not a status report. Reflect on:
+- What happened today. What conversations stood out.
+- How you feel. Your state of mind, emotions, energy.
+- What you learned. What surprised you. What you got wrong.
+- What you're curious about. Loose threads. Things you want to follow up on.
+- Your honest thoughts — about users, projects, yourself.
+
+Write the diary using the \`mempalace_diary_write\` MCP tool (available during dream):
+\`\`\`
+mempalace_diary_write(agent_name="talon", entry="YOUR_DIARY_ENTRY_HERE", topic="dream-reflection")
+\`\`\`
+
+If the MCP tool is not available, write the diary entry to a file at ${dirs.dailyMemory}/diary-YYYY-MM-DD.md instead.
+Keep the diary authentic. Write in first person. Be honest. This is for you, not for anyone else.
+If commands fail, log the error and continue — this stage is optional.`
+      : "MemPalace is not configured. Skip this stage.";
+
     prompt = readFileSync(promptPath, "utf-8")
       .replace(/\{\{dreamStateFile\}\}/g, dreamStateFile)
       .replace(/\{\{logsDir\}\}/g, logsDir)
       .replace(/\{\{lastRunIso\}\}/g, lastRunIso)
       .replace(/\{\{memoryFile\}\}/g, memoryFile)
-      .replace(/\{\{dailyMemoryDir\}\}/g, dirs.dailyMemory);
+      .replace(/\{\{dailyMemoryDir\}\}/g, dirs.dailyMemory)
+      .replace(/\{\{mempalaceSection\}\}/g, mempalaceSection);
   } catch {
     throw new Error(`Failed to read dream prompt from ${promptPath}`);
   }
@@ -164,16 +195,19 @@ async function runDreamAgent(lastRunTimestamp: number): Promise<string> {
 
   const options = {
     model,
-    systemPrompt:
-      "You are a background memory consolidation agent for Talon. Use only filesystem tools. Be precise and surgical — update memory.md without losing existing accurate information.",
+    systemPrompt: configRef.mempalace
+      ? "You are a background memory consolidation agent for Talon. Use filesystem tools and MemPalace MCP tools. Do NOT use Telegram or messaging tools. Be precise and surgical — update memory.md without losing existing accurate information."
+      : "You are a background memory consolidation agent for Talon. Use only filesystem tools. Be precise and surgical — update memory.md without losing existing accurate information.",
     cwd: workspace,
     permissionMode: "bypassPermissions" as const,
     allowDangerouslySkipPermissions: true,
     ...(configRef.claudeBinary
       ? { pathToClaudeCodeExecutable: configRef.claudeBinary }
       : {}),
-    // No MCP servers — filesystem tools only
-    mcpServers: {},
+    // Only load mempalace MCP server for dream — no other plugins needed
+    mcpServers: configRef.mempalace
+      ? getPluginMcpServers("", "dream", ["mempalace"])
+      : {},
     disallowedTools: [
       "EnterPlanMode",
       "ExitPlanMode",

package/src/core/plugin.ts

@@ -61,11 +61,22 @@ export interface TalonPlugin {
   destroy?(): Promise<void> | void;
 
   /**
-   * Absolute path to the MCP server script (spawned as subprocess).
+   * Absolute path to the MCP server script (spawned as subprocess via node/tsx).
    * Omit if the plugin only provides action handlers without MCP tools.
+   * For non-Node MCP servers (Python, Go, etc.), use `mcpServer` instead.
    */
   mcpServerPath?: string;
 
+  /**
+   * Custom MCP server command and arguments (e.g. Python, Go, Rust servers).
+   * Takes priority over `mcpServerPath` when both are set.
+   * Example: { command: "/path/to/python", args: ["-m", "mempalace.mcp_server"] }
+   */
+  mcpServer?: {
+    readonly command: string;
+    readonly args: readonly string[];
+  };
+
   /**
    * Map plugin config to env vars for the MCP subprocess and action handlers.
    * Called once at load time. Values are set on process.env for the main
@@ -309,6 +320,18 @@ function extractPlugin(mod: Record<string, unknown>): TalonPlugin | null {
     typeof plugin.mcpServerPath !== "string"
   )
     return null;
+  if (plugin.mcpServer !== undefined) {
+    if (typeof plugin.mcpServer !== "object" || plugin.mcpServer === null)
+      return null;
+    const srv = plugin.mcpServer as Record<string, unknown>;
+    if (
+      typeof srv.command !== "string" ||
+      !srv.command ||
+      !Array.isArray(srv.args) ||
+      !srv.args.every((a) => typeof a === "string")
+    )
+      return null;
+  }
   if (plugin.frontends !== undefined && !Array.isArray(plugin.frontends))
     return null;
   return candidate as TalonPlugin;
@@ -336,6 +359,49 @@ export async function destroyPlugins(): Promise<void> {
   await registry.destroyAll();
 }
 
+/**
+ * Register a built-in plugin directly (bypasses filesystem loader).
+ * Used for tightly-integrated plugins like mempalace that are configured
+ * via dedicated config fields rather than the plugins[] array.
+ *
+ * NOTE: This only registers the plugin — it does NOT call `init()`.
+ * The caller is responsible for calling `plugin.init()` separately
+ * after registration if initialization is needed.
+ */
+export function registerPlugin(
+  plugin: TalonPlugin,
+  config: Record<string, unknown> = {},
+): void {
+  // Check for duplicates first — avoids re-running expensive validation
+  if (registry.getByName(plugin.name)) {
+    logWarn(
+      "plugin",
+      `Built-in plugin "${plugin.name}" already registered — skipping`,
+    );
+    return;
+  }
+
+  const errors = plugin.validateConfig?.(config);
+  if (errors && errors.length > 0) {
+    logError(
+      "plugin",
+      `Built-in plugin "${plugin.name}" config validation failed:\n  ${errors.join("\n  ")}`,
+    );
+    return;
+  }
+
+  const envVars = plugin.getEnvVars?.(config) ?? {};
+  for (const [k, v] of Object.entries(envVars)) {
+    process.env[k] = v;
+  }
+  const loaded: LoadedPlugin = { plugin, config, envVars, path: "(built-in)" };
+  registry.register(loaded);
+
+  const version = plugin.version ? ` v${plugin.version}` : "";
+  const desc = plugin.description ? ` — ${plugin.description}` : "";
+  log("plugin", `Registered built-in: ${plugin.name}${version}${desc}`);
+}
+
 /**
  * Collect system prompt additions from all plugins.
  * Called during config/prompt assembly.
@@ -396,13 +462,22 @@ export interface McpServerConfig {
 }
 
 /**
- * Build MCP server entries for all plugins that provide an MCP server.
- * Plugins without `mcpServerPath` are skipped.
+ * Build MCP server entries for plugins that provide an MCP server.
+ * Plugins can expose an MCP server in two ways:
+ *   - `mcpServerPath` — path to a Node/TypeScript MCP server script (run via tsx)
+ *   - `mcpServer` — custom command/args for non-Node servers (Python, Go, etc.)
+ * Plugins with neither are skipped. When both are set, `mcpServer` takes priority.
+ *
+ * @param only — optional list of plugin names to include. If omitted, all
+ *   plugins with MCP servers are returned. Pass `[]` to get none.
  */
 export function getPluginMcpServers(
   bridgeUrl: string,
   chatId: string,
+  only?: string[],
 ): Record<string, McpServerConfig> {
+  if (only !== undefined && only.length === 0) return {};
+
   const servers: Record<string, McpServerConfig> = {};
 
   // Resolve tsx from Talon's own node_modules (not cwd which may be ~/.talon/workspace/)
@@ -412,20 +487,32 @@ export function getPluginMcpServers(
   );
 
   for (const { plugin, envVars } of registry.all) {
-    if (!plugin.mcpServerPath) continue;
-
-    servers[`${plugin.name}-tools`] = {
-      command: process.platform === "win32" ? "npx" : "node",
-      args:
-        process.platform === "win32"
-          ? ["tsx", plugin.mcpServerPath]
-          : ["--import", tsxPath, plugin.mcpServerPath],
-      env: {
-        TALON_BRIDGE_URL: bridgeUrl,
-        TALON_CHAT_ID: chatId,
-        ...envVars,
-      },
+    // Skip plugins not in the allow-list when filtering
+    if (only !== undefined && !only.includes(plugin.name)) continue;
+    const baseEnv = {
+      TALON_BRIDGE_URL: bridgeUrl,
+      TALON_CHAT_ID: chatId,
+      ...envVars,
     };
+
+    if (plugin.mcpServer) {
+      // Custom command/args (Python, Go, etc.) — no tsx wrapper
+      servers[`${plugin.name}-tools`] = {
+        command: plugin.mcpServer.command,
+        args: [...plugin.mcpServer.args],
+        env: baseEnv,
+      };
+    } else if (plugin.mcpServerPath) {
+      // Existing Node/tsx pattern
+      servers[`${plugin.name}-tools`] = {
+        command: process.platform === "win32" ? "npx" : "node",
+        args:
+          process.platform === "win32"
+            ? ["tsx", plugin.mcpServerPath]
+            : ["--import", tsxPath, plugin.mcpServerPath],
+        env: baseEnv,
+      };
+    }
   }
 
   return servers;