droid-mode 0.0.5 → 0.0.7

package/README.md

@@ -22,22 +22,50 @@ Droid Mode lets you:
 2. Access them **on-demand** through progressive discovery
 3. Run procedural workflows that call MCP tools **outside** the LLM loop
 
-## Performance: Daemon Mode
+## Benchmarks
 
-Droid Mode includes an optional daemon that maintains persistent MCP connections, dramatically reducing latency for repeated operations.
+Independent benchmarks comparing Droid Mode against Native MCP (direct HTTP).
 
-### Benchmark Results
+### Summary
 
-| Mode | 10 Operations | Per-Call (warm) | Speedup |
-|------|---------------|-----------------|---------|
-| Without Daemon | 29.9s | ~2,900ms | baseline |
-| **With Daemon** | **10.2s** | **~620ms** | **4.7x faster** |
+| Configuration | Per-Tool Latency | vs Native MCP |
+|---------------|------------------|---------------|
+| **Droid Mode (Daemon)** | **616ms** | **11% faster** |
+| Native MCP (HTTP) | 695ms | baseline |
+| Droid Mode (No Daemon) | 2,365ms | 240% slower |
 
-### How It Works
+### Single Tool Performance
+
+| Call | No Daemon | Daemon | Native MCP |
+|------|-----------|--------|------------|
+| 1 | 2948ms | 845ms | 866ms |
+| 2 | 2442ms | 610ms | 789ms |
+| 3 | 2300ms | 613ms | 798ms |
+| 4 | 2415ms | 706ms | 742ms |
+| 5 | 2334ms | 617ms | 690ms |
+| **Average** | **2488ms** | **678ms** | **777ms** |
+
+### Scale Performance (10 Tools)
+
+| Metric | No Daemon | Daemon | Native MCP |
+|--------|-----------|--------|------------|
+| Total Time | 23.7s | **6.2s** | 6.9s |
+| Per-Tool Avg | 2365ms | **616ms** | 695ms |
+
+### Key Findings
+
+1. **Daemon beats Native MCP** — 11-14% faster per-tool latency
+2. **Scales linearly** — No cumulative overhead at 10+ tools
+3. **Consistent** — ±262ms variance vs ±236ms for Native MCP
+4. **No-daemon is prohibitive** — 74% slower, only for one-off calls
+
+*Benchmarks: macOS Darwin 25.2.0, Context Repo MCP server, January 2026*
+
+## Daemon Mode
 
-Each `dm call` normally spawns a new process, initializes the MCP connection, executes the tool, and exits. This adds ~2.5s overhead per call.
+The daemon maintains persistent MCP connections via a Unix socket, eliminating stdio spawn overhead.
 
-The daemon maintains a connection pool. After the first call to a server, subsequent calls reuse the existing connection:
+### How It Works
 
 ```
 ┌──────────────────────────────────────────────────┐
@@ -56,26 +84,33 @@ The daemon maintains a connection pool. After the first call to a server, subseq
 ### Usage
 
 ```bash
-# Start daemon (runs in background)
-dm daemon start
+# Daemon auto-starts on first dm call
+dm call list_collections --server context-repo
 
-# All dm call commands automatically use daemon
-dm call list_collections --server context-repo  # ~620ms
+# Or start manually
+dm daemon start
 
 # Check connection status
 dm daemon status
 
-# Stop daemon when done
+# Pre-warm specific servers
+dm daemon warm context-repo
+
+# Stop daemon
 dm daemon stop
+
+# Bypass daemon for direct call
+dm call tool --server X --no-daemon
 ```
 
-### When to Use Daemon
+### Configuration
 
-- **Multi-operation workflows** — Running several tool calls in sequence
-- **Interactive development** — Testing and iterating with MCP tools
-- **Benchmarking** — Accurate timing without spawn overhead
+```bash
+# Disable auto-warm for a server
+dm config context-repo autoWarm false
+```
 
-The daemon is optional. Without it, Droid Mode works exactly as before.
+The daemon is optional. Use `--no-daemon` to bypass it.
 
 ## Installation
 
@@ -171,6 +206,8 @@ dm run --server context-repo \
 | `dm daemon start` | Start background daemon |
 | `dm daemon stop` | Stop daemon |
 | `dm daemon status` | Show connection pool status |
+| `dm daemon warm [server]` | Pre-warm server connections |
+| `dm config <server> autoWarm false` | Disable auto-warm for server |
 
 ## Design Philosophy
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "droid-mode",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Progressive Code-Mode MCP integration for Factory.ai Droid - access MCP tools without context bloat",
   "type": "module",
   "main": "dist/cli.js",

package/templates/skills/droid-mode/bin/dm

@@ -8,7 +8,8 @@ import { getToolsCached, compactToolSummaries } from "../lib/tool_index.mjs";
 import { searchTools } from "../lib/search.mjs";
 import { hydrateTools } from "../lib/hydrate.mjs";
 import { createToolApi, executeWorkflow, writeRunArtifact } from "../lib/run.mjs";
-import { isDaemonRunning, callViaDaemon, getDaemonStatus, shutdownDaemon, startDaemon } from "../lib/daemon_client.mjs";
+import { isDaemonRunning, callViaDaemon, getDaemonStatus, shutdownDaemon, startDaemon, ensureDaemonRunning, warmServers } from "../lib/daemon_client.mjs";
+import { setServerAutoWarm, getServerState } from "../lib/state.mjs";
 
 function usage() {
   return `
