@lightcone-ai/daemon 0.6.4 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -3,6 +3,8 @@ import { mkdirSync, readdirSync, readFileSync, statSync, lstatSync } from 'fs';
 import { homedir } from 'os';
 import path from 'path';
 import { buildSystemPrompt } from './drivers/claude.js';
+import { buildCodexSpawn, buildCodexSystemPrompt, parseCodexLine } from './drivers/codex.js';
+import { buildKimiSpawn, buildKimiInitMessages, parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
 
 export class AgentManager {
   constructor({ serverUrl, machineApiKey }) {
@@ -47,6 +49,19 @@ export class AgentManager {
     return dir;
   }
 
+  _formatDeliveryText(message) {
+    return `New message in ${message.channel_type === 'dm' ? 'dm from' : `#${message.channel_name} from`} ${message.sender_name}: ${message.content}`;
+  }
+
+  _takePendingMessage(key) {
+    if (!this._pendingMessages) return null;
+    const pending = this._pendingMessages.get(key);
+    if (!pending?.length) return null;
+    const msg = pending.shift();
+    if (pending.length === 0) this._pendingMessages.delete(key);
+    return msg;
+  }
+
   _startAgent({ agentId, channelId, config }, connection) {
     const key = this._key(agentId, channelId);
     if (this.agents.has(key) || this.starting.has(key)) {
@@ -55,88 +70,184 @@ export class AgentManager {
     }
     this.starting.add(key);
 
+    const runtime = config.runtime ?? 'claude';
     const workspaceDir = this._workspaceDir(agentId, channelId);
     const chatBridgePath = new URL('./chat-bridge.js', import.meta.url).pathname;
+    const startupMsg = runtime === 'codex' ? this._takePendingMessage(key) : null;
 
-    const mcpServers = {
-      chat: {
-        command: 'node',
-        args: [chatBridgePath],
-        env: {
-          SERVER_URL: this.serverUrl,
-          MACHINE_API_KEY: this.machineApiKey,
-          AGENT_ID: agentId,
-          CHANNEL_ID: channelId ?? '',
-        },
-      },
-    };
+    let proc;
 
-    if (config.browserAccess) {
-      mcpServers['chrome-devtools'] = {
-        command: 'npx',
-        args: ['chrome-devtools-mcp@latest', '--headless'],
-        env: {},
-      };
-    }
+    if (runtime === 'kimi') {
+      // ── Kimi CLI ──────────────────────────────────────────────────────────
+      const kimiSpawn = buildKimiSpawn({
+        config, agentId, channelId, workspaceDir, chatBridgePath,
+        serverUrl: this.serverUrl, machineApiKey: this.machineApiKey,
+      });
+
+      console.log(`[AgentManager] Spawning kimi for ${agentId} channel=${channelId ?? 'none'} (session=${kimiSpawn.sessionId})`);
+
+      proc = spawn('kimi', kimiSpawn.args, {
+        cwd: workspaceDir,
+        env: kimiSpawn.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      // Send initialize + prompt via stdin
+      const initMsgs = buildKimiInitMessages(kimiSpawn);
+      for (const msg of initMsgs) {
+        proc.stdin.write(msg + '\n');
+      }
+
+      // Track Kimi-specific state for parsing
+      const kimiState = { sessionId: kimiSpawn.sessionId, sessionAnnounced: false };
+
+      this.agents.set(key, {
+        config, channelId, agentId, sessionId: kimiSpawn.sessionId, proc,
+        runtime: 'kimi', kimiState, kimiIdle: false,
+      });
+      this.starting.delete(key);
+
+      let buffer = '';
+      proc.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          this._parseKimiLine(key, agentId, channelId, line, connection);
+        }
+      });
+    } else if (runtime === 'codex') {
+      const startupPrompt = startupMsg
+        ? `${buildCodexSystemPrompt(config, agentId)}\n\nNew message received:\n\n${this._formatDeliveryText(startupMsg.message)}\n\nRespond as appropriate. Complete all required work before stopping.`
+        : buildCodexSystemPrompt(config, agentId);
+
+      const codexSpawn = buildCodexSpawn({
+        config,
+        agentId,
+        channelId,
+        workspaceDir,
+        chatBridgePath,
+        serverUrl: this.serverUrl,
+        machineApiKey: this.machineApiKey,
+        prompt: startupPrompt,
+      });
 
-    if (config.mysqlAccess) {
-      const mysqlServerPath = new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname;
-      const agentEnv = config.envVars ?? {};
-      mcpServers['mysql'] = {
-        command: 'node',
-        args: [mysqlServerPath],
-        env: {
-          DB_HOST:     process.env.DB_HOST      ?? '',
-          DB_PORT:     process.env.DB_PORT      ?? '3306',
-          DB_USER:     process.env.DB_USER      ?? '',
-          DB_PASSWORD: process.env.DB_PASSWORD  ?? '',
-          DB_NAME:     agentEnv.MYSQL_DB ?? process.env.DB_NAME ?? '',
+      console.log(`[AgentManager] Spawning codex for ${agentId} channel=${channelId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
+
+      proc = spawn('codex', codexSpawn.args, {
+        cwd: workspaceDir,
+        env: codexSpawn.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      this.agents.set(key, {
+        config, channelId, agentId, sessionId: config.sessionId ?? null, proc,
+        runtime: 'codex',
+      });
+      this.starting.delete(key);
+
+      let buffer = '';
+      proc.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          this._parseCodexLine(key, agentId, channelId, line, connection);
+        }
+      });
+    } else {
+      // ── Claude CLI (default) ──────────────────────────────────────────────
+      const mcpServers = {
+        chat: {
+          command: 'node',
+          args: [chatBridgePath],
+          env: {
+            SERVER_URL: this.serverUrl,
+            MACHINE_API_KEY: this.machineApiKey,
+            AGENT_ID: agentId,
+            CHANNEL_ID: channelId ?? '',
+          },
         },
       };
-    }
 
-    const mcpConfig = { mcpServers };
-
-    const args = [
-      '--allow-dangerously-skip-permissions',
-      '--dangerously-skip-permissions',
-      '--verbose',
-      '--output-format', 'stream-json',
-      '--input-format', 'stream-json',
-      '--mcp-config', JSON.stringify(mcpConfig),
-      '--system-prompt', buildSystemPrompt(config, agentId),
-      '--disallowed-tools', 'EnterPlanMode,ExitPlanMode',
-    ];
-
-    if (config.sessionId) {
-      args.push('--resume', config.sessionId);
-    }
+      if (config.browserAccess) {
+        mcpServers['chrome-devtools'] = {
+          command: 'npx',
+          args: ['chrome-devtools-mcp@latest', '--headless'],
+          env: {},
+        };
+      }
 
-    const spawnEnv = { ...process.env, FORCE_COLOR: '0', ...(config.envVars ?? {}) };
-    delete spawnEnv.CLAUDECODE;
+      if (config.mysqlAccess) {
+        const mysqlServerPath = new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname;
+        const agentEnv = config.envVars ?? {};
+        mcpServers['mysql'] = {
+          command: 'node',
+          args: [mysqlServerPath],
+          env: {
+            DB_HOST:     process.env.DB_HOST      ?? '',
+            DB_PORT:     process.env.DB_PORT      ?? '3306',
+            DB_USER:     process.env.DB_USER      ?? '',
+            DB_PASSWORD: process.env.DB_PASSWORD  ?? '',
+            DB_NAME:     agentEnv.MYSQL_DB ?? process.env.DB_NAME ?? '',
+          },
+        };
+      }
 
-    console.log(`[AgentManager] Spawning claude for ${agentId} channel=${channelId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
+      const mcpConfig = { mcpServers };
+
+      const args = [
+        '--print',
+        '--allow-dangerously-skip-permissions',
+        '--dangerously-skip-permissions',
+        '--verbose',
+        '--output-format', 'stream-json',
+        '--input-format', 'stream-json',
+        '--mcp-config', JSON.stringify(mcpConfig),
+        '--system-prompt', buildSystemPrompt(config, agentId),
+        '--disallowed-tools', 'EnterPlanMode,ExitPlanMode',
+      ];
+
+      if (config.sessionId) {
+        // Only resume if the session file exists locally
+        const projectSlug = workspaceDir.replace(/[\/\.]/g, '-');
+        const sessionFile = path.join(homedir(), '.claude', 'projects', projectSlug, `${config.sessionId}.jsonl`);
+        try {
+          statSync(sessionFile);
+          args.push('--resume', config.sessionId);
+        } catch {
+          console.log(`[AgentManager] Session ${config.sessionId} not found locally, starting fresh`);
+        }
+      }
 
-    const proc = spawn('claude', args, {
-      cwd: workspaceDir,
-      env: spawnEnv,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
+      const spawnEnv = { ...process.env, FORCE_COLOR: '0', ...(config.envVars ?? {}) };
+      delete spawnEnv.CLAUDECODE;
 
-    this.agents.set(key, { config, channelId, agentId, sessionId: config.sessionId ?? null, proc });
-    this.starting.delete(key);
-
-    // Parse stdout stream for session ID and activity updates
-    let buffer = '';
-    proc.stdout.on('data', (chunk) => {
-      buffer += chunk.toString();
-      const lines = buffer.split('\n');
-      buffer = lines.pop();
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        this._parseLine(key, agentId, channelId, line, connection);
-      }
-    });
+      console.log(`[AgentManager] Spawning claude for ${agentId} channel=${channelId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
+
+      proc = spawn('claude', args, {
+        cwd: workspaceDir,
+        env: spawnEnv,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      this.agents.set(key, { config, channelId, agentId, sessionId: config.sessionId ?? null, proc, runtime: 'claude' });
+      this.starting.delete(key);
+
+      // Parse stdout stream for session ID and activity updates
+      let buffer = '';
+      proc.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          this._parseLine(key, agentId, channelId, line, connection);
+        }
+      });
+    }
 
     proc.stderr.on('data', (data) => {
       const text = data.toString().trim();
@@ -144,9 +255,16 @@ export class AgentManager {
     });
 
     proc.on('exit', (code) => {
+      const agent = this.agents.get(key);
       console.log(`[AgentManager] Agent ${agentId} channel=${channelId ?? 'none'} exited (code=${code})`);
       this.agents.delete(key);
 
+      if (code === 0 && runtime === 'codex' && this._pendingMessages?.get(key)?.length) {
+        const restartConfig = { ...config, sessionId: agent?.sessionId ?? config.sessionId ?? null };
+        this._startAgent({ agentId, channelId, config: restartConfig }, connection);
+        return;
+      }
+
       // If exited immediately with an error and had a session, retry without session (session file may not exist on this machine)
       if (code !== 0 && config.sessionId && !this._retried?.has(key)) {
         if (!this._retried) this._retried = new Set();
@@ -161,8 +279,12 @@ export class AgentManager {
       connection.send({ type: 'agent:activity', agentId, channelId, activity: 'offline', detail: '', entries: [] });
     });
 
-    // Send startup prompt — agent reads memory index first, then checks messages
-    this._write(key, 'You have just started. Follow your startup sequence: first call read_memory with path="MEMORY.md" to load your memory index, then call check_messages.');
+    // Send startup prompt
+    if (runtime === 'kimi' || runtime === 'codex') {
+      // Kimi already received its prompt via the initialize + prompt JSON-RPC messages
+    } else {
+      this._write(key, 'You have just started. Follow your startup sequence: first call read_memory with path="MEMORY.md" to load your memory index, then call check_messages.');
+    }
 
     connection.send({ type: 'agent:status', agentId, channelId, status: 'active' });
     connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
@@ -206,36 +328,58 @@ export class AgentManager {
       return;
     }
 
-    const text = `New message in ${message.channel_type === 'dm' ? `dm from` : `#${message.channel_name} from`} ${message.sender_name}: ${message.content}`;
+    const text = this._formatDeliveryText(message);
     console.log(`[AgentManager] Delivering seq=${seq} to agent ${agentId} channel=${channelId}`);
+    const agent = this.agents.get(key);
+    if (agent?.runtime === 'codex') {
+      if (!this._pendingMessages) this._pendingMessages = new Map();
+      const pending = this._pendingMessages.get(key) ?? [];
+      pending.push(msg);
+      this._pendingMessages.set(key, pending);
+      return;
+    }
     this._write(key, text);
   }
 
   _flushPending(key, connection) {
     if (!this._pendingMessages) return;
+    if (this.agents.get(key)?.runtime === 'codex') return;
     const pending = this._pendingMessages.get(key);
     if (!pending || pending.length === 0) return;
     this._pendingMessages.delete(key);
     for (const msg of pending) {
       const { agentId, channelId, seq, message } = msg;
-      const text = `New message in ${message.channel_type === 'dm' ? `dm from` : `#${message.channel_name} from`} ${message.sender_name}: ${message.content}`;
+      const text = this._formatDeliveryText(message);
       console.log(`[AgentManager] Flushing queued seq=${seq} to agent ${agentId} channel=${channelId}`);
       this._write(key, text);
     }
   }
 
-  // Write a user message to the running Claude process via stdin
+  // Write a user message to the running agent process via stdin
   _write(key, text) {
     const agent = this.agents.get(key);
     if (!agent?.proc) return;
-    const line = JSON.stringify({
-      type: 'user',
-      message: { role: 'user', content: [{ type: 'text', text }] },
-    }) + '\n';
+
+    let line;
+    if (agent.runtime === 'kimi') {
+      // Kimi uses JSON-RPC: prompt (idle) or steer (busy)
+      const mode = agent.kimiIdle ? 'idle' : 'busy';
+      agent.kimiIdle = false; // will be set back to true on TurnEnd
+      line = encodeKimiStdin(text, mode) + '\n';
+    } else if (agent.runtime === 'codex') {
+      return;
+    } else {
+      // Claude uses stream-json
+      line = JSON.stringify({
+        type: 'user',
+        message: { role: 'user', content: [{ type: 'text', text }] },
+      }) + '\n';
+    }
+
     try {
       agent.proc.stdin.write(line);
     } catch (err) {
-      console.error(`[AgentManager] stdin write error for ${agentId}:`, err.message);
+      console.error(`[AgentManager] stdin write error for ${key}:`, err.message);
     }
   }
 
@@ -250,14 +394,29 @@ export class AgentManager {
       ? this._workspaceDir(agentId, agent.channelId)
       : this._workspaceDir(agentId, channelId);
 
-    const globalDirs = [
-      path.join(home, '.claude', 'skills'),
-      path.join(home, '.claude', 'commands'),
-    ];
-    const workspaceDirs = [
-      path.join(workspaceDir, '.claude', 'skills'),
-      path.join(workspaceDir, '.claude', 'commands'),
-    ];
+    const runtime = agent?.config?.runtime ?? 'claude';
+    const skillDirs = runtime === 'codex'
+      ? {
+          global: [
+            path.join(home, '.codex', 'skills'),
+            path.join(home, '.codex', 'skills', '.system'),
+            path.join(home, '.agents', 'skills'),
+          ],
+          workspace: [
+            path.join(workspaceDir, '.codex', 'skills'),
+            path.join(workspaceDir, '.agents', 'skills'),
+          ],
+        }
+      : {
+          global: [
+            path.join(home, '.claude', 'skills'),
+            path.join(home, '.claude', 'commands'),
+          ],
+          workspace: [
+            path.join(workspaceDir, '.claude', 'skills'),
+            path.join(workspaceDir, '.claude', 'commands'),
+          ],
+        };
 
     const dedup = (skills) => {
       const seen = new Set();
@@ -272,8 +431,8 @@ export class AgentManager {
       sourcePath: s.sourcePath?.startsWith(home) ? '~' + s.sourcePath.slice(home.length) : s.sourcePath,
     }));
 
-    const global = shorten(dedup(globalDirs.flatMap(d => this._scanSkillsDir(d))));
-    const workspace = shorten(dedup(workspaceDirs.flatMap(d => this._scanSkillsDir(d))));
+    const global = shorten(dedup(skillDirs.global.flatMap(d => this._scanSkillsDir(d))));
+    const workspace = shorten(dedup(skillDirs.workspace.flatMap(d => this._scanSkillsDir(d))));
 
     connection.send({ type: 'agent:skills:list_result', agentId, requestId, global, workspace });
   }
@@ -317,6 +476,63 @@ export class AgentManager {
     return info;
   }
 
+  _parseKimiLine(key, agentId, channelId, line, connection) {
+    const agent = this.agents.get(key);
+    if (!agent) return;
+    const events = parseKimiLine(line, agent.kimiState);
+    for (const evt of events) {
+      switch (evt.kind) {
+        case 'session_init':
+          if (agent.sessionId !== evt.sessionId) {
+            agent.sessionId = evt.sessionId;
+            connection.send({ type: 'agent:session', agentId, channelId, sessionId: evt.sessionId });
+          }
+          break;
+        case 'thinking':
+          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'thinking', detail: '', entries: [] });
+          break;
+        case 'tool_call':
+          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'working', detail: evt.name, entries: [] });
+          break;
+        case 'turn_end':
+          agent.kimiIdle = true;
+          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
+          break;
+        case 'error':
+          console.error(`[AgentManager][kimi][${agentId}] Error: ${evt.message}`);
+          break;
+      }
+    }
+  }
+
+  _parseCodexLine(key, agentId, channelId, line, connection) {
+    const agent = this.agents.get(key);
+    if (!agent) return;
+    const events = parseCodexLine(line);
+    for (const evt of events) {
+      switch (evt.kind) {
+        case 'session_init':
+          if (agent.sessionId !== evt.sessionId) {
+            agent.sessionId = evt.sessionId;
+            connection.send({ type: 'agent:session', agentId, channelId, sessionId: evt.sessionId });
+          }
+          break;
+        case 'thinking':
+          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'thinking', detail: '', entries: [] });
+          break;
+        case 'tool_call':
+          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'working', detail: evt.name, entries: [] });
+          break;
+        case 'turn_end':
+          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
+          break;
+        case 'error':
+          console.error(`[AgentManager][codex][${agentId}] Error: ${evt.message}`);
+          break;
+      }
+    }
+  }
+
   _parseLine(key, agentId, channelId, line, connection) {
     let event;
     try { event = JSON.parse(line); }

package/src/chat-bridge.js

@@ -3,10 +3,16 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 
-const SERVER_URL    = process.env.SERVER_URL    ?? 'http://localhost:8777';
-const MACHINE_API_KEY = process.env.MACHINE_API_KEY ?? '';
-const AGENT_ID      = process.env.AGENT_ID      ?? '';
-const CHANNEL_ID    = process.env.CHANNEL_ID    ?? '';  // injected per-channel at spawn time
+const cliArgs = process.argv.slice(2);
+function getArg(name) {
+  const idx = cliArgs.indexOf(name);
+  return idx !== -1 && cliArgs[idx + 1] ? cliArgs[idx + 1] : '';
+}
+
+const SERVER_URL      = process.env.SERVER_URL || getArg('--server-url') || 'http://localhost:8777';
+const MACHINE_API_KEY = process.env.MACHINE_API_KEY || getArg('--auth-token') || '';
+const AGENT_ID        = process.env.AGENT_ID || getArg('--agent-id') || '';
+const CHANNEL_ID      = process.env.CHANNEL_ID || getArg('--channel-id') || '';  // injected per-channel at spawn time
 
 // Current active channelId for memory isolation (defaults to spawn-time CHANNEL_ID)
 let currentChannelId = CHANNEL_ID;
@@ -57,24 +63,100 @@ server.tool('send_message', 'Send a message to a channel, DM, or thread', {
 });
 
 // ── read_history ──────────────────────────────────────────────────────────────
-server.tool('read_history', 'Read message history from a channel', {
-  channel: z.string().describe('Target: #channel-name | dm:@agentName'),
-  limit:   z.number().optional().describe('Max messages to return (default 50)'),
+server.tool('read_history', 'Read message history from a channel, DM, or thread. Supports pagination via before/after and context jumps via around.', {
+  channel: z.string().describe('Target: #channel-name | dm:@agentName | #channel-name:shortMsgId'),
+  limit:   z.number().optional().describe('Max messages to return (default 50, max 100)'),
+  around:  z.union([z.string(), z.number()]).optional().describe('Center the result window around a messageId or seq number'),
   before:  z.number().optional().describe('Return messages before this seq'),
   after:   z.number().optional().describe('Return messages after this seq'),
-}, async ({ channel, limit, before, after }) => {
-  const params = new URLSearchParams({ channel, limit: String(limit ?? 50) });
+}, async ({ channel, limit, around, before, after }) => {
+  const params = new URLSearchParams({ channel, limit: String(Math.min(limit ?? 50, 100)) });
+  if (around != null) params.set('around', String(around));
   if (before != null) params.set('before', String(before));
   if (after  != null) params.set('after',  String(after));
   const data = await api('GET', `/history?${params}`);
   const msgs = data.messages ?? [];
   if (msgs.length === 0) return { content: [{ type: 'text', text: 'No messages found.' }] };
 
-  const text = msgs.map(m =>
-    `[seq=${m.seq}] ${m.senderName}: ${m.content}`
-    + (m.taskStatus ? ` [task #${m.taskNumber} ${m.taskStatus}]` : '')
-  ).join('\n');
-  return { content: [{ type: 'text', text }] };
+  const text = msgs.map(m => {
+    const senderType = m.senderType === 'agent' ? ' type=agent' : '';
+    const taskSuffix = m.taskStatus ? ` [task #${m.taskNumber} status=${m.taskStatus}${m.taskAssigneeId ? ` assignee=${m.taskAssigneeType}:${m.taskAssigneeId}` : ''}]` : '';
+    return `[seq=${m.seq} msg=${m.id} time=${m.createdAt}${senderType}] @${m.senderName}: ${m.content}${taskSuffix}`;
+  }).join('\n');
+
+  let footer = '';
+  if (data.has_more && msgs.length > 0) {
+    const minSeq = msgs[0].seq;
+    const maxSeq = msgs[msgs.length - 1].seq;
+    if (around) {
+      footer = `\n\n--- Use before=${minSeq} to load older or after=${maxSeq} to load newer. ---`;
+    } else if (after) {
+      footer = `\n\n--- ${msgs.length} messages shown. Use after=${maxSeq} for more. ---`;
+    } else {
+      footer = `\n\n--- ${msgs.length} messages shown. Use before=${minSeq} for older. ---`;
+    }
+  }
+
+  return { content: [{ type: 'text', text: `## History for ${channel} (${msgs.length} messages)\n\n${text}${footer}` }] };
+});
+
+// ── search_messages ──────────────────────────────────────────────────────────
+server.tool('search_messages', 'Search messages visible to you. Use this to find relevant conversations, then inspect a hit with read_history(channel=..., around=messageId).', {
+  query:   z.string().describe('Search query'),
+  channel: z.string().optional().describe('Optional target to scope the search, e.g. "#general", "dm:@richard"'),
+  limit:   z.number().optional().describe('Max results (default 10, max 20)'),
+}, async ({ query, channel, limit }) => {
+  const trimmed = query.trim();
+  if (!trimmed) return { content: [{ type: 'text', text: 'Search query cannot be empty.' }] };
+  const params = new URLSearchParams({ q: trimmed, limit: String(Math.min(limit ?? 10, 20)) });
+  if (channel) params.set('channel', channel);
+  try {
+    const data = await api('GET', `/search?${params}`);
+    if (!data.results || data.results.length === 0)
+      return { content: [{ type: 'text', text: 'No search results.' }] };
+    const formatted = data.results.map((r, i) => [
+      `[${i + 1}] msg=${r.id} seq=${r.seq} time=${r.createdAt}`,
+      `channel: #${r.channelName}`,
+      `sender: @${r.senderName}${r.senderType === 'agent' ? ' (agent)' : ''}`,
+      `content: ${r.snippet}`,
+      `next: read_history(channel="#${r.channelName}", around="${r.id}", limit=20)`,
+    ].join('\n')).join('\n\n');
+    return { content: [{ type: 'text', text: `## Search Results for "${trimmed}" (${data.results.length} results)\n\n${formatted}` }] };
+  } catch (err) {
+    return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+  }
+});
+
+// ── view_file ────────────────────────────────────────────────────────────────
+server.tool('view_file', 'Download an attached image by its attachment ID and save it locally so you can view it. Use this when messages contain image attachments.', {
+  attachment_id: z.string().describe('The attachment UUID'),
+}, async ({ attachment_id }) => {
+  try {
+    const fs = await import('fs');
+    const pathMod = await import('path');
+    const os = await import('os');
+    const cacheDir = pathMod.join(os.homedir(), '.lightcone', 'attachments');
+    fs.mkdirSync(cacheDir, { recursive: true });
+    // Check cache
+    const existing = fs.readdirSync(cacheDir).find(f => f.startsWith(attachment_id));
+    if (existing) {
+      return { content: [{ type: 'text', text: `File already cached at: ${pathMod.join(cacheDir, existing)}\n\nUse your Read tool to view this image.` }] };
+    }
+    const res = await fetch(`${SERVER_URL}/api/attachments/${attachment_id}`, {
+      headers: { 'Authorization': `Bearer ${MACHINE_API_KEY}` },
+      redirect: 'follow',
+    });
+    if (!res.ok) return { isError: true, content: [{ type: 'text', text: `Error: Failed to download attachment (${res.status})` }] };
+    const contentType = res.headers.get('content-type') || 'application/octet-stream';
+    const extMap = { 'image/jpeg': '.jpg', 'image/png': '.png', 'image/gif': '.gif', 'image/webp': '.webp' };
+    const ext = extMap[contentType] || '.bin';
+    const filePath = pathMod.join(cacheDir, `${attachment_id}${ext}`);
+    const buffer = Buffer.from(await res.arrayBuffer());
+    fs.writeFileSync(filePath, buffer);
+    return { content: [{ type: 'text', text: `Downloaded to: ${filePath}\n\nUse your Read tool to view this image.` }] };
+  } catch (err) {
+    return { isError: true, content: [{ type: 'text', text: `Error: ${err.message}` }] };
+  }
 });
 
 // ── list_server ───────────────────────────────────────────────────────────────

package/src/connection.js

@@ -1,8 +1,22 @@
 import WebSocket from 'ws';
 import os from 'os';
+import { execSync } from 'child_process';
 
 const RECONNECT_INITIAL = 1000;
 const RECONNECT_MAX = 30000;
+const KNOWN_RUNTIMES = ['claude', 'codex', 'kimi'];
+
+function detectRuntimes() {
+  const cmd = process.platform === 'win32' ? 'where' : 'which';
+  const runtimes = [];
+  for (const runtime of KNOWN_RUNTIMES) {
+    try {
+      execSync(`${cmd} ${runtime}`, { stdio: 'pipe' });
+      runtimes.push(runtime);
+    } catch {}
+  }
+  return runtimes;
+}
 
 export class DaemonConnection {
   constructor({ serverUrl, machineApiKey, onMessage }) {
@@ -58,7 +72,7 @@ export class DaemonConnection {
       type: 'ready',
       hostname: os.hostname(),
       os: `${os.platform()} ${os.arch()}`,
-      runtimes: ['claude'],
+      runtimes: detectRuntimes(),
       daemonVersion: '0.1.0',
     });
   }