@slock-ai/daemon 0.1.0

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@slock-ai/daemon",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "slock-daemon": "src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/botiverse/slock.git",
+    "directory": "packages/daemon"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "tsx": "^4.19.2",
+    "ws": "^8.18.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.12.0",
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.7.3",
+    "@slock-ai/shared": "0.1.0"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "tsx src/index.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "release:patch": "npm version patch && git push && git push --tags",
+    "release:minor": "npm version minor && git push && git push --tags",
+    "release:major": "npm version major && git push && git push --tags"
+  }
+}

package/src/agentProcessManager.ts

@@ -0,0 +1,685 @@
+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;
+    this.sendToServer = sendToServer;
+    this.daemonApiKey = daemonApiKey;
+  }
+
+  async startAgent(agentId: string, config: AgentConfig) {
+    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`;
+      await writeFile(memoryMdPath, initialMemoryMd);
+    }
+
+    await mkdir(path.join(agentDataDir, "notes"), { recursive: true });
+
+    // Build prompt
+    const isResume = !!config.sessionId;
+    const prompt = isResume
+      ? "New message waiting. Call mcp__chat__receive_message(block=true) to read it, then reply with mcp__chat__send_message. After replying, call mcp__chat__receive_message(block=true) again to keep listening for more 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."
+      : 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,
+    ];
+
+    const mcpConfig = JSON.stringify({
+      mcpServers: {
+        chat: {
+          command: "npx",
+          args: mcpArgs,
+        },
+      },
+    });
+
+    const args = [
+      "--allow-dangerously-skip-permissions",
+      "--dangerously-skip-permissions",
+      "--verbose",
+      "--output-format", "stream-json",
+      "--input-format", "stream-json",
+      "--mcp-config", mcpConfig,
+      "--model", config.model || "sonnet",
+    ];
+
+    if (config.sessionId) {
+      args.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, {
+      cwd: agentDataDir,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: spawnEnv,
+    });
+
+    const agentProcess: AgentProcess = {
+      process: proc,
+      inbox: [],
+      pendingReceive: null,
+      config,
+      sessionId: config.sessionId || null,
+      isInReceiveMessage: false,
+      notificationTimer: null,
+      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) => {
+      buffer += chunk.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          this.handleStreamEvent(agentId, event);
+        } catch { /* ignore */ }
+      }
+    });
+
+    proc.stderr?.on("data", (chunk: Buffer) => {
+      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)!;
+        if (ap.pendingReceive) {
+          clearTimeout(ap.pendingReceive.timer);
+          ap.pendingReceive.resolve([]);
+        }
+        if (ap.notificationTimer) {
+          clearTimeout(ap.notificationTimer);
+        }
+        this.agents.delete(agentId);
+        this.sendToServer({ type: "agent:status", agentId, status: "sleeping" });
+        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) {
+    const ap = this.agents.get(agentId);
+    if (!ap) return;
+
+    if (ap.pendingReceive) {
+      clearTimeout(ap.pendingReceive.timer);
+      ap.pendingReceive.resolve([]);
+    }
+    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) {
+    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([]);
+    }
+    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) {
+    const ap = this.agents.get(agentId);
+    if (!ap) return;
+
+    if (ap.pendingReceive) {
+      clearTimeout(ap.pendingReceive.timer);
+      ap.pendingReceive.resolve([message]);
+      ap.pendingReceive = null;
+    } 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
+
+    ap.pendingNotificationCount++;
+    if (!ap.notificationTimer) {
+      ap.notificationTimer = setTimeout(() => {
+        this.sendStdinNotification(agentId);
+      }, 3000);
+    }
+  }
+
+  async resetWorkspace(agentId: string) {
+    const agentDataDir = path.join(DATA_DIR, agentId);
+    try {
+      await rm(agentDataDir, { recursive: true, force: true });
+      console.log(`[Agent ${agentId}] Workspace deleted: ${agentDataDir}`);
+    } catch (err) {
+      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[] {
+    return [...this.agents.keys()];
+  }
+
+  // Machine-level workspace scanning
+
+  async scanAllWorkspaces(): Promise<WorkspaceDirectoryInfo[]> {
+    const results: WorkspaceDirectoryInfo[] = [];
+    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 fileCount = 0;
+
+        for (const item of dirContents) {
+          const itemPath = path.join(dirPath, item.name);
+          try {
+            const info = await stat(itemPath);
+            if (item.isFile()) {
+              totalSize += info.size;
+              fileCount++;
+            }
+            if (info.mtime > latestMtime) {
+              latestMtime = info.mtime;
+            }
+          } catch { continue; }
+        }
+
+        results.push({
+          directoryName: entry.name,
+          totalSizeBytes: totalSize,
+          lastModified: latestMtime.toISOString(),
+          fileCount,
+        });
+      } catch { continue; }
+    }
+
+    return results;
+  }
+
+  async deleteWorkspaceDirectory(directoryName: string): Promise<boolean> {
+    // Validate: no path traversal
+    if (directoryName.includes("/") || directoryName.includes("..") || directoryName.includes("\\")) {
+      return false;
+    }
+    const targetDir = path.join(DATA_DIR, directoryName);
+    try {
+      await rm(targetDir, { recursive: true, force: true });
+      console.log(`[Workspace] Deleted directory: ${targetDir}`);
+      return true;
+    } catch (err) {
+      console.error(`[Workspace] Failed to delete directory ${targetDir}:`, err);
+      return false;
+    }
+  }
+
+  // Workspace file browsing
+
+  async getFileTree(agentId: string): Promise<FileNode[]> {
+    const agentDir = path.join(DATA_DIR, agentId);
+    try {
+      await stat(agentDir);
+    } catch {
+      return [];
+    }
+    const count = { n: 0 };
+    return this.buildFileTree(agentDir, agentDir, count);
+  }
+
+  async readFile(agentId: string, filePath: string): Promise<{ content: string | null; binary: boolean }> {
+    const agentDir = path.join(DATA_DIR, agentId);
+    const resolved = path.resolve(agentDir, filePath);
+    if (!resolved.startsWith(agentDir + path.sep) && resolved !== agentDir) {
+      throw new Error("Access denied");
+    }
+    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 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");
+
+    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) {
+    const stdinMsg = JSON.stringify({
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "text", text }],
+      },
+      ...(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) {
+    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.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[]> {
+    let entries;
+    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[] = [];
+    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; }
+      count.n++;
+      if (entry.isDirectory()) {
+        const children = await this.buildFileTree(fullPath, rootDir, count);
+        nodes.push({ name: entry.name, path: relativePath, isDirectory: true, size: 0, modifiedAt: info.mtime.toISOString(), children });
+      } else {
+        nodes.push({ name: entry.name, path: relativePath, isDirectory: false, size: info.size, modifiedAt: info.mtime.toISOString() });
+      }
+    }
+    return nodes;
+  }
+
+  private handleStreamEvent(agentId: string, event: any) {
+    const trajectory: TrajectoryEntry[] = [];
+    let activity = "";
+    let detail = "";
+
+    switch (event.type) {
+      case "system":
+        if (event.subtype === "init" && event.session_id) {
+          const ap = this.agents.get(agentId);
+          if (ap) ap.sessionId = event.session_id;
+          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;
+              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;
+              trajectory.push({ kind: "text", text });
+            } else if (block.type === "tool_use") {
+              const toolName = block.name || "unknown_tool";
+              const inputSummary = this.summarizeToolInput(toolName, block.input);
+              trajectory.push({ kind: "tool_start", toolName, toolInput: inputSummary });
+            }
+          }
+        }
+
+        // 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") : [];
+        if (toolUses.length > 0) {
+          const lastTool = toolUses[toolUses.length - 1];
+          const toolName = lastTool.name || "tool";
+          if (toolName === "mcp__chat__receive_message") {
+            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);
+                ap.notificationTimer = null;
+              }
+            }
+          } else if (toolName === "mcp__chat__send_message") {
+            activity = "working";
+            detail = "Sending message\u2026";
+            if (ap) ap.isInReceiveMessage = false;
+          } else {
+            activity = "working";
+            detail = this.toolDisplayName(toolName);
+            if (ap) ap.isInReceiveMessage = false;
+          }
+        } else {
+          activity = "thinking";
+          if (ap) ap.isInReceiveMessage = false;
+        }
+        break;
+      }
+
+      case "result": {
+        activity = "online";
+        const apResult = this.agents.get(agentId);
+        if (apResult) {
+          apResult.isInReceiveMessage = false;
+          if (event.session_id) apResult.sessionId = event.session_id;
+        }
+        if (event.session_id) {
+          this.sendToServer({ type: "agent:session", agentId, sessionId: event.session_id });
+        }
+        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 });
+    }
+
+    // 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 {
+    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";
+    if (toolName === "Edit" || toolName === "edit_file") return "Editing file\u2026";
+    if (toolName === "Bash" || toolName === "bash") return "Running command\u2026";
+    if (toolName === "Glob" || toolName === "glob") return "Searching files\u2026";
+    if (toolName === "Grep" || toolName === "grep") return "Searching code\u2026";
+    if (toolName === "WebFetch" || toolName === "web_fetch") return "Fetching web\u2026";
+    if (toolName === "WebSearch" || toolName === "web_search") return "Searching web\u2026";
+    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 {
+    if (!input || typeof input !== "object") return "";
+    try {
+      if (toolName === "Read" || toolName === "read_file") return input.file_path || input.path || "";
+      if (toolName === "Write" || toolName === "write_file") return input.file_path || input.path || "";
+      if (toolName === "Edit" || toolName === "edit_file") return input.file_path || input.path || "";
+      if (toolName === "Bash" || toolName === "bash") {
+        const cmd = input.command || "";
+        return cmd.length > 100 ? cmd.slice(0, 100) + "\u2026" : cmd;
+      }
+      if (toolName === "Glob" || toolName === "glob") return input.pattern || "";
+      if (toolName === "Grep" || toolName === "grep") return input.pattern || "";
+      if (toolName === "WebFetch" || toolName === "web_fetch") return input.url || "";
+      if (toolName === "WebSearch" || toolName === "web_search") return input.query || "";
+      if (toolName === "mcp__chat__send_message") {
+        return input.channel || (input.dm_to ? `DM:@${input.dm_to}` : "");
+      }
+      if (toolName === "mcp__chat__read_history") return input.channel || "";
+      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 workspace 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.
+
+## Communication — 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_workspace** — List all channels, agents, and humans in the workspace.
+4. **mcp__chat__read_history** — Read past messages from a channel or DM.
+
+CRITICAL RULES:
+- Do NOT output text directly. ALL communication goes through mcp__chat__send_message.
+- Do NOT use bash/curl/sqlite to send or receive messages. The MCP tools handle everything.
+- Do NOT explore the filesystem looking for messaging scripts. The MCP tools are already available.
+
+## 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.
+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.
+5. After replying, call mcp__chat__receive_message(block=true) again to keep listening.
+
+## Messaging
+
+Messages you receive look like:
+- **Channel message from a human**: \`[#all] @richard: hello everyone\`
+- **Channel message from an agent**: \`[#all] (agent) @Alice: hi there\`
+- **DM from a human**: \`[DM:@richard] @richard: hey, can you help?\`
+
+The \`[...]\` prefix identifies where the message came from. Reuse it as the \`channel\` parameter when replying.
+
+### 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_workspace (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.
+
+### Discovering people and channels
+
+Call \`list_workspace\` to see all your channels, other agents, and humans in the workspace.
+
+### Reading history
+
+\`read_history(channel="#channel-name")\` or \`read_history(channel="DM:@peer-name")\`
+
+## @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.
+
+## 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…").
+- When done, summarize the result.
+- Keep updates concise — 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\` 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.
+
+\`\`\`markdown
+# <Your Name>
+
+## Role
+<your role definition, evolved over time>
+
+## Key Knowledge
+- Read notes/user-preferences.md for user preferences and conventions
+- Read notes/channels.md for what each channel is about and ongoing work
+- Read notes/domain.md for domain-specific knowledge and conventions
+- ...
+
+## Active Context
+- Currently working on: <brief summary>
+- Last interaction: <brief summary>
+\`\`\`
+
+### What to memorize
+
+**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.
+
+### 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
+- 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.
+
+### Compaction safety (CRITICAL)
+
+Your context will be periodically compressed to stay within limits. When this happens, you lose your in-context conversation history but MEMORY.md is always re-read. Therefore:
+
+- **MEMORY.md must be self-sufficient as a recovery point.** After reading it, you should be able to understand who you are, what you know, and what you were working on.
+- **Before a long task**, write a brief "Active Context" note in MEMORY.md so you can resume if interrupted mid-task.
+- **After completing work**, update your notes and MEMORY.md index so nothing is lost.
+- NEVER let context compression cause you to forget: which channel is about what, what tasks are in progress, what the user has asked for, or what other agents are doing.
+
+## Capabilities
+
+You can work with any files or tools on this computer — you are not confined to any directory.
+You may develop a specialized role over time through your interactions. Embrace it.
+
+## Message Notifications
+
+While you are busy (executing tools, thinking, etc.), new messages may arrive. When this happens, you will receive a system notification like:
+
+\`[System notification: You have N new message(s) waiting. Call receive_message to read them when you're ready.]\`
+
+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.
+- 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.`;
+    }
+
+    return systemPrompt;
+  }
+}

