@hengyuliu/agenthub-daemon 0.1.0

package/dist/index.js

@@ -0,0 +1,1112 @@
+#!/usr/bin/env node
+
+// src/daemon-core.ts
+import { hostname, platform } from "os";
+import { homedir as homedir3 } from "os";
+import { mkdirSync, readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as joinPath3 } from "path";
+import { randomUUID } from "crypto";
+
+// src/ws-client.ts
+import WebSocket from "ws";
+
+// ../shared/src/index.ts
+import { z } from "zod";
+var RuntimeKind = z.enum(["claude", "codex", "cursor", "gemini", "manual"]);
+var AgentStatus = z.enum(["hot", "cold", "offline"]);
+var TeamKind = z.enum(["personal", "workspace"]);
+var TeamMemberRole = z.enum(["owner", "admin", "member", "viewer"]);
+var SubjectKind = z.enum(["human", "agent", "session"]);
+var Team = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  kind: TeamKind,
+  createdBy: z.string(),
+  createdAt: z.string()
+});
+var TeamMember = z.object({
+  teamId: z.string(),
+  subjectKind: SubjectKind,
+  subjectId: z.string(),
+  role: TeamMemberRole,
+  joinedAt: z.string()
+});
+var ClaudeSessionInfo = z.object({
+  sessionId: z.string(),
+  // the .jsonl uuid
+  projectDir: z.string(),
+  // decoded best-effort; raw if not decodable
+  rawProjectDirName: z.string(),
+  // exact dirname under ~/.claude/projects/
+  lastModified: z.string(),
+  messageCount: z.number().int().nonnegative(),
+  sizeBytes: z.number().int().nonnegative(),
+  customTitle: z.string().nullable().default(null),
+  firstSnippet: z.string().nullable().default(null)
+});
+var Computer = z.object({
+  id: z.string(),
+  // server-generated UUID (V0.2.1)
+  ownerUserId: z.string(),
+  // who registered this computer
+  hostname: z.string(),
+  customName: z.string().nullable().default(null),
+  platform: z.string(),
+  daemonVersion: z.string(),
+  detectedRuntimes: z.array(RuntimeKind),
+  online: z.boolean(),
+  lastSeen: z.string(),
+  /** Plaintext token — only returned to the owner; hidden for non-owners. */
+  connectTokenPlaintext: z.string().nullable().default(null),
+  /** Live inventory from the daemon — NOT persisted; in-memory only. */
+  liveSessionInventory: z.array(ClaudeSessionInfo).default([])
+});
+var Session = z.object({
+  id: z.string(),
+  computerId: z.string(),
+  sessionUuid: z.string(),
+  // the .jsonl filename uuid
+  projectDir: z.string(),
+  displayName: z.string(),
+  // user-given on import
+  customTitle: z.string().nullable().default(null),
+  firstSnippet: z.string().nullable().default(null),
+  messageCount: z.number().int().nonnegative(),
+  lastModified: z.string().nullable().default(null),
+  importedBy: z.string(),
+  importedAt: z.string(),
+  parentSessionId: z.string().nullable().default(null),
+  forkPointMessageUuid: z.string().nullable().default(null),
+  forkedAt: z.string().nullable().default(null),
+  createdAt: z.string()
+});
+var Agent = z.object({
+  id: z.string(),
+  teamId: z.string(),
+  name: z.string(),
+  description: z.string().nullable().default(null),
+  rolePrompt: z.string().nullable().default(null),
+  runtime: RuntimeKind,
+  model: z.string().nullable().default(null),
+  homeComputerId: z.string(),
+  envVars: z.record(z.string()).default({}),
+  agentSessionUuid: z.string().nullable().default(null),
+  status: AgentStatus,
+  lastActive: z.string().nullable().default(null),
+  createdBy: z.string().nullable().default(null),
+  createdAt: z.string(),
+  /** Joined from agent_sessions. Always ≥ 1 (enforced by DB trigger). */
+  sourceSessionIds: z.array(z.string())
+});
+var ChannelKind = z.enum(["channel", "dm"]);
+var ChannelMemberKind = z.enum(["human", "agent", "session"]);
+var ChannelMember = z.object({
+  memberId: z.string(),
+  memberKind: ChannelMemberKind
+});
+var Channel = z.object({
+  id: z.string(),
+  // slug or "dm-<id>"
+  teamId: z.string(),
+  name: z.string(),
+  kind: ChannelKind,
+  purpose: z.string().nullable().default(null),
+  // V0.2 workspace purpose
+  members: z.array(ChannelMember).default([]),
+  /** Compatibility: agent ids extracted from members where kind='agent'. */
+  memberAgentIds: z.array(z.string()).default([]),
+  memberHumanIds: z.array(z.string()).default([]),
+  memberSessionIds: z.array(z.string()).default([]),
+  createdAt: z.string()
+});
+var MessageRole = z.enum(["human", "agent", "system"]);
+var MessageSource = z.enum([
+  "web",
+  "telegram",
+  "inter-agent",
+  "peer-query",
+  "peer-response",
+  "system",
+  "imported-history"
+]);
+var Message = z.object({
+  id: z.string(),
+  channelId: z.string(),
+  teamId: z.string(),
+  authorId: z.string(),
+  role: MessageRole,
+  source: MessageSource,
+  content: z.string(),
+  mentions: z.array(z.string()).default([]),
+  threadParentId: z.string().nullable().default(null),
+  createdAt: z.string()
+});
+var DaemonHelloFrame = z.object({
+  type: z.literal("daemon.hello"),
+  payload: z.object({
+    daemonId: z.string(),
+    hostname: z.string(),
+    platform: z.string(),
+    daemonVersion: z.string(),
+    detectedRuntimes: z.array(RuntimeKind)
+  })
+});
+var AgentStatusFrame = z.object({
+  type: z.literal("agent.status"),
+  payload: z.object({
+    agentId: z.string(),
+    status: AgentStatus
+  })
+});
+var AgentMessageFrame = z.object({
+  type: z.literal("agent.message"),
+  payload: z.object({
+    agentId: z.string(),
+    channelId: z.string(),
+    content: z.string(),
+    mentions: z.array(z.string()).default([]),
+    threadParentId: z.string().nullable().default(null)
+  })
+});
+var AgentSessionUpdateFrame = z.object({
+  type: z.literal("agent.session_update"),
+  payload: z.object({
+    agentId: z.string(),
+    resumeSessionId: z.string()
+  })
+});
+var DaemonSessionsAdvertisedFrame = z.object({
+  type: z.literal("daemon.sessions_advertised"),
+  payload: z.object({
+    daemonId: z.string(),
+    sessions: z.array(ClaudeSessionInfo)
+  })
+});
+var AgentReadHistoryRequestFrame = z.object({
+  type: z.literal("agent.read_history.request"),
+  id: z.string(),
+  payload: z.object({
+    agentId: z.string(),
+    channelId: z.string(),
+    limit: z.number().int().positive().max(200).default(50),
+    before: z.string().nullable().default(null)
+  })
+});
+var BackendHelloAckFrame = z.object({
+  type: z.literal("backend.hello_ack"),
+  payload: z.object({
+    accepted: z.boolean(),
+    reason: z.string().optional()
+  })
+});
+var RouteToAgentFrame = z.object({
+  type: z.literal("backend.route_to_agent"),
+  payload: z.object({
+    agentId: z.string(),
+    channelId: z.string(),
+    fromId: z.string(),
+    fromRole: MessageRole,
+    content: z.string(),
+    mentions: z.array(z.string()).default([])
+  })
+});
+var HistoryResponseFrame = z.object({
+  type: z.literal("backend.history.response"),
+  id: z.string(),
+  payload: z.object({
+    messages: z.array(Message)
+  })
+});
+var AgentSpawnFrame = z.object({
+  type: z.literal("backend.agent.spawn"),
+  payload: z.object({
+    agentId: z.string(),
+    runtime: RuntimeKind,
+    workspacePath: z.string().nullable(),
+    resumeSessionId: z.string().nullable(),
+    historyTargetChannelId: z.string().nullable().default(null)
+  })
+});
+var ImportedMessage = z.object({
+  role: z.enum(["human", "agent"]),
+  content: z.string(),
+  timestamp: z.string()
+});
+var DaemonSessionHistoryFrame = z.object({
+  type: z.literal("daemon.session_history"),
+  payload: z.object({
+    daemonId: z.string(),
+    agentId: z.string(),
+    channelId: z.string(),
+    messages: z.array(ImportedMessage)
+  })
+});
+var AgentStopFrame = z.object({
+  type: z.literal("backend.agent.stop"),
+  payload: z.object({
+    agentId: z.string()
+  })
+});
+var BusFrame = z.discriminatedUnion("type", [
+  DaemonHelloFrame,
+  DaemonSessionsAdvertisedFrame,
+  DaemonSessionHistoryFrame,
+  AgentSessionUpdateFrame,
+  AgentStatusFrame,
+  AgentMessageFrame,
+  AgentReadHistoryRequestFrame,
+  BackendHelloAckFrame,
+  RouteToAgentFrame,
+  HistoryResponseFrame,
+  AgentSpawnFrame,
+  AgentStopFrame
+]);
+var HumanSendMessageBody = z.object({
+  channelId: z.string(),
+  content: z.string(),
+  mentions: z.array(z.string()).default([]),
+  threadParentId: z.string().nullable().default(null)
+});
+var WebMessageEvent = z.object({
+  type: z.literal("message"),
+  payload: Message
+});
+var WebAgentStatusEvent = z.object({
+  type: z.literal("agent.status"),
+  payload: z.object({
+    agentId: z.string(),
+    status: AgentStatus
+  })
+});
+var WebComputerEvent = z.object({
+  type: z.literal("computer"),
+  payload: Computer
+});
+var WebAgentEvent = z.object({
+  type: z.literal("agent"),
+  payload: Agent
+});
+var WebChannelEvent = z.object({
+  type: z.literal("channel"),
+  payload: Channel
+});
+var WebAgentRemovedEvent = z.object({
+  type: z.literal("agent.removed"),
+  payload: z.object({ agentId: z.string() })
+});
+var WebChannelRemovedEvent = z.object({
+  type: z.literal("channel.removed"),
+  payload: z.object({ channelId: z.string() })
+});
+var WebSessionEvent = z.object({
+  type: z.literal("session"),
+  payload: Session
+});
+var WebSessionRemovedEvent = z.object({
+  type: z.literal("session.removed"),
+  payload: z.object({ sessionId: z.string() })
+});
+var WebEvent = z.discriminatedUnion("type", [
+  WebMessageEvent,
+  WebAgentStatusEvent,
+  WebComputerEvent,
+  WebAgentEvent,
+  WebChannelEvent,
+  WebAgentRemovedEvent,
+  WebChannelRemovedEvent,
+  WebSessionEvent,
+  WebSessionRemovedEvent
+]);
+var RenameComputerBody = z.object({
+  customName: z.string().min(1).max(64).nullable()
+});
+var CreateDmBody = z.object({
+  targetKind: z.enum(["agent", "session"]),
+  targetId: z.string()
+});
+var ImportSessionBody = z.object({
+  computerId: z.string(),
+  sessionUuid: z.string(),
+  projectDir: z.string(),
+  displayName: z.string(),
+  customTitle: z.string().nullable().default(null),
+  firstSnippet: z.string().nullable().default(null),
+  messageCount: z.number().int().nonnegative().default(0),
+  lastModified: z.string().nullable().default(null)
+});
+var CreateAgentBody = z.object({
+  name: z.string().min(1).max(64),
+  description: z.string().nullable().default(null),
+  rolePrompt: z.string().nullable().default(null),
+  runtime: RuntimeKind,
+  model: z.string().nullable().default(null),
+  homeComputerId: z.string(),
+  envVars: z.record(z.string()).default({}),
+  sourceSessionIds: z.array(z.string()).min(1).max(20)
+});
+var CreateChannelBody = z.object({
+  name: z.string().min(1).max(64),
+  purpose: z.string().nullable().default(null),
+  memberAgentIds: z.array(z.string()).default([]),
+  memberSessionIds: z.array(z.string()).default([])
+});
+var CreateTeamBody = z.object({
+  name: z.string().min(1).max(64)
+});
+var CreateComputerBody = z.object({
+  name: z.string().min(1).max(64)
+});
+
+// src/ws-client.ts
+var RECONNECT_DELAYS_MS = [500, 1e3, 2e3, 5e3, 1e4, 3e4];
+var WsClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  ws = null;
+  closed = false;
+  reconnectAttempt = 0;
+  start() {
+    this.connect();
+  }
+  send(frame) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify(frame));
+  }
+  stop() {
+    this.closed = true;
+    this.ws?.close();
+  }
+  connect() {
+    if (this.closed) return;
+    const url = new URL(this.opts.serverUrl);
+    url.searchParams.set("api_key", this.opts.apiKey);
+    const ws = new WebSocket(url);
+    this.ws = ws;
+    ws.on("open", () => {
+      this.reconnectAttempt = 0;
+      this.opts.onOpen?.();
+    });
+    ws.on("message", (data) => {
+      let raw;
+      try {
+        raw = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      const parsed2 = BusFrame.safeParse(raw);
+      if (!parsed2.success) return;
+      this.opts.onFrame?.(parsed2.data);
+    });
+    ws.on("close", (code, reasonBuf) => {
+      const reason = reasonBuf.toString();
+      this.opts.onClose?.(code, reason);
+      this.ws = null;
+      this.scheduleReconnect();
+    });
+    ws.on("error", () => {
+    });
+  }
+  scheduleReconnect() {
+    if (this.closed) return;
+    const idx = Math.min(this.reconnectAttempt, RECONNECT_DELAYS_MS.length - 1);
+    const delay = RECONNECT_DELAYS_MS[idx] ?? 3e4;
+    this.reconnectAttempt += 1;
+    setTimeout(() => this.connect(), delay);
+  }
+};
+
+// src/runtime-detect.ts
+import { spawn } from "child_process";
+var CANDIDATES = ["claude", "codex", "cursor", "gemini"];
+async function detectRuntimes() {
+  const results = await Promise.all(
+    CANDIDATES.map(async (name) => {
+      const ok = await new Promise((resolve) => {
+        const child = spawn("which", [name], { stdio: "ignore" });
+        child.on("exit", (code) => resolve(code === 0));
+        child.on("error", () => resolve(false));
+      });
+      return ok ? name : null;
+    })
+  );
+  return results.filter((r) => r !== null);
+}
+
+// src/agent-process.ts
+import { spawn as spawn2 } from "child_process";
+import { fileURLToPath } from "url";
+import { resolve as resolvePath, dirname } from "path";
+import { existsSync } from "fs";
+function resolveChatBridge() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const distPath = resolvePath(here, "chat-bridge.js");
+  if (existsSync(distPath)) {
+    return { command: "node", pathArg: distPath };
+  }
+  return { command: "tsx", pathArg: resolvePath(here, "chat-bridge.ts") };
+}
+function runTurn(opts) {
+  const bridge = resolveChatBridge();
+  const mcpConfig = {
+    mcpServers: {
+      chat: {
+        command: bridge.command,
+        args: [
+          bridge.pathArg,
+          "--agent-id",
+          opts.agentId,
+          "--server-url",
+          opts.serverUrl,
+          "--api-key",
+          opts.apiKey
+        ]
+      }
+    }
+  };
+  const args = [
+    "-p",
+    opts.prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--allow-dangerously-skip-permissions",
+    "--dangerously-skip-permissions",
+    "--permission-mode",
+    "bypassPermissions",
+    "--disallowed-tools",
+    "EnterPlanMode,ExitPlanMode",
+    "--mcp-config",
+    JSON.stringify(mcpConfig)
+  ];
+  if (opts.resumeSessionId) {
+    args.push("--resume", opts.resumeSessionId);
+  }
+  return new Promise((resolve) => {
+    const child = spawn2("claude", args, {
+      cwd: opts.workspacePath ?? process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdoutBuffer = "";
+    const textChunks = [];
+    let sessionId = null;
+    let errorMessage = null;
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk.toString();
+      let nl = stdoutBuffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = stdoutBuffer.slice(0, nl).trim();
+        stdoutBuffer = stdoutBuffer.slice(nl + 1);
+        if (line) handleLine(line);
+        nl = stdoutBuffer.indexOf("\n");
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      process.stderr.write(`[agent ${opts.agentId.slice(0, 8)} stderr] ${chunk.toString()}`);
+    });
+    child.on("exit", (code) => {
+      if (stdoutBuffer.trim()) handleLine(stdoutBuffer.trim());
+      resolve({
+        text: textChunks.join("").trim(),
+        sessionId,
+        exitCode: code,
+        errorMessage
+      });
+    });
+    function handleLine(line) {
+      let parsed2;
+      try {
+        parsed2 = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (!parsed2 || typeof parsed2 !== "object") return;
+      const obj = parsed2;
+      const type = obj.type;
+      if (type === "assistant") {
+        const msg = obj.message;
+        if (msg && Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text" && typeof block.text === "string") {
+              textChunks.push(block.text);
+            }
+          }
+        }
+        return;
+      }
+      if (type === "result") {
+        if (typeof obj.session_id === "string") sessionId = obj.session_id;
+        if (obj.is_error && typeof obj.result === "string") errorMessage = obj.result;
+        return;
+      }
+    }
+  });
+}
+
+// src/session-scanner.ts
+import { promises as fs } from "fs";
+import { join as joinPath } from "path";
+import { homedir } from "os";
+var CLAUDE_PROJECTS_DIR = joinPath(homedir(), ".claude", "projects");
+var READ_BUDGET_BYTES = 5 * 1024 * 1024;
+var SNIPPET_PROBE_BYTES = 64 * 1024;
+var SNIPPET_MAX_CHARS = 200;
+function decodeProjectDir(rawName) {
+  if (rawName.startsWith("-")) {
+    return "/" + rawName.slice(1).replaceAll("-", "/");
+  }
+  return rawName.replaceAll("-", "/");
+}
+function parseBuffer(buf, partialCount) {
+  let customTitle = null;
+  let snippet = null;
+  let messageCount = 0;
+  let start = 0;
+  for (let i = 0; i <= buf.length; i += 1) {
+    if (i === buf.length || buf[i] === 10) {
+      if (i > start) {
+        messageCount += 1;
+        const line = buf.toString("utf-8", start, i);
+        if (customTitle === null) {
+          const t = tryExtractCustomTitle(line);
+          if (t !== null) customTitle = t;
+        }
+        if (snippet === null) {
+          snippet = tryExtractUserText(line);
+        }
+      }
+      start = i + 1;
+    }
+  }
+  if (partialCount) messageCount = 0;
+  return { customTitle, snippet, messageCount };
+}
+function tryExtractCustomTitle(line) {
+  if (!line.includes('"custom-title"')) return null;
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  if (o.type !== "custom-title") return null;
+  const t = o.customTitle ?? o.custom_title ?? o.title;
+  if (typeof t !== "string" || !t.trim()) return null;
+  return t.trim();
+}
+function tryExtractUserText(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  if (o.type !== "user") return null;
+  const msg = o.message;
+  if (!msg || typeof msg !== "object") return null;
+  const m = msg;
+  if (m.role !== "user") return null;
+  const content = m.content;
+  let text = null;
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    const texts = [];
+    for (const block of content) {
+      if (block && typeof block === "object") {
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") texts.push(b.text);
+      }
+    }
+    if (texts.length > 0) text = texts.join(" ");
+  }
+  if (!text) return null;
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("<command-")) return null;
+  if (trimmed.startsWith("<system-reminder>")) return null;
+  if (trimmed.startsWith("Caveat:")) return null;
+  if (trimmed.startsWith("[Request interrupted")) return null;
+  return trimmed.replace(/\s+/g, " ").slice(0, SNIPPET_MAX_CHARS);
+}
+async function readSessionMeta(filePath, sizeBytes) {
+  try {
+    if (sizeBytes <= READ_BUDGET_BYTES) {
+      const buf = await fs.readFile(filePath);
+      return parseBuffer(buf, false);
+    }
+    const fd = await fs.open(filePath, "r");
+    try {
+      const buf = Buffer.alloc(Math.min(SNIPPET_PROBE_BYTES, sizeBytes));
+      await fd.read(buf, 0, buf.length, 0);
+      const partial = parseBuffer(buf, true);
+      return {
+        customTitle: partial.customTitle,
+        snippet: partial.snippet,
+        messageCount: Math.max(0, Math.round(sizeBytes / 1500))
+      };
+    } finally {
+      await fd.close();
+    }
+  } catch {
+    return { customTitle: null, snippet: null, messageCount: 0 };
+  }
+}
+async function scanClaudeSessions() {
+  let projectDirs;
+  try {
+    projectDirs = await fs.readdir(CLAUDE_PROJECTS_DIR);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const rawName of projectDirs) {
+    const dirPath = joinPath(CLAUDE_PROJECTS_DIR, rawName);
+    let dirStat;
+    try {
+      dirStat = await fs.stat(dirPath);
+    } catch {
+      continue;
+    }
+    if (!dirStat.isDirectory()) continue;
+    let files;
+    try {
+      files = await fs.readdir(dirPath);
+    } catch {
+      continue;
+    }
+    const decoded = decodeProjectDir(rawName);
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const sessionId = file.slice(0, -".jsonl".length);
+      const filePath = joinPath(dirPath, file);
+      let stat;
+      try {
+        stat = await fs.stat(filePath);
+      } catch {
+        continue;
+      }
+      const meta = await readSessionMeta(filePath, stat.size);
+      out.push({
+        sessionId,
+        projectDir: decoded,
+        rawProjectDirName: rawName,
+        lastModified: stat.mtime.toISOString(),
+        messageCount: meta.messageCount,
+        sizeBytes: stat.size,
+        customTitle: meta.customTitle,
+        firstSnippet: meta.snippet
+      });
+    }
+  }
+  out.sort((a, b) => b.lastModified.localeCompare(a.lastModified));
+  return out;
+}
+
+// src/session-reader.ts
+import { promises as fs2 } from "fs";
+import { join as joinPath2 } from "path";
+import { homedir as homedir2 } from "os";
+var CLAUDE_PROJECTS_DIR2 = joinPath2(homedir2(), ".claude", "projects");
+async function findSessionFile(sessionId) {
+  let projectDirs;
+  try {
+    projectDirs = await fs2.readdir(CLAUDE_PROJECTS_DIR2);
+  } catch {
+    return null;
+  }
+  const target = `${sessionId}.jsonl`;
+  for (const dir of projectDirs) {
+    const candidate = joinPath2(CLAUDE_PROJECTS_DIR2, dir, target);
+    try {
+      const st = await fs2.stat(candidate);
+      if (st.isFile()) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const pieces = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      pieces.push(b.text);
+    }
+  }
+  return pieces.length > 0 ? pieces.join("\n").trim() : null;
+}
+function isNoiseUserText(text) {
+  const t = text.trim();
+  if (!t) return true;
+  if (t.startsWith("<command-")) return true;
+  if (t.startsWith("<system-reminder>")) return true;
+  if (t.startsWith("Caveat:")) return true;
+  if (t.startsWith("[Request interrupted")) return true;
+  return false;
+}
+var DAEMON_PROMPT_PREFIX = /^\[#[^\]\s]+ from \w+:[a-z0-9-]{1,12}\]\s+/;
+var DAEMON_PROMPT_SUFFIX = /\n\n+Reply directly with your response text\. Do not call any tools\.\s*$/;
+function unwrapDaemonPrompt(text) {
+  const trimmedTail = text.replace(DAEMON_PROMPT_SUFFIX, "");
+  const trimmedHead = trimmedTail.replace(DAEMON_PROMPT_PREFIX, "");
+  return trimmedHead;
+}
+async function readSessionMessages(sessionId) {
+  const path = await findSessionFile(sessionId);
+  if (!path) return [];
+  let buf;
+  try {
+    buf = await fs2.readFile(path);
+  } catch {
+    return [];
+  }
+  const out = [];
+  let start = 0;
+  for (let i = 0; i <= buf.length; i += 1) {
+    if (i === buf.length || buf[i] === 10) {
+      if (i > start) {
+        const line = buf.toString("utf-8", start, i);
+        const m = parseLine(line);
+        if (m) out.push(m);
+      }
+      start = i + 1;
+    }
+  }
+  return out;
+}
+function parseLine(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  const t = o.type;
+  if (t !== "user" && t !== "assistant") return null;
+  const msg = o.message;
+  if (!msg || typeof msg !== "object") return null;
+  const m = msg;
+  const role = m.role;
+  if (role !== "user" && role !== "assistant") return null;
+  const rawText = extractText(m.content);
+  if (!rawText) return null;
+  if (role === "user" && isNoiseUserText(rawText)) return null;
+  const cleaned = role === "user" ? unwrapDaemonPrompt(rawText).trim() : rawText.trim();
+  if (!cleaned) return null;
+  const ts = typeof o.timestamp === "string" ? o.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    role: role === "user" ? "human" : "agent",
+    content: cleaned,
+    timestamp: ts
+  };
+}
+
+// src/daemon-core.ts
+var DAEMON_VERSION = "0.0.1";
+var DaemonCore = class {
+  constructor(args) {
+    this.args = args;
+    this.daemonId = args.daemonId ?? loadOrCreateDaemonId();
+  }
+  args;
+  ws = null;
+  agents = /* @__PURE__ */ new Map();
+  daemonId;
+  sessionScanTimer = null;
+  async start() {
+    const detected = await detectRuntimes();
+    process.stderr.write(
+      `[daemon] starting id=${this.daemonId} runtimes=${detected.join(",") || "(none)"}
+`
+    );
+    this.ws = new WsClient({
+      serverUrl: this.args.serverUrl,
+      apiKey: this.args.apiKey,
+      onOpen: () => this.onConnected(detected),
+      onFrame: (f) => this.onFrame(f),
+      onClose: (code, reason) => {
+        process.stderr.write(`[daemon] ws closed code=${code} reason=${reason}
+`);
+      }
+    });
+    this.ws.start();
+  }
+  async stop() {
+    if (this.sessionScanTimer) clearInterval(this.sessionScanTimer);
+    this.agents.clear();
+    this.ws?.stop();
+  }
+  onConnected(detected) {
+    process.stderr.write("[daemon] ws open, sending hello\n");
+    this.ws?.send({
+      type: "daemon.hello",
+      payload: {
+        daemonId: this.daemonId,
+        hostname: hostname(),
+        platform: platform(),
+        daemonVersion: DAEMON_VERSION,
+        detectedRuntimes: detected
+      }
+    });
+    void this.advertiseSessions();
+    if (!this.sessionScanTimer) {
+      this.sessionScanTimer = setInterval(() => {
+        void this.advertiseSessions();
+      }, 6e4);
+    }
+  }
+  async advertiseSessions() {
+    try {
+      const sessions = await scanClaudeSessions();
+      process.stderr.write(`[daemon] discovered ${sessions.length} claude session(s)
+`);
+      this.ws?.send({
+        type: "daemon.sessions_advertised",
+        payload: { daemonId: this.daemonId, sessions }
+      });
+    } catch (err) {
+      process.stderr.write(`[daemon] session scan failed: ${String(err)}
+`);
+    }
+  }
+  onFrame(frame) {
+    switch (frame.type) {
+      case "backend.hello_ack":
+        process.stderr.write(
+          `[daemon] hello_ack accepted=${frame.payload.accepted}` + (frame.payload.reason ? ` reason=${frame.payload.reason}` : "") + "\n"
+        );
+        return;
+      case "backend.agent.spawn":
+        this.handleSpawn(frame.payload);
+        return;
+      case "backend.agent.stop":
+        this.handleStop(frame.payload.agentId);
+        return;
+      case "backend.route_to_agent":
+        this.handleRouteToAgent(frame.payload);
+        return;
+      default:
+        return;
+    }
+  }
+  handleSpawn(payload) {
+    if (payload.runtime !== "claude") {
+      process.stderr.write(
+        `[daemon] runtime ${payload.runtime} not supported in V0.1 (claude only)
+`
+      );
+      return;
+    }
+    if (this.agents.has(payload.agentId)) {
+      process.stderr.write(`[daemon] agent ${payload.agentId} already registered
+`);
+      return;
+    }
+    process.stderr.write(
+      `[daemon] registered agent ${payload.agentId.slice(0, 8)} (per-turn spawn model)
+`
+    );
+    this.agents.set(payload.agentId, {
+      agentId: payload.agentId,
+      workspacePath: payload.workspacePath,
+      resumeSessionId: payload.resumeSessionId,
+      busy: false,
+      pendingPrompts: []
+    });
+    this.ws?.send({
+      type: "agent.status",
+      payload: { agentId: payload.agentId, status: "hot" }
+    });
+    if (payload.historyTargetChannelId && payload.resumeSessionId) {
+      void this.shipSessionHistory(
+        payload.agentId,
+        payload.resumeSessionId,
+        payload.historyTargetChannelId
+      );
+    }
+  }
+  async shipSessionHistory(agentId, sessionId, channelId) {
+    try {
+      const messages = await readSessionMessages(sessionId);
+      process.stderr.write(
+        `[daemon] shipping ${messages.length} historical message(s) for agent ${agentId.slice(0, 8)}
+`
+      );
+      this.ws?.send({
+        type: "daemon.session_history",
+        payload: {
+          daemonId: this.daemonId,
+          agentId,
+          channelId,
+          messages
+        }
+      });
+    } catch (err) {
+      process.stderr.write(`[daemon] session history read failed: ${String(err)}
+`);
+    }
+  }
+  handleStop(agentId) {
+    if (this.agents.delete(agentId)) {
+      this.ws?.send({
+        type: "agent.status",
+        payload: { agentId, status: "cold" }
+      });
+    }
+  }
+  handleRouteToAgent(payload) {
+    const state = this.agents.get(payload.agentId);
+    if (!state) {
+      process.stderr.write(
+        `[daemon] route_to_agent for unregistered agent ${payload.agentId}; ignoring
+`
+      );
+      return;
+    }
+    const prompt = `[#${payload.channelId} from ${payload.fromRole}:${payload.fromId.slice(0, 8)}] ${payload.content}`;
+    state.pendingPrompts.push(prompt);
+    void this.drainQueue(state, payload.channelId);
+  }
+  async drainQueue(state, channelId) {
+    if (state.busy) return;
+    state.busy = true;
+    try {
+      while (state.pendingPrompts.length > 0) {
+        const prompt = state.pendingPrompts.shift();
+        process.stderr.write(
+          `[daemon] running turn for agent ${state.agentId.slice(0, 8)} (resume=${state.resumeSessionId ?? "new"})
+`
+        );
+        const result = await runTurn({
+          agentId: state.agentId,
+          prompt,
+          resumeSessionId: state.resumeSessionId,
+          workspacePath: state.workspacePath,
+          serverUrl: this.args.serverUrl,
+          apiKey: this.args.apiKey
+        });
+        if (result.sessionId && result.sessionId !== state.resumeSessionId) {
+          state.resumeSessionId = result.sessionId;
+          this.ws?.send({
+            type: "agent.session_update",
+            payload: { agentId: state.agentId, resumeSessionId: result.sessionId }
+          });
+        }
+        process.stderr.write(
+          `[daemon] turn done agent=${state.agentId.slice(0, 8)} exit=${result.exitCode} text_len=${result.text.length}
+`
+        );
+        if (result.errorMessage) {
+          process.stderr.write(`[daemon] turn error: ${result.errorMessage}
+`);
+        }
+        if (result.text) {
+          this.ws?.send({
+            type: "agent.message",
+            payload: {
+              agentId: state.agentId,
+              channelId,
+              content: result.text,
+              mentions: [],
+              threadParentId: null
+            }
+          });
+        }
+      }
+    } finally {
+      state.busy = false;
+    }
+  }
+};
+function loadOrCreateDaemonId() {
+  const dir = joinPath3(homedir3(), ".agenthub");
+  const file = joinPath3(dir, "daemon-id");
+  try {
+    if (existsSync2(file)) {
+      const v = readFileSync(file, "utf-8").trim();
+      if (v) return v;
+    }
+    mkdirSync(dir, { recursive: true });
+    const id = randomUUID();
+    writeFileSync(file, id);
+    return id;
+  } catch {
+    return randomUUID();
+  }
+}
+
+// src/cli-args.ts
+var DAEMON_CLI_USAGE = `Usage: agenthub-daemon --server-url <url> --api-key <key> [--daemon-id <id>]
+
+  --server-url  Backend bus URL (ws:// or wss://). Required.
+  --api-key     Auth token for this daemon. Required.
+  --daemon-id   Persistent daemon identifier. Optional \u2014 auto-generated and
+                cached in ~/.agenthub/daemon-id if omitted.`;
+function parseDaemonCliArgs(argv) {
+  let serverUrl = "";
+  let apiKey = "";
+  let daemonId = null;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    switch (arg) {
+      case "--server-url":
+        if (!next) return null;
+        serverUrl = next;
+        i += 1;
+        break;
+      case "--api-key":
+        if (!next) return null;
+        apiKey = next;
+        i += 1;
+        break;
+      case "--daemon-id":
+        if (!next) return null;
+        daemonId = next;
+        i += 1;
+        break;
+      case "--help":
+      case "-h":
+        return null;
+      case "--":
+        break;
+      default:
+        if (arg && arg.startsWith("--")) return null;
+    }
+  }
+  if (!serverUrl || !apiKey) return null;
+  return { serverUrl, apiKey, daemonId };
+}
+
+// src/index.ts
+var parsed = parseDaemonCliArgs(process.argv.slice(2));
+if (!parsed) {
+  console.error(DAEMON_CLI_USAGE);
+  process.exit(1);
+}
+var daemon = new DaemonCore(parsed);
+var shutdown = async () => {
+  process.stderr.write("[daemon] shutting down\n");
+  await daemon.stop();
+  process.exit(0);
+};
+process.on("SIGTERM", () => {
+  void shutdown();
+});
+process.on("SIGINT", () => {
+  void shutdown();
+});
+void daemon.start();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hengyuliu/agenthub-daemon",
+  "version": "0.1.0",
+  "description": "AgentHub local daemon — connects your machine to AgentHub and bridges AI agent runtimes (Claude/Codex/Cursor/Gemini) to the cloud bus",
+  "type": "module",
+  "bin": {
+    "agenthub-daemon": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "tsx src/index.ts",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "agent",
+    "daemon",
+    "claude",
+    "codex",
+    "ai",
+    "agenthub"
+  ],
+  "author": "hengyuliu",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "ws": "^8.18.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@agenthub/shared": "workspace:*",
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}