@slock-ai/daemon 0.2.0 → 0.2.3

package/{src/agentProcessManager.ts → dist/index.js}

@@ -1,138 +1,214 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import { mkdir, writeFile, access, readdir, stat, readFile, rm } from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import type { AgentMessage, AgentConfig, FileNode, MachineToServerMessage, WorkspaceDirectoryInfo, TrajectoryEntry } from "@slock-ai/shared";
-
-const DATA_DIR = path.join(os.homedir(), ".slock", "agents");
-
-/** Max chars for thinking/text content in trajectory entries (sent over WebSocket) */
-const MAX_TRAJECTORY_TEXT = 2000;
-
-interface AgentProcess {
-  process: ChildProcess;
-  inbox: AgentMessage[];
-  pendingReceive: {
-    resolve: (messages: AgentMessage[]) => void;
-    timer: ReturnType<typeof setTimeout>;
-  } | null;
-  config: AgentConfig;
-  sessionId: string | null;
-  isInReceiveMessage: boolean;
-  notificationTimer: ReturnType<typeof setTimeout> | null;
-  pendingNotificationCount: number;
-}
-
-export class AgentProcessManager {
-  private agents = new Map<string, AgentProcess>();
-  private chatBridgePath: string;
-  private sendToServer: (msg: MachineToServerMessage) => void;
-  private daemonApiKey: string;
-
-  constructor(chatBridgePath: string, sendToServer: (msg: MachineToServerMessage) => void, daemonApiKey: string) {
-    this.chatBridgePath = chatBridgePath;
+#!/usr/bin/env node
+
+// src/index.ts
+import path2 from "path";
+import os2 from "os";
+import { execSync } from "child_process";
+import { accessSync } from "fs";
+import { fileURLToPath } from "url";
+
+// src/connection.ts
+import WebSocket from "ws";
+var DaemonConnection = class {
+  ws = null;
+  options;
+  reconnectTimer = null;
+  reconnectDelay = 1e3;
+  maxReconnectDelay = 3e4;
+  shouldConnect = true;
+  constructor(options) {
+    this.options = options;
+  }
+  connect() {
+    this.shouldConnect = true;
+    this.doConnect();
+  }
+  disconnect() {
+    this.shouldConnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  get connected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  doConnect() {
+    if (!this.shouldConnect) return;
+    const wsUrl = this.options.serverUrl.replace(/^http/, "ws") + `/daemon/connect?key=${this.options.apiKey}`;
+    console.log(`[Daemon] Connecting to ${this.options.serverUrl}...`);
+    this.ws = new WebSocket(wsUrl);
+    this.ws.on("open", () => {
+      console.log("[Daemon] Connected to server");
+      this.reconnectDelay = 1e3;
+      this.options.onConnect();
+    });
+    this.ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this.options.onMessage(msg);
+      } catch (err) {
+        console.error("[Daemon] Invalid message from server:", err);
+      }
+    });
+    this.ws.on("close", () => {
+      console.log("[Daemon] Disconnected from server");
+      this.options.onDisconnect();
+      this.scheduleReconnect();
+    });
+    this.ws.on("error", (err) => {
+      console.error("[Daemon] WebSocket error:", err.message);
+    });
+  }
+  scheduleReconnect() {
+    if (!this.shouldConnect) return;
+    if (this.reconnectTimer) return;
+    console.log(`[Daemon] Reconnecting in ${this.reconnectDelay}ms...`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.doConnect();
+    }, this.reconnectDelay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+  }
+};
+
+// src/agentProcessManager.ts
+import { spawn } from "child_process";
+import { mkdir, writeFile, access, readdir, stat, readFile, rm } from "fs/promises";
+import path from "path";
+import os from "os";
+var DATA_DIR = path.join(os.homedir(), ".slock", "agents");
+var MAX_TRAJECTORY_TEXT = 2e3;
+var AgentProcessManager = class {
+  agents = /* @__PURE__ */ new Map();
+  chatBridgePath;
+  sendToServer;
+  daemonApiKey;
+  constructor(chatBridgePath2, sendToServer, daemonApiKey) {
+    this.chatBridgePath = chatBridgePath2;
     this.sendToServer = sendToServer;
     this.daemonApiKey = daemonApiKey;
   }
-
-  async startAgent(agentId: string, config: AgentConfig, wakeMessage?: AgentMessage, unreadSummary?: Record<string, number>) {
+  async startAgent(agentId, config, wakeMessage, unreadSummary) {
     if (this.agents.has(agentId)) return;
-
     const agentDataDir = path.join(DATA_DIR, agentId);
     await mkdir(agentDataDir, { recursive: true });
-
-    // Create MEMORY.md if not exists
     const memoryMdPath = path.join(agentDataDir, "MEMORY.md");
     try {
       await access(memoryMdPath);
     } catch {
       const agentName = config.displayName || config.name;
-      const initialMemoryMd = `# ${agentName}\n\n## Role\n${config.description || "No role defined yet."}\n\n## Key Knowledge\n- No notes yet.\n\n## Active Context\n- First startup.\n`;
+      const initialMemoryMd = `# ${agentName}
+
+## Role
+${config.description || "No role defined yet."}
+
+## Key Knowledge
+- No notes yet.
+
+## Active Context
+- First startup.
+`;
       await writeFile(memoryMdPath, initialMemoryMd);
     }
-
     await mkdir(path.join(agentDataDir, "notes"), { recursive: true });
-
-    // Build prompt
     const isResume = !!config.sessionId;
-    let prompt: string;
+    let prompt;
     if (isResume && wakeMessage) {
-      // Format the wake message inline so the agent sees it immediately
-      const channelLabel = wakeMessage.channel_type === "dm"
-        ? `DM:@${wakeMessage.channel_name}` : `#${wakeMessage.channel_name}`;
+      const channelLabel = wakeMessage.channel_type === "dm" ? `DM:@${wakeMessage.channel_name}` : `#${wakeMessage.channel_name}`;
       const senderPrefix = wakeMessage.sender_type === "agent" ? "(agent) " : "";
       const formatted = `[${channelLabel}] ${senderPrefix}@${wakeMessage.sender_name}: ${wakeMessage.content}`;
-      prompt = `New message received:\n\n${formatted}`;
+      prompt = `New message received:
 
-      // Add unread summary for other channels (exclude the wake message's channel)
+${formatted}`;
       if (unreadSummary && Object.keys(unreadSummary).length > 0) {
         const otherUnread = Object.entries(unreadSummary).filter(([key]) => key !== channelLabel);
         if (otherUnread.length > 0) {
-          prompt += `\n\nYou also have unread messages in other channels:`;
+          prompt += `
+
+You also have unread messages in other channels:`;
           for (const [ch, count] of otherUnread) {
-            prompt += `\n- ${ch}: ${count} unread`;
+            prompt += `
+- ${ch}: ${count} unread`;
           }
-          prompt += `\n\nUse read_history to catch up, or respond to the message above first.`;
+          prompt += `
+
+Use read_history to catch up, or respond to the message above first.`;
         }
       }
+      prompt += `
 
-      prompt += `\n\nRespond as appropriate — reply using send_message, or take action as needed. Then call receive_message(block=true) to keep listening.\n\nNote: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
+Respond as appropriate \u2014 reply using send_message, or take action as needed. Then call receive_message(block=true) to keep listening.
+
+Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
     } else if (isResume && unreadSummary && Object.keys(unreadSummary).length > 0) {
-      // Resuming with unread messages (e.g. agent was stopped, messages arrived, then restarted)
       prompt = `You have unread messages from while you were offline:`;
       for (const [ch, count] of Object.entries(unreadSummary)) {
-        prompt += `\n- ${ch}: ${count} unread`;
+        prompt += `
+- ${ch}: ${count} unread`;
       }
-      prompt += `\n\nUse read_history to catch up on important channels, then call receive_message(block=true) to listen for new messages.\n\nNote: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
+      prompt += `
+
+Use read_history to catch up on important channels, then call receive_message(block=true) to listen for new messages.
+
+Note: While you are busy, you may receive [System notification: ...] messages. Finish your current step, then call receive_message to check.`;
     } else if (isResume) {
       prompt = "No new messages while you were away. Call mcp__chat__receive_message(block=true) to listen for new messages.\n\nNote: While you are busy, you may receive [System notification: ...] messages about new messages. Finish your current step, then call receive_message to check.";
     } else {
       prompt = this.buildSystemPrompt(config, agentId);
     }
-
-    // Build MCP config — point to remote server
-    // Use daemon's own API key for chat-bridge authentication with /internal/* routes
     const mcpArgs = [
-      "tsx",
       this.chatBridgePath,
-      "--agent-id", agentId,
-      "--server-url", config.serverUrl,
-      "--auth-token", config.authToken || this.daemonApiKey,
+      "--agent-id",
+      agentId,
+      "--server-url",
+      config.serverUrl,
+      "--auth-token",
+      config.authToken || this.daemonApiKey
     ];
-
+    const isTsSource = this.chatBridgePath.endsWith(".ts");
     const mcpConfig = JSON.stringify({
       mcpServers: {
         chat: {
-          command: "npx",
-          args: mcpArgs,
-        },
-      },
+          command: isTsSource ? "npx" : "node",
+          args: isTsSource ? ["tsx", ...mcpArgs] : mcpArgs
+        }
+      }
     });
-
-    const args = [
+    const args2 = [
       "--allow-dangerously-skip-permissions",
       "--dangerously-skip-permissions",
       "--verbose",
-      "--output-format", "stream-json",
-      "--input-format", "stream-json",
-      "--mcp-config", mcpConfig,
-      "--model", config.model || "sonnet",
+      "--output-format",
+      "stream-json",
+      "--input-format",
+      "stream-json",
+      "--mcp-config",
+      mcpConfig,
+      "--model",
+      config.model || "sonnet"
     ];
-
     if (config.sessionId) {
-      args.push("--resume", config.sessionId);
+      args2.push("--resume", config.sessionId);
     }
-
     const runtime = config.runtime || "claude";
     const spawnEnv = { ...process.env, FORCE_COLOR: "0" };
-    delete (spawnEnv as any).CLAUDECODE;
-    const proc = spawn(runtime, args, {
+    delete spawnEnv.CLAUDECODE;
+    const proc = spawn(runtime, args2, {
       cwd: agentDataDir,
       stdio: ["pipe", "pipe", "pipe"],
-      env: spawnEnv,
+      env: spawnEnv
     });
-
-    const agentProcess: AgentProcess = {
+    const agentProcess = {
       process: proc,
       inbox: [],
       pendingReceive: null,
@@ -140,16 +216,12 @@ export class AgentProcessManager {
       sessionId: config.sessionId || null,
       isInReceiveMessage: false,
       notificationTimer: null,
-      pendingNotificationCount: 0,
+      pendingNotificationCount: 0
     };
     this.agents.set(agentId, agentProcess);
-
-    // Send initial prompt via stdin (stream-json format)
     this.writeStdinMessage(agentProcess, prompt);
-
-    // Parse stream-json output
     let buffer = "";
-    proc.stdout?.on("data", (chunk: Buffer) => {
+    proc.stdout?.on("data", (chunk) => {
       buffer += chunk.toString();
       const lines = buffer.split("\n");
       buffer = lines.pop() || "";
@@ -158,19 +230,18 @@ export class AgentProcessManager {
         try {
           const event = JSON.parse(line);
           this.handleStreamEvent(agentId, event);
-        } catch { /* ignore */ }
+        } catch {
+        }
       }
     });
-
-    proc.stderr?.on("data", (chunk: Buffer) => {
+    proc.stderr?.on("data", (chunk) => {
       const text = chunk.toString().trim();
       if (text) console.error(`[Agent ${agentId} stderr]: ${text}`);
     });
-
     proc.on("exit", (code) => {
       console.log(`[Agent ${agentId}] Process exited with code ${code}`);
       if (this.agents.has(agentId)) {
-        const ap = this.agents.get(agentId)!;
+        const ap = this.agents.get(agentId);
         if (ap.pendingReceive) {
           clearTimeout(ap.pendingReceive.timer);
           ap.pendingReceive.resolve([]);
@@ -183,15 +254,12 @@ export class AgentProcessManager {
         this.sendToServer({ type: "agent:activity", agentId, activity: "sleeping", detail: "" });
       }
     });
-
     this.sendToServer({ type: "agent:status", agentId, status: "active" });
     this.sendToServer({ type: "agent:activity", agentId, activity: "working", detail: "Starting\u2026" });
   }
-
-  async stopAgent(agentId: string) {
+  async stopAgent(agentId) {
     const ap = this.agents.get(agentId);
     if (!ap) return;
-
     if (ap.pendingReceive) {
       clearTimeout(ap.pendingReceive.timer);
       ap.pendingReceive.resolve([]);
@@ -199,20 +267,16 @@ export class AgentProcessManager {
     if (ap.notificationTimer) {
       clearTimeout(ap.notificationTimer);
     }
-
     this.agents.delete(agentId);
     ap.process.kill("SIGTERM");
     this.sendToServer({ type: "agent:status", agentId, status: "inactive" });
     this.sendToServer({ type: "agent:activity", agentId, activity: "offline", detail: "" });
   }
-
   /** Hibernate: kill process but keep status as "sleeping" (auto-wakes on next message via --resume) */
-  sleepAgent(agentId: string) {
+  sleepAgent(agentId) {
     const ap = this.agents.get(agentId);
     if (!ap) return;
-
     console.log(`[Agent ${agentId}] Hibernating (sleeping)`);
-
     if (ap.pendingReceive) {
       clearTimeout(ap.pendingReceive.timer);
       ap.pendingReceive.resolve([]);
@@ -220,17 +284,12 @@ export class AgentProcessManager {
     if (ap.notificationTimer) {
       clearTimeout(ap.notificationTimer);
     }
-
-    // Remove from map BEFORE killing so the exit handler doesn't double-report
     this.agents.delete(agentId);
     ap.process.kill("SIGTERM");
-    // Status already set to "sleeping" by the server; don't override
   }
-
-  deliverMessage(agentId: string, message: AgentMessage) {
+  deliverMessage(agentId, message) {
     const ap = this.agents.get(agentId);
     if (!ap) return;
-
     if (ap.pendingReceive) {
       clearTimeout(ap.pendingReceive.timer);
       ap.pendingReceive.resolve([message]);
@@ -238,20 +297,16 @@ export class AgentProcessManager {
     } else {
       ap.inbox.push(message);
     }
-
-    // Stdin notification: if agent is busy (not in receive_message), notify via stdin
-    if (ap.isInReceiveMessage) return; // message will be picked up via MCP bridge
-    if (!ap.sessionId) return; // agent not initialized yet
-
+    if (ap.isInReceiveMessage) return;
+    if (!ap.sessionId) return;
     ap.pendingNotificationCount++;
     if (!ap.notificationTimer) {
       ap.notificationTimer = setTimeout(() => {
         this.sendStdinNotification(agentId);
-      }, 3000);
+      }, 3e3);
     }
   }
-
-  async resetWorkspace(agentId: string) {
+  async resetWorkspace(agentId) {
     const agentDataDir = path.join(DATA_DIR, agentId);
     try {
       await rm(agentDataDir, { recursive: true, force: true });
@@ -260,38 +315,30 @@ export class AgentProcessManager {
       console.error(`[Agent ${agentId}] Failed to delete workspace:`, err);
     }
   }
-
   async stopAll() {
     const ids = [...this.agents.keys()];
     await Promise.all(ids.map((id) => this.stopAgent(id)));
   }
-
-  getRunningAgentIds(): string[] {
+  getRunningAgentIds() {
     return [...this.agents.keys()];
   }
-
   // Machine-level workspace scanning
-
-  async scanAllWorkspaces(): Promise<WorkspaceDirectoryInfo[]> {
-    const results: WorkspaceDirectoryInfo[] = [];
+  async scanAllWorkspaces() {
+    const results = [];
     let entries;
     try {
       entries = await readdir(DATA_DIR, { withFileTypes: true });
     } catch {
-      // DATA_DIR doesn't exist yet
       return [];
     }
-
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-
       const dirPath = path.join(DATA_DIR, entry.name);
       try {
         const dirContents = await readdir(dirPath, { withFileTypes: true });
         let totalSize = 0;
-        let latestMtime = new Date(0);
+        let latestMtime = /* @__PURE__ */ new Date(0);
         let fileCount = 0;
-
         for (const item of dirContents) {
           const itemPath = path.join(dirPath, item.name);
           try {
@@ -303,23 +350,23 @@ export class AgentProcessManager {
             if (info.mtime > latestMtime) {
               latestMtime = info.mtime;
             }
-          } catch { continue; }
+          } catch {
+            continue;
+          }
         }
-
         results.push({
           directoryName: entry.name,
           totalSizeBytes: totalSize,
           lastModified: latestMtime.toISOString(),
-          fileCount,
+          fileCount
         });
-      } catch { continue; }
+      } catch {
+        continue;
+      }
     }
-
     return results;
   }
-
-  async deleteWorkspaceDirectory(directoryName: string): Promise<boolean> {
-    // Validate: no path traversal
+  async deleteWorkspaceDirectory(directoryName) {
     if (directoryName.includes("/") || directoryName.includes("..") || directoryName.includes("\\")) {
       return false;
     }
@@ -333,10 +380,8 @@ export class AgentProcessManager {
       return false;
     }
   }
-
   // Workspace file browsing
-
-  async getFileTree(agentId: string): Promise<FileNode[]> {
+  async getFileTree(agentId) {
     const agentDir = path.join(DATA_DIR, agentId);
     try {
       await stat(agentDir);
@@ -346,8 +391,7 @@ export class AgentProcessManager {
     const count = { n: 0 };
     return this.buildFileTree(agentDir, agentDir, count);
   }
-
-  async readFile(agentId: string, filePath: string): Promise<{ content: string | null; binary: boolean }> {
+  async readFile(agentId, filePath) {
     const agentDir = path.join(DATA_DIR, agentId);
     const resolved = path.resolve(agentDir, filePath);
     if (!resolved.startsWith(agentDir + path.sep) && resolved !== agentDir) {
@@ -355,70 +399,84 @@ export class AgentProcessManager {
     }
     const info = await stat(resolved);
     if (info.isDirectory()) throw new Error("Cannot read a directory");
-
-    const TEXT_EXTENSIONS = new Set([
-      ".md", ".txt", ".json", ".js", ".ts", ".jsx", ".tsx", ".yaml", ".yml",
-      ".toml", ".log", ".csv", ".xml", ".html", ".css", ".sh", ".py",
+    const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".md",
+      ".txt",
+      ".json",
+      ".js",
+      ".ts",
+      ".jsx",
+      ".tsx",
+      ".yaml",
+      ".yml",
+      ".toml",
+      ".log",
+      ".csv",
+      ".xml",
+      ".html",
+      ".css",
+      ".sh",
+      ".py"
     ]);
     const ext = path.extname(resolved).toLowerCase();
     if (!TEXT_EXTENSIONS.has(ext) && ext !== "") {
       return { content: null, binary: true };
     }
-    if (info.size > 1_048_576) throw new Error("File too large");
-
+    if (info.size > 1048576) throw new Error("File too large");
     const content = await readFile(resolved, "utf-8");
     return { content, binary: false };
   }
-
   // Private methods
-
   /** Write a stream-json user message to the agent's stdin */
-  private writeStdinMessage(ap: AgentProcess, text: string) {
+  writeStdinMessage(ap, text) {
     const stdinMsg = JSON.stringify({
       type: "user",
       message: {
         role: "user",
-        content: [{ type: "text", text }],
+        content: [{ type: "text", text }]
       },
-      ...(ap.sessionId ? { session_id: ap.sessionId } : {}),
+      ...ap.sessionId ? { session_id: ap.sessionId } : {}
     });
     ap.process.stdin?.write(stdinMsg + "\n");
   }
-
   /** Send a batched notification to the agent via stdin about pending messages */
-  private sendStdinNotification(agentId: string) {
+  sendStdinNotification(agentId) {
     const ap = this.agents.get(agentId);
     if (!ap) return;
-
     const count = ap.pendingNotificationCount;
     ap.pendingNotificationCount = 0;
     ap.notificationTimer = null;
-
     if (count === 0) return;
-    if (ap.isInReceiveMessage) return; // agent entered receive during batch window
+    if (ap.isInReceiveMessage) return;
     if (!ap.sessionId) return;
-
     const notification = `[System notification: You have ${count} new message${count > 1 ? "s" : ""} waiting. Call receive_message to read ${count > 1 ? "them" : "it"} when you're ready.]`;
     console.log(`[Agent ${agentId}] Sending stdin notification: ${count} message(s)`);
     this.writeStdinMessage(ap, notification);
   }
-
-  private async buildFileTree(dir: string, rootDir: string, count: { n: number }): Promise<FileNode[]> {
+  async buildFileTree(dir, rootDir, count) {
     let entries;
-    try { entries = await readdir(dir, { withFileTypes: true }); } catch { return []; }
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
     entries.sort((a, b) => {
       if (a.isDirectory() && !b.isDirectory()) return -1;
       if (!a.isDirectory() && b.isDirectory()) return 1;
       return a.name.localeCompare(b.name);
     });
-    const nodes: FileNode[] = [];
+    const nodes = [];
     for (const entry of entries) {
       if (count.n >= 500) break;
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
       const fullPath = path.join(dir, entry.name);
       const relativePath = path.relative(rootDir, fullPath);
       let info;
-      try { info = await stat(fullPath); } catch { continue; }
+      try {
+        info = await stat(fullPath);
+      } catch {
+        continue;
+      }
       count.n++;
       if (entry.isDirectory()) {
         const children = await this.buildFileTree(fullPath, rootDir, count);
@@ -429,12 +487,10 @@ export class AgentProcessManager {
     }
     return nodes;
   }
-
-  private handleStreamEvent(agentId: string, event: any) {
-    const trajectory: TrajectoryEntry[] = [];
+  handleStreamEvent(agentId, event) {
+    const trajectory = [];
     let activity = "";
     let detail = "";
-
     switch (event.type) {
       case "system":
         if (event.subtype === "init" && event.session_id) {
@@ -443,22 +499,15 @@ export class AgentProcessManager {
           this.sendToServer({ type: "agent:session", agentId, sessionId: event.session_id });
         }
         break;
-
       case "assistant": {
-        // Claude CLI stream-json emits one "assistant" per turn with full message.content array.
-        // Each content block is complete (thinking, text, or tool_use).
         const content = event.message?.content;
         if (Array.isArray(content)) {
           for (const block of content) {
             if (block.type === "thinking" && block.thinking) {
-              const text = block.thinking.length > MAX_TRAJECTORY_TEXT
-                ? block.thinking.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026"
-                : block.thinking;
+              const text = block.thinking.length > MAX_TRAJECTORY_TEXT ? block.thinking.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : block.thinking;
               trajectory.push({ kind: "thinking", text });
             } else if (block.type === "text" && block.text) {
-              const text = block.text.length > MAX_TRAJECTORY_TEXT
-                ? block.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026"
-                : block.text;
+              const text = block.text.length > MAX_TRAJECTORY_TEXT ? block.text.slice(0, MAX_TRAJECTORY_TEXT) + "\u2026" : block.text;
               trajectory.push({ kind: "text", text });
             } else if (block.type === "tool_use") {
               const toolName = block.name || "unknown_tool";
@@ -467,10 +516,8 @@ export class AgentProcessManager {
             }
           }
         }
-
-        // High-level activity status + track isInReceiveMessage
         const ap = this.agents.get(agentId);
-        const toolUses = Array.isArray(content) ? content.filter((c: any) => c.type === "tool_use") : [];
+        const toolUses = Array.isArray(content) ? content.filter((c) => c.type === "tool_use") : [];
         if (toolUses.length > 0) {
           const lastTool = toolUses[toolUses.length - 1];
           const toolName = lastTool.name || "tool";
@@ -478,7 +525,6 @@ export class AgentProcessManager {
             activity = "online";
             if (ap) {
               ap.isInReceiveMessage = true;
-              // Agent is now waiting for messages via MCP bridge — clear notification state
               ap.pendingNotificationCount = 0;
               if (ap.notificationTimer) {
                 clearTimeout(ap.notificationTimer);
@@ -500,7 +546,6 @@ export class AgentProcessManager {
         }
         break;
       }
-
       case "result": {
         activity = "online";
         const apResult = this.agents.get(agentId);
@@ -514,21 +559,16 @@ export class AgentProcessManager {
         break;
       }
     }
-
-    // Send simple activity status (existing flow)
     if (activity) {
       this.sendToServer({ type: "agent:activity", agentId, activity, detail });
-      trajectory.push({ kind: "status", activity: activity as any, detail });
+      trajectory.push({ kind: "status", activity, detail });
     }
-
-    // Send trajectory entries (new flow)
     if (trajectory.length > 0) {
       this.sendToServer({ type: "agent:trajectory", agentId, entries: trajectory });
     }
   }
-
   /** Map raw tool names to user-friendly labels (all end with "…") */
-  private toolDisplayName(toolName: string): string {
+  toolDisplayName(toolName) {
     if (toolName.startsWith("mcp__chat__")) return "";
     if (toolName === "Read" || toolName === "read_file") return "Reading file\u2026";
     if (toolName === "Write" || toolName === "write_file") return "Writing file\u2026";
@@ -541,9 +581,8 @@ export class AgentProcessManager {
     if (toolName === "TodoWrite") return "Updating tasks\u2026";
     return `Using ${toolName.length > 20 ? toolName.slice(0, 20) + "\u2026" : toolName}\u2026`;
   }
-
   /** Extract a short human-readable summary from tool input */
-  private summarizeToolInput(toolName: string, input: any): string {
+  summarizeToolInput(toolName, input) {
     if (!input || typeof input !== "object") return "";
     try {
       if (toolName === "Read" || toolName === "read_file") return input.file_path || input.path || "";
@@ -562,24 +601,25 @@ export class AgentProcessManager {
       }
       if (toolName === "mcp__chat__read_history") return input.channel || "";
       return "";
-    } catch { return ""; }
+    } catch {
+      return "";
+    }
   }
-
-  private buildSystemPrompt(config: AgentConfig, agentId: string): string {
-    let systemPrompt = `You are "${config.displayName || config.name}", an AI agent in Slock — a collaborative platform for human-AI collaboration.
+  buildSystemPrompt(config, agentId) {
+    let systemPrompt = `You are "${config.displayName || config.name}", an AI agent in Slock \u2014 a collaborative platform for human-AI collaboration.
 
 ## Who you are
 
-You are a **long-running, persistent agent**. You are NOT a one-shot assistant — you live across many sessions. You will be started, put to sleep when idle, and woken up again when someone sends you a message. Your process may restart, but your memory persists through files in your workspace directory. Think of yourself as a team member who is always available, accumulates knowledge over time, and develops expertise through interactions.
+You are a **long-running, persistent agent**. You are NOT a one-shot assistant \u2014 you live across many sessions. You will be started, put to sleep when idle, and woken up again when someone sends you a message. Your process may restart, but your memory persists through files in your workspace directory. Think of yourself as a team member who is always available, accumulates knowledge over time, and develops expertise through interactions.
 
-## Communication — MCP tools ONLY
+## Communication \u2014 MCP tools ONLY
 
 You have MCP tools from the "chat" server. Use ONLY these for communication:
 
-1. **mcp__chat__receive_message** — Call with block=true to wait for messages. This is your main loop.
-2. **mcp__chat__send_message** — Send a message to a channel or DM.
-3. **mcp__chat__list_server** — List all channels, agents, and humans in this server.
-4. **mcp__chat__read_history** — Read past messages from a channel or DM.
+1. **mcp__chat__receive_message** \u2014 Call with block=true to wait for messages. This is your main loop.
+2. **mcp__chat__send_message** \u2014 Send a message to a channel or DM.
+3. **mcp__chat__list_server** \u2014 List all channels, agents, and humans in this server.
+4. **mcp__chat__read_history** \u2014 Read past messages from a channel or DM.
 
 CRITICAL RULES:
 - Do NOT output text directly. ALL communication goes through mcp__chat__send_message.
@@ -588,7 +628,7 @@ CRITICAL RULES:
 
 ## Startup sequence
 
-1. **Read MEMORY.md** (in your cwd). This is your memory index — it tells you what you know and where to find it.
+1. **Read MEMORY.md** (in your cwd). This is your memory index \u2014 it tells you what you know and where to find it.
 2. Follow the instructions in MEMORY.md to read any other memory files you need (e.g. channel summaries, role definitions, user preferences).
 3. Call mcp__chat__receive_message(block=true) to start listening.
 4. When you receive a message, process it and reply with mcp__chat__send_message.
@@ -606,8 +646,8 @@ The \`[...]\` prefix identifies where the message came from. Reuse it as the \`c
 ### Sending messages
 
 - **Reply to a channel**: \`send_message(channel="#channel-name", content="...")\`
-- **Reply to a DM**: \`send_message(channel="DM:@peer-name", content="...")\`  — reuse the channel value from the received message
-- **Start a NEW DM**: \`send_message(dm_to="peer-name", content="...")\`  — use the human's name from list_server (no @ prefix)
+- **Reply to a DM**: \`send_message(channel="DM:@peer-name", content="...")\`  \u2014 reuse the channel value from the received message
+- **Start a NEW DM**: \`send_message(dm_to="peer-name", content="...")\`  \u2014 use the human's name from list_server (no @ prefix)
 
 **IMPORTANT**: To reply to any message (channel or DM), always use \`channel\` with the exact identifier from the received message. Only use \`dm_to\` when you want to start a brand new DM that doesn't exist yet.
 
@@ -622,24 +662,24 @@ Call \`list_server\` to see all your channels, other agents, and humans in this
 ## @Mentions
 
 In channel group chats, you can @mention people by their unique name (e.g. "@alice" or "@bob").
-- Every human and agent has a unique \`name\` — this is their stable identifier for @mentions.
-- @mentions do not notify people outside the channel — channels are the isolation boundary.
+- Every human and agent has a unique \`name\` \u2014 this is their stable identifier for @mentions.
+- @mentions do not notify people outside the channel \u2014 channels are the isolation boundary.
 
 ## Communication style
 
 Keep the user informed. They cannot see your internal reasoning, so:
 - When you receive a task, acknowledge it and briefly outline your plan before starting.
-- For multi-step work, send short progress updates (e.g. "Working on step 2/3…").
+- For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
 - When done, summarize the result.
-- Keep updates concise — one or two sentences. Don't flood the chat.
+- Keep updates concise \u2014 one or two sentences. Don't flood the chat.
 
 ## Workspace & Memory
 
 Your working directory (cwd) is your **persistent workspace**. Everything you write here survives across sessions.
 
-### MEMORY.md — Your Memory Index (CRITICAL)
+### MEMORY.md \u2014 Your Memory Index (CRITICAL)
 
-\`MEMORY.md\` is the **entry point** to all your knowledge. It is the first file read on every startup (including after context compression). Structure it as an index that points to everything you know. This file is called \`MEMORY.md\` (not tied to any specific runtime) — keep it updated after every significant interaction or learning.
+\`MEMORY.md\` is the **entry point** to all your knowledge. It is the first file read on every startup (including after context compression). Structure it as an index that points to everything you know. This file is called \`MEMORY.md\` (not tied to any specific runtime) \u2014 keep it updated after every significant interaction or learning.
 
 \`\`\`markdown
 # <Your Name>
@@ -662,24 +702,24 @@ Your working directory (cwd) is your **persistent workspace**. Everything you wr
 
 **Actively observe and record** the following kinds of knowledge as you encounter them in conversations:
 
-1. **User preferences** — How the user likes things done, communication style, coding conventions, tool preferences, recurring patterns in their requests.
-2. **World/project context** — The project structure, tech stack, architectural decisions, team conventions, deployment patterns.
-3. **Domain knowledge** — Domain-specific terminology, conventions, best practices you learn through tasks.
-4. **Work history** — What has been done, decisions made and why, problems solved, approaches that worked or failed.
-5. **Channel context** — What each channel is about, who participates, what's being discussed, ongoing tasks per channel.
-6. **Other agents** — What other agents do, their specialties, collaboration patterns, how to work with them effectively.
+1. **User preferences** \u2014 How the user likes things done, communication style, coding conventions, tool preferences, recurring patterns in their requests.
+2. **World/project context** \u2014 The project structure, tech stack, architectural decisions, team conventions, deployment patterns.
+3. **Domain knowledge** \u2014 Domain-specific terminology, conventions, best practices you learn through tasks.
+4. **Work history** \u2014 What has been done, decisions made and why, problems solved, approaches that worked or failed.
+5. **Channel context** \u2014 What each channel is about, who participates, what's being discussed, ongoing tasks per channel.
+6. **Other agents** \u2014 What other agents do, their specialties, collaboration patterns, how to work with them effectively.
 
 ### How to organize memory
 
 - **MEMORY.md** is always the index. Keep it concise but comprehensive as a table of contents.
 - Create a \`notes/\` directory for detailed knowledge files. Use descriptive names:
-  - \`notes/user-preferences.md\` — User's preferences and conventions
-  - \`notes/channels.md\` — Summary of each channel and its purpose
-  - \`notes/work-log.md\` — Important decisions and completed work
-  - \`notes/<domain>.md\` — Domain-specific knowledge
+  - \`notes/user-preferences.md\` \u2014 User's preferences and conventions
+  - \`notes/channels.md\` \u2014 Summary of each channel and its purpose
+  - \`notes/work-log.md\` \u2014 Important decisions and completed work
+  - \`notes/<domain>.md\` \u2014 Domain-specific knowledge
 - You can also create any other files or directories for your work (scripts, notes, data, etc.)
-- **Update notes proactively** — Don't wait to be asked. When you learn something important, write it down.
-- **Keep MEMORY.md current** — After updating notes, update the index in MEMORY.md if new files were added.
+- **Update notes proactively** \u2014 Don't wait to be asked. When you learn something important, write it down.
+- **Keep MEMORY.md current** \u2014 After updating notes, update the index in MEMORY.md if new files were added.
 
 ### Compaction safety (CRITICAL)
 
@@ -692,7 +732,7 @@ Your context will be periodically compressed to stay within limits. When this ha
 
 ## Capabilities
 
-You can work with any files or tools on this computer — you are not confined to any directory.
+You can work with any files or tools on this computer \u2014 you are not confined to any directory.
 You may develop a specialized role over time through your interactions. Embrace it.
 
 ## Message Notifications
@@ -704,13 +744,151 @@ While you are busy (executing tools, thinking, etc.), new messages may arrive. W
 How to handle these:
 - **Do NOT interrupt your current work.** Finish what you're doing first.
 - After completing your current step, call \`mcp__chat__receive_message(block=false)\` to check for messages.
-- Do not ignore notifications for too long — acknowledge new messages in a timely manner.
+- Do not ignore notifications for too long \u2014 acknowledge new messages in a timely manner.
 - These notifications are batched (you won't get one per message), so the count tells you how many are waiting.`;
-
     if (config.description) {
-      systemPrompt += `\n\n## Initial role\n${config.description}. This may evolve.`;
-    }
+      systemPrompt += `
 
+## Initial role
+${config.description}. This may evolve.`;
+    }
     return systemPrompt;
   }
+};
+
+// ../shared/src/index.ts
+var RUNTIMES = [
+  { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
+  { id: "codex", displayName: "Codex CLI", binary: "codex", supported: false },
+  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: false },
+  { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: false }
+];
+
+// src/index.ts
+function detectRuntimes() {
+  const detected = [];
+  for (const rt of RUNTIMES) {
+    try {
+      execSync(`which ${rt.binary}`, { stdio: "pipe" });
+      detected.push(rt.id);
+    } catch {
+    }
+  }
+  return detected;
 }
+var args = process.argv.slice(2);
+var serverUrl = "";
+var apiKey = "";
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
+  if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
+}
+if (!serverUrl || !apiKey) {
+  console.error("Usage: slock-daemon --server-url <url> --api-key <key>");
+  process.exit(1);
+}
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var chatBridgePath = path2.resolve(__dirname, "chat-bridge.js");
+try {
+  accessSync(chatBridgePath);
+} catch {
+  chatBridgePath = path2.resolve(__dirname, "chat-bridge.ts");
+}
+var connection;
+var agentManager = new AgentProcessManager(chatBridgePath, (msg) => {
+  connection.send(msg);
+}, apiKey);
+connection = new DaemonConnection({
+  serverUrl,
+  apiKey,
+  onMessage: (msg) => {
+    console.log(`[Daemon] Received: ${msg.type}`, msg.type === "ping" ? "" : JSON.stringify(msg).slice(0, 200));
+    switch (msg.type) {
+      case "agent:start":
+        console.log(`[Daemon] Starting agent ${msg.agentId} (model: ${msg.config.model}, session: ${msg.config.sessionId || "new"}${msg.wakeMessage ? ", with wake message" : ""})`);
+        agentManager.startAgent(msg.agentId, msg.config, msg.wakeMessage, msg.unreadSummary);
+        break;
+      case "agent:stop":
+        console.log(`[Daemon] Stopping agent ${msg.agentId}`);
+        agentManager.stopAgent(msg.agentId);
+        break;
+      case "agent:sleep":
+        console.log(`[Daemon] Sleeping agent ${msg.agentId}`);
+        agentManager.sleepAgent(msg.agentId);
+        break;
+      case "agent:reset-workspace":
+        console.log(`[Daemon] Resetting workspace for agent ${msg.agentId}`);
+        agentManager.resetWorkspace(msg.agentId);
+        break;
+      case "agent:deliver":
+        console.log(`[Daemon] Delivering message to ${msg.agentId}: ${msg.message.content.slice(0, 80)}`);
+        agentManager.deliverMessage(msg.agentId, msg.message);
+        connection.send({ type: "agent:deliver:ack", agentId: msg.agentId, seq: msg.seq });
+        break;
+      case "agent:workspace:list":
+        agentManager.getFileTree(msg.agentId).then((files) => {
+          connection.send({ type: "agent:workspace:file_tree", agentId: msg.agentId, files });
+        });
+        break;
+      case "agent:workspace:read":
+        agentManager.readFile(msg.agentId, msg.path).then(({ content, binary }) => {
+          connection.send({
+            type: "agent:workspace:file_content",
+            agentId: msg.agentId,
+            requestId: msg.requestId,
+            content,
+            binary
+          });
+        }).catch(() => {
+          connection.send({
+            type: "agent:workspace:file_content",
+            agentId: msg.agentId,
+            requestId: msg.requestId,
+            content: null,
+            binary: false
+          });
+        });
+        break;
+      case "machine:workspace:scan":
+        console.log("[Daemon] Scanning all workspace directories");
+        agentManager.scanAllWorkspaces().then((directories) => {
+          connection.send({ type: "machine:workspace:scan_result", directories });
+        });
+        break;
+      case "machine:workspace:delete":
+        console.log(`[Daemon] Deleting workspace directory: ${msg.directoryName}`);
+        agentManager.deleteWorkspaceDirectory(msg.directoryName).then((success) => {
+          connection.send({ type: "machine:workspace:delete_result", directoryName: msg.directoryName, success });
+        });
+        break;
+      case "ping":
+        connection.send({ type: "pong" });
+        break;
+    }
+  },
+  onConnect: () => {
+    const runtimes = detectRuntimes();
+    console.log(`[Daemon] Detected runtimes: ${runtimes.join(", ") || "none"}`);
+    connection.send({
+      type: "ready",
+      capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
+      runtimes,
+      runningAgents: agentManager.getRunningAgentIds(),
+      hostname: os2.hostname(),
+      os: `${os2.platform()} ${os2.arch()}`
+    });
+  },
+  onDisconnect: () => {
+    console.log("[Daemon] Lost connection \u2014 agents continue running locally");
+  }
+});
+console.log("[Slock Daemon] Starting...");
+connection.connect();
+var shutdown = async () => {
+  console.log("[Slock Daemon] Shutting down...");
+  await agentManager.stopAll();
+  connection.disconnect();
+  process.exit(0);
+};
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);