@@ -24,9 +25,13 @@ Usage:
   dm call    <tool> --server <name> [--args-json '{...}'] [--args-file path.json] [--json] [--no-daemon]
 
 Daemon (persistent connections for faster calls):
-  dm daemon start            → Start background daemon
+  dm daemon start            → Start background daemon (auto-warms servers)
   dm daemon stop             → Stop daemon
   dm daemon status [--json]  → Show connection pool status
+  dm daemon warm [<server>]  → Pre-warm server(s)
+
+Configuration:
+  dm config <server> autoWarm true|false  → Enable/disable auto-warm for server
 
 Progressive Disclosure Flow:
   1. dm servers              → Discover available MCP servers
@@ -394,19 +399,21 @@ async function cmdCall(args) {
   }
 
   // Try daemon first (unless --no-daemon flag is set)
-  const useDaemon = !args.flags["no-daemon"] && await isDaemonRunning();
-
-  if (useDaemon) {
-    const res = await callViaDaemon({ server: serverName, tool, args: argObj });
-    if (!res.ok) {
-      fail(`Daemon call failed: ${res.error}`);
-    }
-    if (args.flags.json) {
-      process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+  // Auto-start daemon if not running
+  if (!args.flags["no-daemon"]) {
+    const daemonReady = await ensureDaemonRunning();
+    if (daemonReady) {
+      const res = await callViaDaemon({ server: serverName, tool, args: argObj });
+      if (!res.ok) {
+        fail(`Daemon call failed: ${res.error}`);
+      }
+      if (args.flags.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(JSON.stringify(res.result, null, 2) + "\n");
       return;
     }
-    process.stdout.write(JSON.stringify(res.result, null, 2) + "\n");
-    return;
   }
 
   // Direct call (no daemon)
@@ -488,7 +495,65 @@ async function cmdDaemon(args) {
     return;
   }
 
-  fail(`Unknown daemon subcommand: ${subcmd}\nUsage: dm daemon start|stop|status`);
+  if (subcmd === "warm") {
+    const running = await isDaemonRunning();
+    if (!running) {
+      // Auto-start daemon for warm command
+      try {
+        await startDaemon();
+        process.stdout.write("Daemon started.\n");
+      } catch (err) {
+        fail(`Failed to start daemon: ${err.message}`);
+      }
+    }
+
+    const serverName = args._[2]; // Optional: specific server
+    const result = await warmServers(serverName);
+
+    if (args.flags.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+
+    if (serverName) {
+      process.stdout.write(result.warmed ? `Warmed: ${serverName}\n` : `Already warm: ${serverName}\n`);
+    } else {
+      const { warmed = [], failed = [] } = result;
+      if (warmed.length) {
+        process.stdout.write(`Warmed ${warmed.length} server(s): ${warmed.join(", ")}\n`);
+      }
+      if (failed.length) {
+        process.stdout.write(`Failed: ${failed.join(", ")}\n`);
+      }
+      if (!warmed.length && !failed.length) {
+        process.stdout.write("All servers already warm or none configured for auto-warm.\n");
+      }
+    }
+    return;
+  }
+
+  fail(`Unknown daemon subcommand: ${subcmd}\nUsage: dm daemon start|stop|status|warm`);
+}
+
+async function cmdConfig(args) {
+  const serverName = args._[1];
+  const key = args._[2];
+  const value = args._[3];
+
+  if (!serverName || !key) {
+    fail("Usage: dm config <server> <key> <value>\n\nSupported keys:\n  autoWarm true|false  - Enable/disable auto-warm for server");
+  }
+
+  if (key === "autoWarm") {
+    if (value !== "true" && value !== "false") {
+      fail("autoWarm must be 'true' or 'false'");
+    }
+    setServerAutoWarm(serverName, value === "true");
+    process.stdout.write(`Set ${serverName}.autoWarm = ${value}\n`);
+    return;
+  }
+
+  fail(`Unknown config key: ${key}\nSupported: autoWarm`);
 }
 
 async function main() {
@@ -509,6 +574,7 @@ async function main() {
     if (cmd === "run") return await cmdRun(args);
     if (cmd === "call") return await cmdCall(args);
     if (cmd === "daemon") return await cmdDaemon(args);
+    if (cmd === "config") return await cmdConfig(args);
     fail(`Unknown command: ${cmd}\n\n${usage()}`);
   } catch (err) {
     fail(err.message || err);

package/templates/skills/droid-mode/lib/daemon.mjs

@@ -2,10 +2,12 @@ import net from "node:net";
 import fs from "node:fs";
 import path from "node:path";
 import { McpClient } from "./mcp_client.mjs";
-import { resolveServer, listAllServers } from "./config.mjs";
+import { resolveServer, listAllServers, loadMcpConfigs } from "./config.mjs";
+import { loadState, saveState, getServersToWarm, recordServerUsage } from "./state.mjs";
 
 const SOCKET_PATH = process.env.DM_DAEMON_SOCKET || "/tmp/dm-daemon.sock";
 const IDLE_TIMEOUT_MS = parseInt(process.env.DM_DAEMON_IDLE_MS || "600000", 10); // 10 minutes default
+const MAX_CONNECTIONS = 50;
 
 /**
  * Connection pool managing lazy-initialized MCP clients.
@@ -30,6 +32,11 @@ class ConnectionPool {
       return existing.client;
     }
 
+    // Enforce max connections limit
+    if (this.connections.size >= MAX_CONNECTIONS) {
+      throw new Error(`Connection pool full (max ${MAX_CONNECTIONS}). Close unused connections or increase limit.`);
+    }
+
     // Lazy init: resolve from mcp.json, connect, cache
     const { entry } = resolveServer({ server: serverName });
     const client = new McpClient({ serverName, entry });
@@ -42,9 +49,66 @@ class ConnectionPool {
       callCount: 1,
     });
 
+    // Record usage for auto-warm state
+    recordServerUsage(serverName);
+
     return client;
   }
 
+  /**
+   * Pre-warm a specific server connection.
+   * @param {string} serverName
+   * @returns {Promise<boolean>} true if warmed, false if already warm or failed
+   */
+  async warmServer(serverName) {
+    if (this.connections.has(serverName)) {
+      return false; // Already warm
+    }
+
+    try {
+      await this.getClient(serverName);
+      return true;
+    } catch (err) {
+      if (process.env.DM_DEBUG === "1") {
+        process.stderr.write(`[daemon] Failed to warm ${serverName}: ${err.message}\n`);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Pre-warm all servers that should be auto-warmed.
+   * @returns {Promise<{ warmed: string[], failed: string[] }>}
+   */
+  async warmAll() {
+    const servers = listAllServers();
+    const serverNames = servers.map((s) => s.name);
+    const toWarm = getServersToWarm(serverNames);
+
+    const warmed = [];
+    const failed = [];
+
+    // Warm in parallel with concurrency limit
+    const results = await Promise.allSettled(
+      toWarm.map(async (name) => {
+        const success = await this.warmServer(name);
+        return { name, success };
+      })
+    );
+
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value.success) {
+        warmed.push(result.value.name);
+      } else if (result.status === "fulfilled") {
+        // Already warm, don't count as failed
+      } else {
+        failed.push(result.reason?.name || "unknown");
+      }
+    }
+
+    return { warmed, failed };
+  }
+
   /**
    * Get status of all connections.
    */
@@ -185,6 +249,18 @@ export class DaemonServer {
       }
     }
 
+    if (action === "warm") {
+      if (server) {
+        // Warm specific server
+        const success = await this.pool.warmServer(server);
+        return { ok: true, server, warmed: success };
+      } else {
+        // Warm all auto-warm servers
+        const result = await this.pool.warmAll();
+        return { ok: true, ...result };
+      }
+    }
+
     if (action === "shutdown") {
       // Graceful shutdown
       setImmediate(() => this.stop());
@@ -194,6 +270,32 @@ export class DaemonServer {
     return { ok: false, error: `Unknown action: ${action}` };
   }
 
+  /**
+   * Start watching mcp.json for changes.
+   */
+  startMcpWatcher() {
+    const { projectPath, userPath } = loadMcpConfigs();
+    const watchPaths = [userPath, projectPath].filter(Boolean);
+
+    for (const watchPath of watchPaths) {
+      if (!fs.existsSync(watchPath)) continue;
+
+      try {
+        fs.watch(watchPath, { persistent: false }, async (eventType) => {
+          if (eventType === "change") {
+            if (process.env.DM_DEBUG === "1") {
+              process.stderr.write(`[daemon] mcp.json changed, warming new servers...\n`);
+            }
+            // Re-warm any new servers
+            await this.pool.warmAll();
+          }
+        });
+      } catch (err) {
+        // Ignore watch errors (file might not exist yet)
+      }
+    }
+  }
+
   /**
    * Start the daemon server.
    */
@@ -236,9 +338,19 @@ export class DaemonServer {
 
       this.server.on("error", reject);
 
-      this.server.listen(SOCKET_PATH, () => {
+      this.server.listen(SOCKET_PATH, async () => {
         // Set socket permissions (user only)
         fs.chmodSync(SOCKET_PATH, 0o600);
+
+        // Start mcp.json watcher
+        this.startMcpWatcher();
+
+        // Auto-warm servers on startup
+        const { warmed, failed } = await this.pool.warmAll();
+        if (process.env.DM_DEBUG === "1" && warmed.length > 0) {
+          process.stderr.write(`[daemon] Pre-warmed ${warmed.length} server(s): ${warmed.join(", ")}\n`);
+        }
+
         resolve();
       });
     });

package/templates/skills/droid-mode/lib/daemon_client.mjs

@@ -163,3 +163,35 @@ export async function startDaemon() {
   } catch {}
   throw new Error("Daemon failed to start within timeout");
 }
+
+/**
+ * Ensure daemon is running, starting it if necessary.
+ * @returns {Promise<boolean>} true if daemon is now running
+ */
+export async function ensureDaemonRunning() {
+  if (await isDaemonRunning()) {
+    return true;
+  }
+
+  try {
+    await startDaemon();
+    return true;
+  } catch (err) {
+    if (process.env.DM_DEBUG === "1") {
+      process.stderr.write(`[dm] Failed to auto-start daemon: ${err.message}\n`);
+    }
+    return false;
+  }
+}
+
+/**
+ * Request daemon to warm a specific server or all servers.
+ * @param {string} [serverName] - If provided, warm only this server. Otherwise warm all.
+ * @returns {Promise<object>}
+ */
+export async function warmServers(serverName) {
+  return sendRequest({
+    action: "warm",
+    server: serverName,
+  });
+}

package/templates/skills/droid-mode/lib/state.mjs

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getDroidModeDataDir, ensureDir, readJsonFileIfExists, writeJson } from "./util.mjs";
+
+const STATE_FILE = "daemon-state.json";
+const STATE_VERSION = 1;
+
+/**
+ * Get the path to the daemon state file.
+ */
+export function getStateFilePath() {
+  return path.join(getDroidModeDataDir(), STATE_FILE);
+}
+
+/**
+ * Load daemon state from disk.
+ * @returns {{ version: number, servers: Record<string, ServerState> }}
+ */
+export function loadState() {
+  const filePath = getStateFilePath();
+  const data = readJsonFileIfExists(filePath);
+  
+  if (!data || data.version !== STATE_VERSION) {
+    return { version: STATE_VERSION, servers: {} };
+  }
+  
+  return data;
+}
+
+/**
+ * Save daemon state to disk.
+ * @param {{ version: number, servers: Record<string, ServerState> }} state
+ */
+export function saveState(state) {
+  const filePath = getStateFilePath();
+  ensureDir(path.dirname(filePath));
+  writeJson(filePath, { ...state, version: STATE_VERSION });
+}
+
+/**
+ * Get server state, creating default if not exists.
+ * @param {string} serverName
+ * @returns {{ autoWarm: boolean, lastUsed: string|null, usageCount: number }}
+ */
+export function getServerState(serverName) {
+  const state = loadState();
+  return state.servers[serverName] || {
+    autoWarm: true, // Default: opt-out (auto-warm enabled)
+    lastUsed: null,
+    usageCount: 0,
+  };
+}
+
+/**
+ * Update server state after use.
+ * @param {string} serverName
+ */
+export function recordServerUsage(serverName) {
+  const state = loadState();
+  const server = state.servers[serverName] || {
+    autoWarm: true,
+    lastUsed: null,
+    usageCount: 0,
+  };
+  
+  server.lastUsed = new Date().toISOString();
+  server.usageCount = (server.usageCount || 0) + 1;
+  state.servers[serverName] = server;
+  
+  saveState(state);
+}
+
+/**
+ * Set autoWarm for a server.
+ * @param {string} serverName
+ * @param {boolean} autoWarm
+ */
+export function setServerAutoWarm(serverName, autoWarm) {
+  const state = loadState();
+  const server = state.servers[serverName] || {
+    autoWarm: true,
+    lastUsed: null,
+    usageCount: 0,
+  };
+  
+  server.autoWarm = autoWarm;
+  state.servers[serverName] = server;
+  
+  saveState(state);
+}
+
+/**
+ * Get list of servers that should be auto-warmed.
+ * @param {string[]} availableServers - List of server names from mcp.json
+ * @returns {string[]}
+ */
+export function getServersToWarm(availableServers) {
+  const state = loadState();
+  
+  return availableServers.filter((name) => {
+    const serverState = state.servers[name];
+    // Default to true if no state exists (opt-out model)
+    return serverState?.autoWarm !== false;
+  });
+}