package/src/chat-bridge.ts

@@ -0,0 +1,258 @@
+#!/usr/bin/env npx tsx
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// Parse CLI args
+const args = process.argv.slice(2);
+let agentId = "";
+let serverUrl = "http://localhost:3001";
+let authToken = "";
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--agent-id" && args[i + 1]) agentId = args[++i];
+  if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
+  if (args[i] === "--auth-token" && args[i + 1]) authToken = args[++i];
+}
+
+if (!agentId) {
+  console.error("Missing --agent-id");
+  process.exit(1);
+}
+
+// Build common headers for all requests
+const commonHeaders: Record<string, string> = { "Content-Type": "application/json" };
+if (authToken) {
+  commonHeaders["Authorization"] = `Bearer ${authToken}`;
+}
+
+const server = new McpServer({
+  name: "chat",
+  version: "1.0.0",
+});
+
+// send_message tool
+server.tool(
+  "send_message",
+  "Send a message to a channel or DM. To reply, reuse the channel value from the received message (e.g. channel='#all' or channel='DM:@richard'). To start a NEW DM, use dm_to with the person's name.",
+  {
+    channel: z
+      .string()
+      .optional()
+      .describe(
+        "Where to send. Reuse the identifier from received messages: '#channel-name' for channels, 'DM:@peer-name' for DMs. Examples: '#all', '#general', 'DM:@richard'."
+      ),
+    dm_to: z
+      .string()
+      .optional()
+      .describe(
+        "Person's name to start a NEW DM with (e.g. 'richard'). Only for starting a new DM — to reply in an existing DM, use channel instead."
+      ),
+    content: z.string().describe("The message content"),
+  },
+  async ({ channel, dm_to, content }) => {
+    try {
+      const res = await fetch(`${serverUrl}/internal/agent/${agentId}/send`, {
+        method: "POST",
+        headers: commonHeaders,
+        body: JSON.stringify({ channel, dm_to, content }),
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        return {
+          content: [
+            { type: "text" as const, text: `Error: ${data.error}` },
+          ],
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Message sent to ${channel || `new DM with ${dm_to}`}`,
+          },
+        ],
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${err.message}` }],
+      };
+    }
+  }
+);
+
+// receive_message tool
+server.tool(
+  "receive_message",
+  "Receive new messages. Use block=true to wait for new messages. Returns messages formatted as [#channel-name] or [DM:@peer-name] followed by the sender and content.",
+  {
+    block: z
+      .boolean()
+      .default(true)
+      .describe("Whether to block (wait) for new messages"),
+    timeout_ms: z
+      .number()
+      .default(59000)
+      .describe("How long to wait in ms when blocking (default 59s, just under MCP tool call timeout)"),
+  },
+  async ({ block, timeout_ms }) => {
+    try {
+      const params = new URLSearchParams();
+      if (block) params.set("block", "true");
+      params.set("timeout", String(timeout_ms));
+
+      const res = await fetch(
+        `${serverUrl}/internal/agent/${agentId}/receive?${params}`,
+        { method: "GET", headers: commonHeaders }
+      );
+      const data = await res.json();
+
+      if (!data.messages || data.messages.length === 0) {
+        return {
+          content: [{ type: "text" as const, text: "No new messages." }],
+        };
+      }
+
+      // Format with human-readable channel identifiers (no UUIDs)
+      const formatted = data.messages
+        .map((m: any) => {
+          const channel = m.channel_type === "dm"
+            ? `DM:@${m.channel_name}`
+            : `#${m.channel_name}`;
+          const senderPrefix = m.sender_type === "agent" ? "(agent) " : "";
+          return `[${channel}] ${senderPrefix}@${m.sender_name}: ${m.content}`;
+        })
+        .join("\n");
+
+      return {
+        content: [{ type: "text" as const, text: formatted }],
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${err.message}` }],
+      };
+    }
+  }
+);
+
+// list_workspace tool
+server.tool(
+  "list_workspace",
+  "List all channels you are in, all agents, and all humans in the workspace. Use this to discover who and where you can message.",
+  {},
+  async () => {
+    try {
+      const res = await fetch(
+        `${serverUrl}/internal/agent/${agentId}/workspace`,
+        { method: "GET", headers: commonHeaders }
+      );
+      const data = await res.json();
+
+      let text = "## Workspace\n\n";
+
+      text += "### Your Channels\n";
+      text += "Use `#channel-name` with send_message to post in a channel.\n";
+      if (data.channels?.length > 0) {
+        for (const t of data.channels) {
+          text += `  - #${t.name}\n`;
+        }
+      } else {
+        text += "  (none)\n";
+      }
+
+      text += "\n### Agents\n";
+      text += "Other AI agents in this workspace.\n";
+      if (data.agents?.length > 0) {
+        for (const a of data.agents) {
+          text += `  - @${a.name} (${a.status})\n`;
+        }
+      } else {
+        text += "  (none)\n";
+      }
+
+      text += "\n### Humans\n";
+      text += "To start a new DM: send_message(dm_to=\"<name>\"). To reply in an existing DM: reuse channel from the received message.\n";
+      if (data.humans?.length > 0) {
+        for (const u of data.humans) {
+          text += `  - ${u.name}\n`;
+        }
+      } else {
+        text += "  (none)\n";
+      }
+
+      return {
+        content: [{ type: "text" as const, text }],
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${err.message}` }],
+      };
+    }
+  }
+);
+
+// read_history tool
+server.tool(
+  "read_history",
+  "Read message history for a channel or DM. Use #channel-name for channels or DM:@name for DMs.",
+  {
+    channel: z.string().describe("The channel to read history from — e.g. '#all', '#general', 'DM:@richard'"),
+    limit: z
+      .number()
+      .default(50)
+      .describe("Max number of messages to return (default 50, max 100)"),
+  },
+  async ({ channel, limit }) => {
+    try {
+      const params = new URLSearchParams();
+      params.set("channel", channel);
+      if (limit) params.set("limit", String(limit));
+
+      const res = await fetch(
+        `${serverUrl}/internal/agent/${agentId}/history?${params}`,
+        { method: "GET", headers: commonHeaders }
+      );
+      const data = await res.json();
+
+      if (!res.ok) {
+        return {
+          content: [
+            { type: "text" as const, text: `Error: ${data.error}` },
+          ],
+        };
+      }
+
+      if (!data.messages || data.messages.length === 0) {
+        return {
+          content: [
+            { type: "text" as const, text: "No messages in this channel." },
+          ],
+        };
+      }
+
+      const formatted = data.messages
+        .map(
+          (m: any) =>
+            `[${new Date(m.createdAt).toLocaleTimeString()}] @${m.senderName} (${m.senderType}): ${m.content}`
+        )
+        .join("\n");
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `## Message History for ${channel} (${data.messages.length} messages)\n\n${formatted}`,
+          },
+        ],
+      };
+    } catch (err: any) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${err.message}` }],
+      };
+    }
+  }
+);
+
+// Start MCP server
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/connection.ts

@@ -0,0 +1,100 @@
+import WebSocket from "ws";
+import type { ServerToMachineMessage, MachineToServerMessage } from "@slock-ai/shared";
+
+export interface ConnectionOptions {
+  serverUrl: string;
+  apiKey: string;
+  onMessage: (msg: ServerToMachineMessage) => void;
+  onConnect: () => void;
+  onDisconnect: () => void;
+}
+
+export class DaemonConnection {
+  private ws: WebSocket | null = null;
+  private options: ConnectionOptions;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private reconnectDelay = 1000;
+  private maxReconnectDelay = 30000;
+  private shouldConnect = true;
+
+  constructor(options: ConnectionOptions) {
+    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: MachineToServerMessage) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
+  get connected(): boolean {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  private 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 = 1000; // Reset backoff
+      this.options.onConnect();
+    });
+
+    this.ws.on("message", (data: Buffer) => {
+      try {
+        const msg: ServerToMachineMessage = 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);
+      // 'close' will fire after this
+    });
+  }
+
+  private 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);
+
+    // Exponential backoff
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+  }
+}

package/src/index.ts

@@ -0,0 +1,154 @@
+#!/usr/bin/env npx tsx
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { DaemonConnection } from "./connection.js";
+import { AgentProcessManager } from "./agentProcessManager.js";
+import type { ServerToMachineMessage } from "@slock-ai/shared";
+
+/** Detect which CLI runtimes are installed on this machine */
+function detectRuntimes(): string[] {
+  const detected: string[] = [];
+  for (const tool of ["claude", "codex", "kimi"]) {
+    try {
+      execSync(`which ${tool}`, { stdio: "pipe" });
+      detected.push(tool);
+    } catch { /* not installed */ }
+  }
+  return detected;
+}
+
+// Parse CLI args
+const args = process.argv.slice(2);
+let serverUrl = "";
+let 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);
+}
+
+// Resolve chat-bridge path (bundled within daemon package)
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const chatBridgePath = path.resolve(__dirname, "chat-bridge.ts");
+
+// Create connection and agent manager
+let connection: DaemonConnection;
+
+const agentManager = new AgentProcessManager(chatBridgePath, (msg) => {
+  connection.send(msg);
+}, apiKey);
+
+connection = new DaemonConnection({
+  serverUrl,
+  apiKey,
+  onMessage: (msg: ServerToMachineMessage) => {
+    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"})`);
+        agentManager.startAgent(msg.agentId, msg.config);
+        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: os.hostname(),
+      os: `${os.platform()} ${os.arch()}`,
+    });
+  },
+  onDisconnect: () => {
+    console.log("[Daemon] Lost connection — agents continue running locally");
+  },
+});
+
+console.log("[Slock Daemon] Starting...");
+connection.connect();
+
+// Graceful shutdown
+const shutdown = async () => {
+  console.log("[Slock Daemon] Shutting down...");
+  await agentManager.stopAll();
+  connection.disconnect();
+  process.exit(0);
+};
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);