svamp-cli 0.1.2 → 0.1.4

package/dist/run-DE1-CazR.mjs

@@ -0,0 +1,2100 @@
+import os from 'os';
+import fs from 'fs/promises';
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, writeFileSync as writeFileSync$1, readdirSync, mkdirSync as mkdirSync$1, unlinkSync } from 'fs';
+import { dirname, join as join$1, resolve, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { randomUUID as randomUUID$1 } from 'crypto';
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, mkdirSync, appendFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { createServer } from 'node:http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod';
+
+let connectToServerFn = null;
+async function getConnectToServer() {
+  if (!connectToServerFn) {
+    const mod = await import('hypha-rpc');
+    connectToServerFn = mod.connectToServer || mod.default && mod.default.connectToServer || mod.hyphaWebsocketClient && mod.hyphaWebsocketClient.connectToServer;
+    if (!connectToServerFn) {
+      throw new Error("Could not find connectToServer in hypha-rpc module");
+    }
+  }
+  return connectToServerFn;
+}
+async function connectToHypha(config) {
+  const connectToServer = await getConnectToServer();
+  const workspace = config.token ? parseWorkspaceFromToken(config.token) : void 0;
+  const server = await connectToServer({
+    server_url: config.serverUrl,
+    token: config.token,
+    client_id: config.clientId,
+    name: config.name || "svamp-cli",
+    workspace
+  });
+  return server;
+}
+function parseWorkspaceFromToken(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+    const scope = payload.scope || "";
+    const match = scope.match(/wid:([^\s]+)/);
+    return match ? match[1] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getHyphaServerUrl() {
+  return process.env.HYPHA_SERVER_URL || "http://localhost:9527";
+}
+
+async function registerMachineService(server, machineId, metadata, daemonState, handlers) {
+  let currentMetadata = { ...metadata };
+  let currentDaemonState = { ...daemonState };
+  let metadataVersion = 1;
+  let daemonStateVersion = 1;
+  const listeners = [];
+  const removeListener = (listener, reason) => {
+    const idx = listeners.indexOf(listener);
+    if (idx >= 0) {
+      listeners.splice(idx, 1);
+      console.log(`[HYPHA MACHINE] Listener removed (${reason}), remaining: ${listeners.length}`);
+      const rintfId = listener._rintf_service_id;
+      if (rintfId) {
+        server.unregisterService(rintfId).catch(() => {
+        });
+      }
+    }
+  };
+  const notifyListeners = (update) => {
+    for (let i = listeners.length - 1; i >= 0; i--) {
+      try {
+        const result = listeners[i].onUpdate(update);
+        if (result && typeof result.catch === "function") {
+          const listener = listeners[i];
+          result.catch((err) => {
+            console.error(`[HYPHA MACHINE] Async listener error:`, err);
+            removeListener(listener, "async error");
+          });
+        }
+      } catch (err) {
+        console.error(`[HYPHA MACHINE] Listener error:`, err);
+        removeListener(listeners[i], "sync error");
+      }
+    }
+  };
+  const serviceInfo = await server.registerService(
+    {
+      id: `svamp-machine-${machineId}`,
+      name: `Svamp Machine ${machineId}`,
+      type: "svamp-machine",
+      config: { visibility: "public" },
+      // Machine info
+      getMachineInfo: async () => ({
+        machineId,
+        metadata: currentMetadata,
+        metadataVersion,
+        daemonState: currentDaemonState,
+        daemonStateVersion
+      }),
+      // Heartbeat
+      heartbeat: async () => ({
+        time: Date.now(),
+        status: currentDaemonState.status,
+        machineId
+      }),
+      // List active sessions on this machine
+      listSessions: async () => {
+        return handlers.getTrackedSessions();
+      },
+      // Spawn a new session
+      spawnSession: async (options) => {
+        return await handlers.spawnSession({
+          ...options,
+          machineId
+        });
+      },
+      // Stop a session
+      stopSession: async (sessionId) => {
+        return handlers.stopSession(sessionId);
+      },
+      // Stop the daemon
+      stopDaemon: async () => {
+        handlers.requestShutdown();
+        return { success: true };
+      },
+      // Metadata management (with optimistic concurrency)
+      getMetadata: async () => ({
+        metadata: currentMetadata,
+        version: metadataVersion
+      }),
+      updateMetadata: async (newMetadata, expectedVersion) => {
+        if (expectedVersion !== metadataVersion) {
+          return {
+            result: "version-mismatch",
+            version: metadataVersion,
+            metadata: currentMetadata
+          };
+        }
+        currentMetadata = newMetadata;
+        metadataVersion++;
+        notifyListeners({
+          type: "update-machine",
+          machineId,
+          metadata: { value: currentMetadata, version: metadataVersion }
+        });
+        return {
+          result: "success",
+          version: metadataVersion,
+          metadata: currentMetadata
+        };
+      },
+      // Daemon state management
+      getDaemonState: async () => ({
+        daemonState: currentDaemonState,
+        version: daemonStateVersion
+      }),
+      updateDaemonState: async (newState, expectedVersion) => {
+        if (expectedVersion !== daemonStateVersion) {
+          return {
+            result: "version-mismatch",
+            version: daemonStateVersion,
+            daemonState: currentDaemonState
+          };
+        }
+        currentDaemonState = newState;
+        daemonStateVersion++;
+        notifyListeners({
+          type: "update-machine",
+          machineId,
+          daemonState: { value: currentDaemonState, version: daemonStateVersion }
+        });
+        return {
+          result: "success",
+          version: daemonStateVersion,
+          daemonState: currentDaemonState
+        };
+      },
+      // Register a listener for real-time updates (app calls this with _rintf callback)
+      registerListener: async (callback) => {
+        listeners.push(callback);
+        console.log(`[HYPHA MACHINE] Listener registered (total: ${listeners.length})`);
+        return { success: true, listenerId: listeners.length - 1 };
+      },
+      // Shell access
+      bash: async (command, cwd) => {
+        const { exec } = await import('child_process');
+        const { homedir } = await import('os');
+        return new Promise((resolve) => {
+          exec(command, { cwd: cwd || homedir(), timeout: 3e4, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+              resolve({ success: false, stdout: stdout || "", stderr: stderr || err.message, exitCode: err.code ?? 1 });
+            } else {
+              resolve({ success: true, stdout, stderr: stderr || "", exitCode: 0 });
+            }
+          });
+        });
+      },
+      // WISE voice — create ephemeral token for OpenAI Realtime API
+      wiseCreateEphemeralToken: async (params) => {
+        const apiKey = params.apiKey || process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+          return { success: false, error: "No OpenAI API key found. Set OPENAI_API_KEY or pass apiKey." };
+        }
+        try {
+          const response = await fetch("https://api.openai.com/v1/realtime/client_secrets", {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              session: {
+                type: "realtime",
+                model: params.model || "gpt-realtime-mini"
+              }
+            })
+          });
+          if (!response.ok) {
+            return { success: false, error: `OpenAI API error: ${response.status}` };
+          }
+          const result = await response.json();
+          return { success: true, clientSecret: result.value };
+        } catch (error) {
+          return { success: false, error: error instanceof Error ? error.message : "Failed to create token" };
+        }
+      }
+    },
+    { overwrite: true }
+  );
+  console.log(`[HYPHA MACHINE] Machine service registered: ${serviceInfo.id}`);
+  return {
+    serviceInfo,
+    updateMetadata: (newMetadata) => {
+      currentMetadata = newMetadata;
+      metadataVersion++;
+      notifyListeners({
+        type: "update-machine",
+        machineId,
+        metadata: { value: currentMetadata, version: metadataVersion }
+      });
+    },
+    updateDaemonState: (newState) => {
+      currentDaemonState = newState;
+      daemonStateVersion++;
+      notifyListeners({
+        type: "update-machine",
+        machineId,
+        daemonState: { value: currentDaemonState, version: daemonStateVersion }
+      });
+    },
+    disconnect: async () => {
+      await server.unregisterService(serviceInfo.id);
+    }
+  };
+}
+
+function loadMessages(messagesDir, sessionId) {
+  const filePath = join(messagesDir, `${sessionId}.messages.jsonl`);
+  if (!existsSync(filePath)) return [];
+  try {
+    const lines = readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim());
+    const messages = [];
+    for (const line of lines) {
+      try {
+        messages.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return messages.slice(-5e3);
+  } catch {
+    return [];
+  }
+}
+function appendMessage(messagesDir, sessionId, msg) {
+  const filePath = join(messagesDir, `${sessionId}.messages.jsonl`);
+  if (!existsSync(messagesDir)) {
+    mkdirSync(messagesDir, { recursive: true });
+  }
+  appendFileSync(filePath, JSON.stringify(msg) + "\n");
+}
+async function registerSessionService(server, sessionId, initialMetadata, initialAgentState, callbacks, options) {
+  const messages = options?.messagesDir ? loadMessages(options.messagesDir, sessionId) : [];
+  let nextSeq = messages.length > 0 ? messages[messages.length - 1].seq + 1 : 1;
+  let metadata = { ...initialMetadata };
+  let metadataVersion = 1;
+  let agentState = initialAgentState ? { ...initialAgentState } : null;
+  let agentStateVersion = 1;
+  let lastActivity = {
+    active: false,
+    thinking: false,
+    mode: "remote",
+    time: Date.now()
+  };
+  const listeners = [];
+  const removeListener = (listener, reason) => {
+    const idx = listeners.indexOf(listener);
+    if (idx >= 0) {
+      listeners.splice(idx, 1);
+      console.log(`[HYPHA SESSION ${sessionId}] Listener removed (${reason}), remaining: ${listeners.length}`);
+      const rintfId = listener._rintf_service_id;
+      if (rintfId) {
+        server.unregisterService(rintfId).catch(() => {
+        });
+      }
+    }
+  };
+  const notifyListeners = (update) => {
+    for (let i = listeners.length - 1; i >= 0; i--) {
+      try {
+        const result = listeners[i].onUpdate(update);
+        if (result && typeof result.catch === "function") {
+          const listener = listeners[i];
+          result.catch((err) => {
+            console.error(`[HYPHA SESSION ${sessionId}] Async listener error:`, err);
+            removeListener(listener, "async error");
+          });
+        }
+      } catch (err) {
+        console.error(`[HYPHA SESSION ${sessionId}] Listener error:`, err);
+        removeListener(listeners[i], "sync error");
+      }
+    }
+  };
+  const pushMessage = (content, role = "agent") => {
+    let wrappedContent;
+    if (role === "agent") {
+      const data = { ...content };
+      if ((data.type === "assistant" || data.type === "user") && !data.uuid) {
+        data.uuid = randomUUID();
+      }
+      wrappedContent = { role: "agent", content: { type: "output", data } };
+    } else if (role === "session") {
+      wrappedContent = { role: "session", content: { type: "session", data: content } };
+    } else {
+      const text = typeof content === "string" ? content : content?.text || content?.content || JSON.stringify(content);
+      wrappedContent = { role: "user", content: { type: "text", text } };
+    }
+    const msg = {
+      id: randomUUID(),
+      seq: nextSeq++,
+      content: wrappedContent,
+      localId: null,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    messages.push(msg);
+    if (options?.messagesDir) {
+      appendMessage(options.messagesDir, sessionId, msg);
+    }
+    notifyListeners({
+      type: "new-message",
+      sessionId,
+      message: msg
+    });
+    return msg;
+  };
+  const serviceInfo = await server.registerService(
+    {
+      id: `svamp-session-${sessionId}`,
+      name: `Svamp Session ${sessionId.slice(0, 8)}`,
+      type: "svamp-session",
+      config: { visibility: "public" },
+      // ── Messages ──
+      getMessages: async (afterSeq, limit) => {
+        const after = afterSeq ?? 0;
+        const lim = Math.min(limit ?? 100, 500);
+        const filtered = messages.filter((m) => m.seq > after);
+        const page = filtered.slice(0, lim);
+        return {
+          messages: page,
+          hasMore: filtered.length > lim
+        };
+      },
+      sendMessage: async (content, localId, meta) => {
+        if (localId) {
+          const existing = messages.find((m) => m.localId === localId);
+          if (existing) {
+            return { id: existing.id, seq: existing.seq, localId: existing.localId };
+          }
+        }
+        let parsed = content;
+        if (typeof parsed === "string") {
+          try {
+            parsed = JSON.parse(parsed);
+          } catch {
+          }
+        }
+        if (parsed && typeof parsed.content === "string" && !parsed.role) {
+          try {
+            const inner = JSON.parse(parsed.content);
+            if (inner && typeof inner === "object") parsed = inner;
+          } catch {
+          }
+        }
+        const wrappedContent = parsed && parsed.role === "user" ? { role: "user", content: parsed.content } : { role: "user", content: { type: "text", text: typeof parsed === "string" ? parsed : JSON.stringify(parsed) } };
+        const msg = {
+          id: randomUUID(),
+          seq: nextSeq++,
+          content: wrappedContent,
+          localId: localId || randomUUID(),
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        };
+        messages.push(msg);
+        if (options?.messagesDir) {
+          appendMessage(options.messagesDir, sessionId, msg);
+        }
+        notifyListeners({
+          type: "new-message",
+          sessionId,
+          message: msg
+        });
+        callbacks.onUserMessage(content, meta);
+        return { id: msg.id, seq: msg.seq, localId: msg.localId };
+      },
+      // ── Metadata ──
+      getMetadata: async () => ({
+        metadata,
+        version: metadataVersion
+      }),
+      updateMetadata: async (newMetadata, expectedVersion) => {
+        if (expectedVersion !== void 0 && expectedVersion !== metadataVersion) {
+          return {
+            result: "version-mismatch",
+            version: metadataVersion,
+            metadata
+          };
+        }
+        metadata = newMetadata;
+        metadataVersion++;
+        notifyListeners({
+          type: "update-session",
+          sessionId,
+          metadata: { value: metadata, version: metadataVersion }
+        });
+        return {
+          result: "success",
+          version: metadataVersion,
+          metadata
+        };
+      },
+      // ── Agent State ──
+      getAgentState: async () => ({
+        agentState,
+        version: agentStateVersion
+      }),
+      updateAgentState: async (newState, expectedVersion) => {
+        if (expectedVersion !== void 0 && expectedVersion !== agentStateVersion) {
+          return {
+            result: "version-mismatch",
+            version: agentStateVersion,
+            agentState
+          };
+        }
+        agentState = newState;
+        agentStateVersion++;
+        notifyListeners({
+          type: "update-session",
+          sessionId,
+          agentState: { value: agentState, version: agentStateVersion }
+        });
+        return {
+          result: "success",
+          version: agentStateVersion,
+          agentState
+        };
+      },
+      // ── Session Control RPCs ──
+      abort: async () => {
+        callbacks.onAbort();
+        return { success: true };
+      },
+      permissionResponse: async (params) => {
+        callbacks.onPermissionResponse(params);
+        return { success: true };
+      },
+      switchMode: async (mode) => {
+        callbacks.onSwitchMode(mode);
+        return { success: true };
+      },
+      restartClaude: async () => {
+        callbacks.onRestartClaude();
+        return { success: true };
+      },
+      killSession: async () => {
+        callbacks.onKillSession();
+        return { success: true };
+      },
+      // ── Activity ──
+      keepAlive: async (thinking, mode) => {
+        lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
+        notifyListeners({
+          type: "activity",
+          sessionId,
+          ...lastActivity
+        });
+      },
+      sessionEnd: async () => {
+        lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
+        notifyListeners({
+          type: "activity",
+          sessionId,
+          ...lastActivity
+        });
+      },
+      // ── Activity State Query ──
+      getActivityState: async () => {
+        return { ...lastActivity, sessionId };
+      },
+      // ── File Operations (optional) ──
+      readFile: async (path) => {
+        if (!callbacks.onReadFile) throw new Error("readFile not supported");
+        return await callbacks.onReadFile(path);
+      },
+      writeFile: async (path, content) => {
+        if (!callbacks.onWriteFile) throw new Error("writeFile not supported");
+        await callbacks.onWriteFile(path, content);
+        return { success: true };
+      },
+      listDirectory: async (path) => {
+        if (!callbacks.onListDirectory) throw new Error("listDirectory not supported");
+        return await callbacks.onListDirectory(path);
+      },
+      bash: async (command, cwd) => {
+        if (!callbacks.onBash) throw new Error("bash not supported");
+        return await callbacks.onBash(command, cwd);
+      },
+      ripgrep: async (args, cwd) => {
+        if (!callbacks.onRipgrep) throw new Error("ripgrep not supported");
+        return await callbacks.onRipgrep(args, cwd);
+      },
+      getDirectoryTree: async (path, maxDepth) => {
+        if (!callbacks.onGetDirectoryTree) throw new Error("getDirectoryTree not supported");
+        return await callbacks.onGetDirectoryTree(path, maxDepth ?? 3);
+      },
+      // ── Listener Registration ──
+      registerListener: async (callback) => {
+        listeners.push(callback);
+        console.log(`[HYPHA SESSION ${sessionId}] Listener registered (total: ${listeners.length}), replaying ${messages.length} messages`);
+        for (const msg of messages) {
+          try {
+            const result = callback.onUpdate({
+              type: "new-message",
+              sessionId,
+              message: msg
+            });
+            if (result && typeof result.catch === "function") {
+              result.catch((err) => {
+                console.error(`[HYPHA SESSION ${sessionId}] Replay listener error:`, err);
+              });
+            }
+          } catch (err) {
+            console.error(`[HYPHA SESSION ${sessionId}] Replay listener error:`, err);
+          }
+        }
+        try {
+          const result = callback.onUpdate({
+            type: "update-session",
+            sessionId,
+            metadata: { value: metadata, version: metadataVersion },
+            agentState: { value: agentState, version: agentStateVersion }
+          });
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch {
+        }
+        try {
+          const result = callback.onUpdate({
+            type: "activity",
+            sessionId,
+            ...lastActivity
+          });
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch {
+        }
+        return { success: true, listenerId: listeners.length - 1 };
+      }
+    },
+    { overwrite: true }
+  );
+  console.log(`[HYPHA SESSION] Session service registered: ${serviceInfo.id}`);
+  return {
+    serviceInfo,
+    pushMessage,
+    get _agentState() {
+      return agentState;
+    },
+    updateMetadata: (newMetadata) => {
+      metadata = newMetadata;
+      metadataVersion++;
+      notifyListeners({
+        type: "update-session",
+        sessionId,
+        metadata: { value: metadata, version: metadataVersion }
+      });
+    },
+    updateAgentState: (newAgentState) => {
+      agentState = newAgentState;
+      agentStateVersion++;
+      notifyListeners({
+        type: "update-session",
+        sessionId,
+        agentState: { value: agentState, version: agentStateVersion }
+      });
+    },
+    sendKeepAlive: (thinking, mode) => {
+      lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
+      notifyListeners({
+        type: "activity",
+        sessionId,
+        ...lastActivity
+      });
+    },
+    sendSessionEnd: () => {
+      lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
+      notifyListeners({
+        type: "activity",
+        sessionId,
+        ...lastActivity
+      });
+    },
+    disconnect: async () => {
+      await server.unregisterService(serviceInfo.id);
+    }
+  };
+}
+
+async function registerDebugService(server, machineId, deps) {
+  const serviceInfo = await server.registerService(
+    {
+      id: `svamp-debug-${machineId}`,
+      name: `Svamp Debug ${machineId.slice(0, 8)}`,
+      type: "svamp-debug",
+      config: { visibility: "public" },
+      healthCheck: async () => ({
+        ok: true,
+        machineId,
+        uptime: process.uptime(),
+        timestamp: Date.now()
+      }),
+      getSessionStates: async () => {
+        const sessions = deps.getTrackedSessions();
+        const states = [];
+        for (const s of sessions) {
+          let activityState = null;
+          try {
+            const svc = deps.getSessionService(s.sessionId);
+            if (svc) {
+              activityState = await svc.getActivityState?.();
+            }
+          } catch {
+          }
+          states.push({
+            sessionId: s.sessionId,
+            active: s.active,
+            pid: s.pid,
+            startedBy: s.startedBy,
+            directory: s.directory,
+            activityState
+          });
+        }
+        return states;
+      },
+      getMachineInfo: async () => ({
+        machineId,
+        hostname: (await import('os')).hostname(),
+        platform: (await import('os')).platform(),
+        uptime: process.uptime(),
+        sessions: deps.getTrackedSessions().length
+      }),
+      // ── Artifact Sync RPCs ──
+      getArtifactSyncStatus: async () => {
+        const sync = deps.getArtifactSync?.();
+        if (!sync) return { error: "Artifact sync not available" };
+        return sync.getStatus();
+      },
+      forceSyncAll: async () => {
+        const sync = deps.getArtifactSync?.();
+        const sessionsDir = deps.getSessionsDir?.();
+        if (!sync || !sessionsDir) return { error: "Artifact sync not available" };
+        await sync.syncAll(sessionsDir, machineId);
+        return { success: true, status: sync.getStatus() };
+      },
+      listRemoteSessions: async () => {
+        const sync = deps.getArtifactSync?.();
+        if (!sync) return [];
+        return await sync.listRemoteSessions();
+      }
+    },
+    { overwrite: true }
+  );
+  return {
+    disconnect: async () => {
+      await server.unregisterService(serviceInfo.id);
+    }
+  };
+}
+
+const COLLECTION_ALIAS = "svamp-agent-sessions";
+class SessionArtifactSync {
+  server;
+  artifactManager = null;
+  collectionId = null;
+  initialized = false;
+  syncing = false;
+  lastSyncAt = null;
+  syncedSessions = /* @__PURE__ */ new Set();
+  error = null;
+  syncTimers = /* @__PURE__ */ new Map();
+  log;
+  constructor(server, log) {
+    this.server = server;
+    this.log = log;
+  }
+  async init() {
+    try {
+      this.artifactManager = await this.server.getService("public/artifact-manager");
+      if (!this.artifactManager) {
+        this.log("[ARTIFACT SYNC] Artifact manager service not available");
+        this.error = "Artifact manager not available";
+        return;
+      }
+      await this.ensureCollection();
+      this.initialized = true;
+      this.log("[ARTIFACT SYNC] Initialized successfully");
+    } catch (err) {
+      this.error = `Init failed: ${err.message}`;
+      this.log(`[ARTIFACT SYNC] Init failed: ${err.message}`);
+    }
+  }
+  async ensureCollection() {
+    try {
+      const existing = await this.artifactManager.read({
+        artifact_id: COLLECTION_ALIAS,
+        _rkwargs: true
+      });
+      this.collectionId = existing.id;
+      this.log(`[ARTIFACT SYNC] Found existing collection: ${this.collectionId}`);
+    } catch {
+      const collection = await this.artifactManager.create({
+        alias: COLLECTION_ALIAS,
+        type: "collection",
+        manifest: {
+          name: "Svamp Agent Sessions",
+          description: "Cloud-persisted session data for cross-machine continuity"
+        },
+        _rkwargs: true
+      });
+      this.collectionId = collection.id;
+      await this.artifactManager.commit({
+        artifact_id: this.collectionId,
+        _rkwargs: true
+      });
+      this.log(`[ARTIFACT SYNC] Created new collection: ${this.collectionId}`);
+    }
+  }
+  /**
+   * Upload a file to an artifact using the presigned URL pattern:
+   * 1. put_file() returns a presigned upload URL
+   * 2. HTTP PUT the content to that URL
+   */
+  async uploadFile(artifactId, filePath, content) {
+    const putUrl = await this.artifactManager.put_file({
+      artifact_id: artifactId,
+      file_path: filePath,
+      _rkwargs: true
+    });
+    if (!putUrl || typeof putUrl !== "string") {
+      throw new Error(`put_file returned invalid URL for ${filePath}: ${putUrl}`);
+    }
+    const resp = await fetch(putUrl, {
+      method: "PUT",
+      body: content,
+      headers: { "Content-Type": "application/octet-stream" }
+    });
+    if (!resp.ok) {
+      throw new Error(`Upload failed for ${filePath}: ${resp.status} ${resp.statusText}`);
+    }
+  }
+  /**
+   * Download a file from an artifact using the presigned URL pattern:
+   * 1. get_file() returns a presigned download URL
+   * 2. HTTP GET the content from that URL
+   */
+  async downloadFile(artifactId, filePath) {
+    const getUrl = await this.artifactManager.get_file({
+      artifact_id: artifactId,
+      file_path: filePath,
+      _rkwargs: true
+    });
+    if (!getUrl || typeof getUrl !== "string") return null;
+    const resp = await fetch(getUrl);
+    if (!resp.ok) return null;
+    return await resp.text();
+  }
+  /**
+   * Sync a session's metadata and messages to the artifact store.
+   * Creates the artifact if it doesn't exist, updates if it does.
+   */
+  async syncSession(sessionId, sessionsDir, metadata, machineId) {
+    if (!this.initialized || !this.artifactManager || !this.collectionId) {
+      this.log(`[ARTIFACT SYNC] Not initialized, skipping sync for ${sessionId}`);
+      return;
+    }
+    this.syncing = true;
+    try {
+      const artifactAlias = `session-${sessionId}`;
+      const sessionJsonPath = join(sessionsDir, `${sessionId}.json`);
+      const messagesPath = join(sessionsDir, `${sessionId}.messages.jsonl`);
+      const sessionData = existsSync(sessionJsonPath) ? JSON.parse(readFileSync(sessionJsonPath, "utf-8")) : null;
+      const messagesExist = existsSync(messagesPath);
+      const messageCount = messagesExist ? readFileSync(messagesPath, "utf-8").split("\n").filter((l) => l.trim()).length : 0;
+      let artifactId;
+      try {
+        const existing = await this.artifactManager.read({
+          artifact_id: artifactAlias,
+          _rkwargs: true
+        });
+        artifactId = existing.id;
+        await this.artifactManager.edit({
+          artifact_id: artifactId,
+          manifest: {
+            sessionId,
+            machineId,
+            metadata,
+            messageCount,
+            lastSyncAt: Date.now(),
+            ...sessionData || {}
+          },
+          _rkwargs: true
+        });
+      } catch {
+        const artifact = await this.artifactManager.create({
+          alias: artifactAlias,
+          parent_id: this.collectionId,
+          type: "session",
+          manifest: {
+            sessionId,
+            machineId,
+            metadata,
+            messageCount,
+            createdAt: Date.now(),
+            lastSyncAt: Date.now(),
+            ...sessionData || {}
+          },
+          _rkwargs: true
+        });
+        artifactId = artifact.id;
+      }
+      if (sessionData) {
+        await this.uploadFile(artifactId, "session.json", JSON.stringify(sessionData, null, 2));
+      }
+      if (messagesExist) {
+        const messagesContent = readFileSync(messagesPath, "utf-8");
+        await this.uploadFile(artifactId, "messages.jsonl", messagesContent);
+      }
+      await this.artifactManager.commit({
+        artifact_id: artifactId,
+        _rkwargs: true
+      });
+      this.syncedSessions.add(sessionId);
+      this.lastSyncAt = Date.now();
+      this.log(`[ARTIFACT SYNC] Synced session ${sessionId} (${messageCount} messages)`);
+    } catch (err) {
+      this.error = `Sync failed for ${sessionId}: ${err.message}`;
+      this.log(`[ARTIFACT SYNC] Sync failed for ${sessionId}: ${err.message}`);
+    } finally {
+      this.syncing = false;
+    }
+  }
+  /**
+   * Schedule a debounced sync for a session (e.g., on each new message).
+   * Waits 30 seconds before syncing to batch multiple messages.
+   */
+  scheduleDebouncedSync(sessionId, sessionsDir, metadata, machineId, delayMs = 3e4) {
+    const existing = this.syncTimers.get(sessionId);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.syncSession(sessionId, sessionsDir, metadata, machineId).catch(() => {
+      });
+      this.syncTimers.delete(sessionId);
+    }, delayMs);
+    this.syncTimers.set(sessionId, timer);
+  }
+  /**
+   * Download a session from artifact store to local disk.
+   */
+  async downloadSession(sessionId, targetDir) {
+    if (!this.initialized || !this.artifactManager) return null;
+    try {
+      const artifactAlias = `session-${sessionId}`;
+      const artifact = await this.artifactManager.read({
+        artifact_id: artifactAlias,
+        _rkwargs: true
+      });
+      if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
+      try {
+        const data = await this.downloadFile(artifact.id, "session.json");
+        if (data) {
+          writeFileSync(join(targetDir, `${sessionId}.json`), data);
+        }
+      } catch {
+      }
+      try {
+        const data = await this.downloadFile(artifact.id, "messages.jsonl");
+        if (data) {
+          writeFileSync(join(targetDir, `${sessionId}.messages.jsonl`), data);
+        }
+      } catch {
+      }
+      return {
+        sessionData: artifact.manifest,
+        messageCount: artifact.manifest?.messageCount || 0
+      };
+    } catch (err) {
+      this.log(`[ARTIFACT SYNC] Download failed for ${sessionId}: ${err.message}`);
+      return null;
+    }
+  }
+  /**
+   * List all sessions stored in the artifact collection.
+   */
+  async listRemoteSessions() {
+    if (!this.initialized || !this.artifactManager || !this.collectionId) return [];
+    try {
+      const children = await this.artifactManager.list({
+        parent_id: this.collectionId,
+        _rkwargs: true
+      });
+      return (children || []).map((child) => ({
+        sessionId: child.manifest?.sessionId || child.alias?.replace("session-", ""),
+        machineId: child.manifest?.machineId,
+        messageCount: child.manifest?.messageCount || 0,
+        lastSyncAt: child.manifest?.lastSyncAt || 0
+      }));
+    } catch (err) {
+      this.log(`[ARTIFACT SYNC] List failed: ${err.message}`);
+      return [];
+    }
+  }
+  /**
+   * Get current sync status.
+   */
+  getStatus() {
+    return {
+      initialized: this.initialized,
+      collectionId: this.collectionId,
+      lastSyncAt: this.lastSyncAt,
+      syncing: this.syncing,
+      syncedSessions: [...this.syncedSessions],
+      error: this.error
+    };
+  }
+  /**
+   * Force sync all known sessions.
+   */
+  async syncAll(sessionsDir, machineId) {
+    if (!this.initialized || !existsSync(sessionsDir)) return;
+    const { readdirSync } = await import('node:fs');
+    for (const file of readdirSync(sessionsDir)) {
+      if (!file.endsWith(".json") || file.includes(".messages.")) continue;
+      const sessionId = file.replace(".json", "");
+      await this.syncSession(sessionId, sessionsDir, void 0, machineId);
+    }
+  }
+  /**
+   * Cleanup timers on shutdown.
+   */
+  destroy() {
+    for (const timer of this.syncTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.syncTimers.clear();
+  }
+}
+
+async function startSvampServer(ctx) {
+  const { sessionService, getMetadata, setMetadata, logger } = ctx;
+  logger.log("[svampMCP] Starting MCP server");
+  const mcp = new McpServer({
+    name: "Svamp MCP",
+    version: "1.0.0"
+  });
+  mcp.registerTool("change_title", {
+    description: "Change the title of the current chat session",
+    title: "Change Chat Title",
+    inputSchema: {
+      title: z.string().describe("The new title for the chat session")
+    }
+  }, async (args) => {
+    try {
+      setMetadata((m) => ({
+        ...m,
+        summary: { text: args.title, updatedAt: Date.now() }
+      }));
+      sessionService.pushMessage({
+        type: "summary",
+        summary: args.title
+      }, "session");
+      return {
+        content: [{ type: "text", text: `Successfully changed chat title to: "${args.title}"` }],
+        isError: false
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Failed to change chat title: ${String(error)}` }],
+        isError: true
+      };
+    }
+  });
+  mcp.registerTool("set_session_link", {
+    description: "Set a link for the current session. A clickable button with the label will appear next to the session title. Use this after creating a dashboard, report, or any web page the user should access.",
+    title: "Set Session Link",
+    inputSchema: {
+      url: z.string().describe("The URL to display"),
+      label: z.string().optional().describe('Short button label (1-2 chars or up to 2 words). Defaults to "View"')
+    }
+  }, async (args) => {
+    const label = args.label || "View";
+    try {
+      setMetadata((m) => ({
+        ...m,
+        sessionLink: { url: args.url, label, updatedAt: Date.now() }
+      }));
+      const currentSummary = getMetadata().summary?.text;
+      if (currentSummary) {
+        sessionService.pushMessage({
+          type: "summary",
+          summary: currentSummary
+        }, "session");
+      }
+      return {
+        content: [{ type: "text", text: `Session link set: "${label}" \u2192 ${args.url}. A button will appear next to the session title.` }],
+        isError: false
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Failed to set session link: ${String(error)}` }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => crypto.randomUUID()
+  });
+  await mcp.connect(transport);
+  const server = createServer(async (req, res) => {
+    try {
+      await transport.handleRequest(req, res);
+    } catch (error) {
+      logger.log(`[svampMCP] Error handling request: ${error}`);
+      if (!res.headersSent) {
+        res.writeHead(500).end();
+      }
+    }
+  });
+  const baseUrl = await new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve(new URL(`http://127.0.0.1:${addr.port}`));
+    });
+  });
+  logger.log(`[svampMCP] Server ready at ${baseUrl.toString()}`);
+  return {
+    url: baseUrl.toString(),
+    toolNames: ["change_title", "set_session_link"],
+    stop: () => {
+      logger.log("[svampMCP] Stopping server");
+      mcp.close();
+      server.close();
+    }
+  };
+}
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+function loadDotEnv() {
+  const envDir = process.env.SVAMP_HOME || join$1(os.homedir(), ".svamp");
+  const envFile = join$1(envDir, ".env");
+  if (existsSync$1(envFile)) {
+    const lines = readFileSync$1(envFile, "utf-8").split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+      if (!process.env[key]) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+loadDotEnv();
+const SVAMP_HOME = process.env.SVAMP_HOME || join$1(os.homedir(), ".svamp");
+const DAEMON_STATE_FILE = join$1(SVAMP_HOME, "daemon.state.json");
+const DAEMON_LOCK_FILE = join$1(SVAMP_HOME, "daemon.lock");
+const LOGS_DIR = join$1(SVAMP_HOME, "logs");
+const SESSIONS_DIR = join$1(SVAMP_HOME, "sessions");
+function saveSession(session) {
+  if (!existsSync$1(SESSIONS_DIR)) {
+    mkdirSync$1(SESSIONS_DIR, { recursive: true });
+  }
+  writeFileSync$1(
+    join$1(SESSIONS_DIR, `${session.sessionId}.json`),
+    JSON.stringify(session, null, 2),
+    "utf-8"
+  );
+}
+function deletePersistedSession(sessionId) {
+  const sessionFile = join$1(SESSIONS_DIR, `${sessionId}.json`);
+  try {
+    if (existsSync$1(sessionFile)) unlinkSync(sessionFile);
+  } catch {
+  }
+  const messagesFile = join$1(SESSIONS_DIR, `${sessionId}.messages.jsonl`);
+  try {
+    if (existsSync$1(messagesFile)) unlinkSync(messagesFile);
+  } catch {
+  }
+}
+function loadPersistedSessions() {
+  if (!existsSync$1(SESSIONS_DIR)) return [];
+  const sessions = [];
+  for (const file of readdirSync(SESSIONS_DIR)) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const data = JSON.parse(readFileSync$1(join$1(SESSIONS_DIR, file), "utf-8"));
+      if (data.sessionId && data.directory) {
+        sessions.push(data);
+      }
+    } catch {
+    }
+  }
+  return sessions;
+}
+function ensureHomeDir() {
+  if (!existsSync$1(SVAMP_HOME)) {
+    mkdirSync$1(SVAMP_HOME, { recursive: true });
+  }
+  if (!existsSync$1(LOGS_DIR)) {
+    mkdirSync$1(LOGS_DIR, { recursive: true });
+  }
+  if (!existsSync$1(SESSIONS_DIR)) {
+    mkdirSync$1(SESSIONS_DIR, { recursive: true });
+  }
+}
+function createLogger() {
+  ensureHomeDir();
+  const logFile = join$1(LOGS_DIR, `daemon-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.log`);
+  return {
+    logFilePath: logFile,
+    log: (...args) => {
+      const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`;
+      fs.appendFile(logFile, line).catch(() => {
+      });
+      if (process.env.DEBUG) {
+        console.log(...args);
+      }
+    },
+    error: (...args) => {
+      const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`;
+      fs.appendFile(logFile, line).catch(() => {
+      });
+      console.error(...args);
+    }
+  };
+}
+function writeDaemonStateFile(state) {
+  ensureHomeDir();
+  writeFileSync$1(DAEMON_STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+}
+function readDaemonStateFile() {
+  try {
+    if (!existsSync$1(DAEMON_STATE_FILE)) return null;
+    return JSON.parse(readFileSync$1(DAEMON_STATE_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function cleanupDaemonStateFile() {
+  try {
+    if (existsSync$1(DAEMON_STATE_FILE)) {
+      fs.unlink(DAEMON_STATE_FILE).catch(() => {
+      });
+    }
+    if (existsSync$1(DAEMON_LOCK_FILE)) {
+      fs.unlink(DAEMON_LOCK_FILE).catch(() => {
+      });
+    }
+  } catch {
+  }
+}
+function isDaemonAlive() {
+  const state = readDaemonStateFile();
+  if (!state) return false;
+  try {
+    process.kill(state.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function startDaemon() {
+  const logger = createLogger();
+  let requestShutdown;
+  const resolvesWhenShutdownRequested = new Promise((resolve2) => {
+    requestShutdown = (source, errorMessage) => {
+      logger.log(`Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
+      setTimeout(() => {
+        logger.log("Forced exit after timeout");
+        process.exit(1);
+      }, 5e3);
+      resolve2({ source, errorMessage });
+    };
+  });
+  process.on("SIGINT", () => requestShutdown("os-signal"));
+  process.on("SIGTERM", () => requestShutdown("os-signal"));
+  process.on("uncaughtException", (error) => {
+    logger.error("Uncaught exception:", error);
+    requestShutdown("exception", error.message);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const msg = String(reason);
+    logger.error("Unhandled rejection:", reason);
+    if (msg.includes("_rintf") || msg.includes("Method call timed out")) {
+      logger.log("Ignoring _rintf callback timeout (app likely disconnected)");
+      return;
+    }
+    requestShutdown("exception", msg);
+  });
+  if (isDaemonAlive()) {
+    console.log("Svamp daemon is already running");
+    process.exit(0);
+  }
+  const hyphaServerUrl = process.env.HYPHA_SERVER_URL;
+  if (!hyphaServerUrl) {
+    console.error("HYPHA_SERVER_URL is required.");
+    console.error('Run "svamp login <server-url>" first, or set it in .env or environment.');
+    process.exit(1);
+  }
+  const hyphaToken = process.env.HYPHA_TOKEN;
+  const hyphaWorkspace = process.env.HYPHA_WORKSPACE;
+  if (!hyphaToken) {
+    logger.log('Warning: No HYPHA_TOKEN set. Run "svamp login" to authenticate.');
+    logger.log("Connecting anonymously...");
+  }
+  const machineId = process.env.SVAMP_MACHINE_ID || `machine-${os.hostname()}-${randomUUID$1().slice(0, 8)}`;
+  logger.log("Starting svamp daemon...");
+  logger.log(`  Server: ${hyphaServerUrl}`);
+  logger.log(`  Workspace: ${hyphaWorkspace || "(default)"}`);
+  logger.log(`  Machine ID: ${machineId}`);
+  let server = null;
+  try {
+    logger.log("Connecting to Hypha server...");
+    server = await connectToHypha({
+      serverUrl: hyphaServerUrl,
+      token: hyphaToken,
+      name: `svamp-machine-${machineId}`
+    });
+    logger.log(`Connected to Hypha (workspace: ${server.config.workspace})`);
+    const pidToTrackedSession = /* @__PURE__ */ new Map();
+    const getCurrentChildren = () => {
+      return Array.from(pidToTrackedSession.values()).map((s) => ({
+        sessionId: s.svampSessionId || `PID-${s.pid}`,
+        pid: s.pid,
+        startedBy: s.startedBy,
+        directory: s.directory,
+        active: !s.stopped && s.hyphaService != null
+      }));
+    };
+    const spawnSession = async (options) => {
+      logger.log("Spawning session:", JSON.stringify(options));
+      const { directory, approvedNewDirectoryCreation = true, resumeSessionId } = options;
+      try {
+        await fs.access(directory);
+      } catch {
+        if (!approvedNewDirectoryCreation) {
+          return { type: "requestToApproveDirectoryCreation", directory };
+        }
+        try {
+          await fs.mkdir(directory, { recursive: true });
+        } catch (err) {
+          return { type: "error", errorMessage: `Failed to create directory: ${err.message}` };
+        }
+      }
+      const sessionId = options.sessionId || randomUUID$1();
+      try {
+        let parseBashPermission2 = function(permission) {
+          if (permission === "Bash") return;
+          const match = permission.match(/^Bash\((.+?)\)$/);
+          if (!match) return;
+          const command = match[1];
+          if (command.endsWith(":*")) {
+            allowedBashPrefixes.add(command.slice(0, -2));
+          } else {
+            allowedBashLiterals.add(command);
+          }
+        }, shouldAutoAllow2 = function(toolName, toolInput) {
+          if (toolName === "Bash") {
+            const inputObj = toolInput;
+            if (inputObj?.command) {
+              if (allowedBashLiterals.has(inputObj.command)) return true;
+              for (const prefix of allowedBashPrefixes) {
+                if (inputObj.command.startsWith(prefix)) return true;
+              }
+            }
+          } else if (allowedTools.has(toolName)) {
+            return true;
+          }
+          if (currentPermissionMode === "bypassPermissions") return true;
+          if (currentPermissionMode === "acceptEdits" && EDIT_TOOLS.has(toolName)) return true;
+          return false;
+        };
+        var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2;
+        let sessionMetadata = {
+          path: directory,
+          host: os.hostname(),
+          version: "0.1.0",
+          machineId,
+          homeDir: os.homedir(),
+          svampHomeDir: SVAMP_HOME,
+          svampLibDir: join$1(__dirname$1, ".."),
+          svampToolsDir: join$1(__dirname$1, "..", "tools"),
+          startedFromDaemon: true,
+          startedBy: "daemon",
+          lifecycleState: resumeSessionId ? "idle" : "starting"
+        };
+        let claudeProcess = null;
+        const persisted = loadPersistedSessions().find((p) => p.sessionId === sessionId);
+        let claudeResumeId = persisted?.claudeResumeId || (resumeSessionId || void 0);
+        let currentPermissionMode = persisted?.permissionMode || "default";
+        const allowedTools = /* @__PURE__ */ new Set();
+        const allowedBashLiterals = /* @__PURE__ */ new Set();
+        const allowedBashPrefixes = /* @__PURE__ */ new Set();
+        const EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "Write", "NotebookEdit"]);
+        const pendingPermissions = /* @__PURE__ */ new Map();
+        let backgroundTaskCount = 0;
+        let backgroundTaskNames = [];
+        let userMessagePending = false;
+        let turnInitiatedByUser = true;
+        const spawnClaude = (initialMessage, meta) => {
+          const permissionMode = meta?.permissionMode || currentPermissionMode;
+          currentPermissionMode = permissionMode;
+          const model = meta?.model || void 0;
+          const appendSystemPrompt = meta?.appendSystemPrompt || void 0;
+          const mcpConfigPath = join$1(SVAMP_HOME, "logs", `mcp-config-${sessionId}.json`);
+          writeFileSync$1(mcpConfigPath, JSON.stringify({
+            mcpServers: {
+              svamp: { type: "http", url: svampServer.url }
+            }
+          }));
+          const args = [
+            "--output-format",
+            "stream-json",
+            "--input-format",
+            "stream-json",
+            "--verbose",
+            "--permission-prompt-tool",
+            "stdio",
+            "--permission-mode",
+            permissionMode,
+            "--mcp-config",
+            mcpConfigPath,
+            "--allowedTools",
+            svampServer.toolNames.map((t) => `mcp__svamp__${t}`).join(",")
+          ];
+          if (model) args.push("--model", model);
+          if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
+          if (claudeResumeId) args.push("--resume", claudeResumeId);
+          logger.log(`[Session ${sessionId}] Spawning Claude: claude ${args.join(" ")} (cwd: ${directory})`);
+          const spawnEnv = { ...process.env };
+          delete spawnEnv.CLAUDECODE;
+          const child = spawn("claude", args, {
+            cwd: directory,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: spawnEnv,
+            shell: process.platform === "win32"
+          });
+          claudeProcess = child;
+          logger.log(`[Session ${sessionId}] Claude PID: ${child.pid}, stdin: ${!!child.stdin}, stdout: ${!!child.stdout}, stderr: ${!!child.stderr}`);
+          child.on("error", (err) => {
+            logger.log(`[Session ${sessionId}] Claude process error: ${err.message}`);
+            sessionService.pushMessage({
+              type: "assistant",
+              content: [{
+                type: "text",
+                text: `Error: Failed to start Claude Code CLI: ${err.message}
+
+Please ensure Claude Code CLI is installed on this machine. You can install it with:
+\`npm install -g @anthropic-ai/claude-code\``
+              }]
+            }, "agent");
+            sessionService.sendKeepAlive(false);
+          });
+          let stdoutBuffer = "";
+          child.stdout?.on("data", (chunk) => {
+            stdoutBuffer += chunk.toString();
+            const lines = stdoutBuffer.split("\n");
+            stdoutBuffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              logger.log(`[Session ${sessionId}] stdout line (${line.length} chars): ${line.slice(0, 100)}`);
+              try {
+                const msg = JSON.parse(line);
+                logger.log(`[Session ${sessionId}] Parsed type=${msg.type} subtype=${msg.subtype || "n/a"}`);
+                if (msg.type === "control_request" && msg.request?.subtype === "can_use_tool") {
+                  const requestId = msg.request_id;
+                  const toolName = msg.request.tool_name;
+                  const toolInput = msg.request.input;
+                  logger.log(`[Session ${sessionId}] Permission request: ${requestId} tool=${toolName}`);
+                  if (shouldAutoAllow2(toolName, toolInput)) {
+                    logger.log(`[Session ${sessionId}] Auto-allowing ${toolName} (mode=${currentPermissionMode})`);
+                    if (claudeProcess && !claudeProcess.killed && claudeProcess.stdin) {
+                      const controlResponse = JSON.stringify({
+                        type: "control_response",
+                        response: {
+                          subtype: "success",
+                          request_id: requestId,
+                          response: { behavior: "allow", updatedInput: toolInput || {} }
+                        }
+                      });
+                      claudeProcess.stdin.write(controlResponse + "\n");
+                    }
+                    continue;
+                  }
+                  const permissionPromise = new Promise((resolve2) => {
+                    pendingPermissions.set(requestId, { resolve: resolve2, toolName, input: toolInput });
+                  });
+                  const currentRequests = { ...sessionService._agentState?.requests };
+                  sessionService.updateAgentState({
+                    controlledByUser: false,
+                    requests: {
+                      ...currentRequests,
+                      [requestId]: {
+                        tool: toolName,
+                        arguments: toolInput,
+                        createdAt: Date.now()
+                      }
+                    }
+                  });
+                  permissionPromise.then((result) => {
+                    if (claudeProcess && !claudeProcess.killed && claudeProcess.stdin) {
+                      const controlResponse = JSON.stringify({
+                        type: "control_response",
+                        response: {
+                          subtype: "success",
+                          request_id: requestId,
+                          response: result
+                        }
+                      });
+                      logger.log(`[Session ${sessionId}] Sending control_response: ${controlResponse.slice(0, 200)}`);
+                      claudeProcess.stdin.write(controlResponse + "\n");
+                    }
+                    const reqs = { ...sessionService._agentState?.requests };
+                    delete reqs[requestId];
+                    sessionService.updateAgentState({
+                      controlledByUser: false,
+                      requests: reqs,
+                      completedRequests: {
+                        ...sessionService._agentState?.completedRequests,
+                        [requestId]: {
+                          tool: toolName,
+                          arguments: toolInput,
+                          completedAt: Date.now(),
+                          status: result.behavior === "allow" ? "approved" : "denied"
+                        }
+                      }
+                    });
+                  });
+                } else if (msg.type === "control_cancel_request") {
+                  const requestId = msg.request_id;
+                  logger.log(`[Session ${sessionId}] Permission cancel: ${requestId}`);
+                  const pending = pendingPermissions.get(requestId);
+                  if (pending) {
+                    pending.resolve({ behavior: "deny", message: "Cancelled" });
+                    pendingPermissions.delete(requestId);
+                  }
+                } else if (msg.type === "control_response") {
+                  logger.log(`[Session ${sessionId}] Control response: ${JSON.stringify(msg).slice(0, 200)}`);
+                } else if (msg.type === "assistant" || msg.type === "result") {
+                  if (msg.type === "assistant" && Array.isArray(msg.content)) {
+                    for (const block of msg.content) {
+                      if (block.type === "tool_use" && block.input?.run_in_background === true) {
+                        backgroundTaskCount++;
+                        const label = block.tool_name || block.name || "unknown";
+                        backgroundTaskNames.push(label);
+                        logger.log(`[Session ${sessionId}] Background task launched: ${label} (count=${backgroundTaskCount})`);
+                      }
+                    }
+                  }
+                  if (msg.type === "result") {
+                    if (!turnInitiatedByUser) {
+                      logger.log(`[Session ${sessionId}] Skipping stale result from SDK-initiated turn`);
+                      const hasBackgroundTasks = backgroundTaskCount > 0;
+                      if (hasBackgroundTasks) {
+                        const taskInfo = `Background tasks still running (${backgroundTaskCount}): ${backgroundTaskNames.join(", ")}`;
+                        sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
+                      }
+                      sessionService.sendKeepAlive(false);
+                      turnInitiatedByUser = true;
+                      continue;
+                    }
+                    sessionService.sendKeepAlive(false);
+                    if (backgroundTaskCount > 0) {
+                      const taskInfo = `Background tasks still running (${backgroundTaskCount}): ${backgroundTaskNames.join(", ")}`;
+                      logger.log(`[Session ${sessionId}] ${taskInfo}`);
+                      sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
+                    }
+                  }
+                  sessionService.pushMessage(msg, "agent");
+                  if (msg.session_id) {
+                    claudeResumeId = msg.session_id;
+                  }
+                } else if (msg.type === "system" && msg.subtype === "init") {
+                  if (!userMessagePending) {
+                    turnInitiatedByUser = false;
+                    logger.log(`[Session ${sessionId}] SDK-initiated turn (likely stale task_notification)`);
+                  }
+                  userMessagePending = false;
+                  if (msg.session_id) {
+                    claudeResumeId = msg.session_id;
+                    sessionService.updateMetadata({
+                      ...sessionMetadata,
+                      claudeSessionId: msg.session_id
+                    });
+                    saveSession({
+                      sessionId,
+                      directory,
+                      claudeResumeId,
+                      permissionMode: currentPermissionMode,
+                      metadata: sessionMetadata,
+                      createdAt: Date.now(),
+                      machineId
+                    });
+                    artifactSync.scheduleDebouncedSync(sessionId, SESSIONS_DIR, sessionMetadata, machineId);
+                  }
+                  sessionService.pushMessage(msg, "session");
+                } else if (msg.type === "system" && msg.subtype === "task_notification" && msg.status === "completed") {
+                  backgroundTaskCount = Math.max(0, backgroundTaskCount - 1);
+                  if (backgroundTaskNames.length > 0) {
+                    const completed = backgroundTaskNames.shift();
+                    logger.log(`[Session ${sessionId}] Background task completed: ${completed} (remaining=${backgroundTaskCount})`);
+                  }
+                  sessionService.pushMessage(msg, "agent");
+                } else {
+                  sessionService.pushMessage(msg, "agent");
+                }
+              } catch {
+                logger.log(`[Session ${sessionId}] Claude stdout (non-JSON): ${line}`);
+              }
+            }
+          });
+          child.stderr?.on("data", (chunk) => {
+            logger.log(`[Session ${sessionId}] Claude stderr: ${chunk.toString().trim()}`);
+          });
+          child.on("exit", (code, signal) => {
+            logger.log(`[Session ${sessionId}] Claude exited: code=${code}, signal=${signal}`);
+            claudeProcess = null;
+            for (const [id, pending] of pendingPermissions) {
+              pending.resolve({ behavior: "deny", message: "Claude process exited" });
+            }
+            pendingPermissions.clear();
+            if (code !== 0 && code !== null && !claudeResumeId) {
+              sessionService.pushMessage({
+                type: "assistant",
+                content: [{
+                  type: "text",
+                  text: `Error: Claude process exited with code ${code}${signal ? ` (signal: ${signal})` : ""}.
+
+This may indicate that Claude Code CLI is not properly installed or configured.`
+                }]
+              }, "agent");
+            }
+            sessionService.updateMetadata({
+              ...sessionMetadata,
+              lifecycleState: claudeResumeId ? "idle" : "stopped"
+            });
+            sessionService.sendKeepAlive(false);
+            if (claudeResumeId && !trackedSession.stopped) {
+              saveSession({
+                sessionId,
+                directory,
+                claudeResumeId,
+                permissionMode: currentPermissionMode,
+                metadata: sessionMetadata,
+                createdAt: Date.now(),
+                machineId
+              });
+              artifactSync.syncSession(sessionId, SESSIONS_DIR, sessionMetadata, machineId).catch(() => {
+              });
+            }
+          });
+          if (initialMessage && child.stdin) {
+            const stdinMsg = JSON.stringify({
+              type: "user",
+              message: { role: "user", content: initialMessage }
+            });
+            child.stdin.write(stdinMsg + "\n");
+          }
+          return child;
+        };
+        const sessionService = await registerSessionService(
+          server,
+          sessionId,
+          sessionMetadata,
+          { controlledByUser: false },
+          {
+            onUserMessage: (content, meta) => {
+              logger.log(`[Session ${sessionId}] User message received`);
+              userMessagePending = true;
+              turnInitiatedByUser = true;
+              let text;
+              let msgMeta = meta;
+              try {
+                let parsed = typeof content === "string" ? JSON.parse(content) : content;
+                if (parsed?.content && typeof parsed.content === "string") {
+                  try {
+                    const inner = JSON.parse(parsed.content);
+                    if (inner && typeof inner === "object") parsed = inner;
+                  } catch {
+                  }
+                }
+                text = parsed?.content?.text || parsed?.text || (typeof parsed === "string" ? parsed : JSON.stringify(parsed));
+                if (parsed?.meta) msgMeta = { ...msgMeta, ...parsed.meta };
+              } catch {
+                text = typeof content === "string" ? content : JSON.stringify(content);
+              }
+              if (msgMeta?.permissionMode) {
+                currentPermissionMode = msgMeta.permissionMode;
+                logger.log(`[Session ${sessionId}] Permission mode updated to: ${currentPermissionMode}`);
+              }
+              if (!claudeProcess || claudeProcess.killed) {
+                spawnClaude(text, msgMeta);
+              } else {
+                const stdinMsg = JSON.stringify({
+                  type: "user",
+                  message: { role: "user", content: text }
+                });
+                claudeProcess.stdin?.write(stdinMsg + "\n");
+              }
+              sessionService.sendKeepAlive(true);
+            },
+            onAbort: () => {
+              logger.log(`[Session ${sessionId}] Abort requested`);
+              if (claudeProcess && !claudeProcess.killed) {
+                claudeProcess.kill("SIGINT");
+              }
+            },
+            onPermissionResponse: (params) => {
+              logger.log(`[Session ${sessionId}] Permission response:`, JSON.stringify(params));
+              const requestId = params.id;
+              const pending = pendingPermissions.get(requestId);
+              if (params.mode) {
+                logger.log(`[Session ${sessionId}] Permission mode changed to: ${params.mode}`);
+                currentPermissionMode = params.mode;
+              }
+              if (params.allowTools && Array.isArray(params.allowTools)) {
+                for (const tool of params.allowTools) {
+                  if (tool.startsWith("Bash(") || tool === "Bash") {
+                    parseBashPermission2(tool);
+                  } else {
+                    allowedTools.add(tool);
+                  }
+                }
+                logger.log(`[Session ${sessionId}] Updated allowed tools: ${[...allowedTools].join(", ")}`);
+              }
+              if (pending) {
+                pendingPermissions.delete(requestId);
+                if (params.approved) {
+                  pending.resolve({
+                    behavior: "allow",
+                    updatedInput: pending.input || {}
+                  });
+                } else {
+                  pending.resolve({
+                    behavior: "deny",
+                    message: params.reason || "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed."
+                  });
+                }
+              } else {
+                logger.log(`[Session ${sessionId}] No pending permission for id=${requestId}`);
+              }
+            },
+            onSwitchMode: (mode) => {
+              logger.log(`[Session ${sessionId}] Switch mode: ${mode}`);
+              currentPermissionMode = mode;
+              if (claudeProcess && !claudeProcess.killed) {
+                claudeProcess.kill("SIGTERM");
+                setTimeout(() => {
+                  if (!claudeProcess || claudeProcess.killed) {
+                    spawnClaude(void 0, { permissionMode: mode });
+                  }
+                }, 1e3);
+              }
+            },
+            onRestartClaude: () => {
+              logger.log(`[Session ${sessionId}] Restart Claude requested`);
+              if (claudeProcess && !claudeProcess.killed) {
+                claudeProcess.kill("SIGTERM");
+              }
+            },
+            onKillSession: () => {
+              logger.log(`[Session ${sessionId}] Kill session requested`);
+              stopSession(sessionId);
+            },
+            onBash: async (command, cwd) => {
+              logger.log(`[Session ${sessionId}] Bash: ${command} (cwd: ${cwd || directory})`);
+              const { exec } = await import('child_process');
+              return new Promise((resolve2) => {
+                exec(command, { cwd: cwd || directory, timeout: 3e4, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+                  if (err) {
+                    resolve2({ success: false, stdout: stdout || "", stderr: stderr || err.message, exitCode: err.code ?? 1 });
+                  } else {
+                    resolve2({ success: true, stdout, stderr: stderr || "", exitCode: 0 });
+                  }
+                });
+              });
+            },
+            onReadFile: async (path) => {
+              return await fs.readFile(path, "utf-8");
+            },
+            onWriteFile: async (path, content) => {
+              const resolvedPath = resolve(directory, path);
+              if (!resolvedPath.startsWith(resolve(directory))) {
+                throw new Error("Path outside working directory");
+              }
+              await fs.mkdir(dirname(resolvedPath), { recursive: true });
+              await fs.writeFile(resolvedPath, Buffer.from(content, "base64"));
+            },
+            onListDirectory: async (path) => {
+              const entries = await fs.readdir(path, { withFileTypes: true });
+              return entries.map((e) => ({ name: e.name, isDirectory: e.isDirectory() }));
+            },
+            onGetDirectoryTree: async (treePath, maxDepth) => {
+              async function buildTree(p, name, depth) {
+                try {
+                  const stats = await fs.stat(p);
+                  const node = {
+                    name,
+                    path: p,
+                    type: stats.isDirectory() ? "directory" : "file",
+                    size: stats.size,
+                    modified: stats.mtime.getTime()
+                  };
+                  if (stats.isDirectory() && depth < maxDepth) {
+                    const entries = await fs.readdir(p, { withFileTypes: true });
+                    const children = [];
+                    await Promise.all(entries.map(async (entry) => {
+                      if (entry.isSymbolicLink()) return;
+                      const childPath = join$1(p, entry.name);
+                      const childNode = await buildTree(childPath, entry.name, depth + 1);
+                      if (childNode) children.push(childNode);
+                    }));
+                    children.sort((a, b) => {
+                      if (a.type === "directory" && b.type !== "directory") return -1;
+                      if (a.type !== "directory" && b.type === "directory") return 1;
+                      return a.name.localeCompare(b.name);
+                    });
+                    node.children = children;
+                  }
+                  return node;
+                } catch {
+                  return null;
+                }
+              }
+              const resolvedPath = resolve(directory, treePath);
+              const tree = await buildTree(resolvedPath, basename(resolvedPath), 0);
+              return { success: !!tree, tree };
+            }
+          },
+          { messagesDir: SESSIONS_DIR }
+        );
+        const svampServer = await startSvampServer({
+          sessionService,
+          getMetadata: () => sessionMetadata,
+          setMetadata: (updater) => {
+            sessionMetadata = updater(sessionMetadata);
+            sessionService.updateMetadata(sessionMetadata);
+          },
+          logger
+        });
+        const trackedSession = {
+          startedBy: "daemon",
+          pid: process.pid,
+          svampSessionId: sessionId,
+          hyphaService: sessionService,
+          svampMcpServer: svampServer,
+          directory,
+          get childProcess() {
+            return claudeProcess || void 0;
+          }
+        };
+        pidToTrackedSession.set(process.pid + Math.floor(Math.random() * 1e5), trackedSession);
+        sessionService.updateMetadata({
+          ...sessionMetadata,
+          lifecycleState: "idle"
+        });
+        logger.log(`Session ${sessionId} registered on Hypha, waiting for first message to spawn Claude`);
+        return {
+          type: "success",
+          sessionId,
+          message: `Session registered on Hypha as svamp-session-${sessionId}`
+        };
+      } catch (err) {
+        logger.error(`Failed to spawn session:`, err);
+        return {
+          type: "error",
+          errorMessage: `Failed to register session service: ${err.message}`
+        };
+      }
+    };
+    const stopSession = (sessionId) => {
+      logger.log(`Stopping session: ${sessionId}`);
+      for (const [pid, session] of pidToTrackedSession) {
+        if (session.svampSessionId === sessionId) {
+          session.stopped = true;
+          session.svampMcpServer?.stop();
+          session.hyphaService?.disconnect().catch(() => {
+          });
+          if (session.childProcess) {
+            try {
+              session.childProcess.kill("SIGTERM");
+            } catch {
+            }
+          }
+          pidToTrackedSession.delete(pid);
+          deletePersistedSession(sessionId);
+          logger.log(`Session ${sessionId} stopped`);
+          return true;
+        }
+      }
+      logger.log(`Session ${sessionId} not found`);
+      return false;
+    };
+    const defaultHomeDir = existsSync$1("/data") ? "/data" : os.homedir();
+    const machineMetadata = {
+      host: os.hostname(),
+      platform: os.platform(),
+      svampVersion: "0.1.0 (hypha)",
+      homeDir: defaultHomeDir,
+      svampHomeDir: SVAMP_HOME,
+      svampLibDir: join$1(__dirname$1, ".."),
+      displayName: process.env.SVAMP_DISPLAY_NAME || void 0
+    };
+    const initialDaemonState = {
+      status: "running",
+      pid: process.pid,
+      startedAt: Date.now()
+    };
+    const machineService = await registerMachineService(
+      server,
+      machineId,
+      machineMetadata,
+      initialDaemonState,
+      {
+        spawnSession,
+        stopSession,
+        requestShutdown: () => requestShutdown("hypha-app"),
+        getTrackedSessions: getCurrentChildren
+      }
+    );
+    logger.log(`Machine service registered: svamp-machine-${machineId}`);
+    const artifactSync = new SessionArtifactSync(server, logger.log);
+    await artifactSync.init().catch((err) => {
+      logger.log(`[ARTIFACT SYNC] Background init failed: ${err}`);
+    });
+    const debugService = await registerDebugService(server, machineId, {
+      machineId,
+      getTrackedSessions: getCurrentChildren,
+      getSessionService: (sessionId) => {
+        for (const [, session] of pidToTrackedSession) {
+          if (session.svampSessionId === sessionId) {
+            return session.hyphaService;
+          }
+        }
+        return null;
+      },
+      getArtifactSync: () => artifactSync,
+      getSessionsDir: () => SESSIONS_DIR
+    });
+    logger.log(`Debug service registered: svamp-debug-${machineId}`);
+    const persistedSessions = loadPersistedSessions();
+    try {
+      const remoteSessions = await artifactSync.listRemoteSessions();
+      const localIds = new Set(persistedSessions.map((p) => p.sessionId));
+      for (const remote of remoteSessions) {
+        if (!localIds.has(remote.sessionId)) {
+          logger.log(`[ARTIFACT SYNC] Downloading remote session ${remote.sessionId} (from machine ${remote.machineId || "unknown"})`);
+          const downloaded = await artifactSync.downloadSession(remote.sessionId, SESSIONS_DIR);
+          if (downloaded?.sessionData) {
+            persistedSessions.push({
+              sessionId: remote.sessionId,
+              directory: downloaded.sessionData.directory || "/tmp",
+              claudeResumeId: downloaded.sessionData.claudeResumeId,
+              permissionMode: downloaded.sessionData.permissionMode || "default",
+              metadata: downloaded.sessionData.metadata,
+              createdAt: downloaded.sessionData.createdAt || Date.now(),
+              machineId: remote.machineId
+            });
+            logger.log(`[ARTIFACT SYNC] Downloaded session ${remote.sessionId} (${downloaded.messageCount} messages)`);
+          }
+        }
+      }
+    } catch (err) {
+      logger.log(`[ARTIFACT SYNC] Remote session restore failed: ${err.message}`);
+    }
+    if (persistedSessions.length > 0) {
+      logger.log(`Restoring ${persistedSessions.length} persisted session(s)...`);
+      for (const persisted of persistedSessions) {
+        try {
+          const isOrphaned = persisted.machineId && persisted.machineId !== machineId;
+          if (isOrphaned) {
+            logger.log(`Session ${persisted.sessionId} is from a different machine (${persisted.machineId} vs ${machineId}), marking as orphaned`);
+          }
+          const result = await spawnSession({
+            directory: persisted.directory,
+            sessionId: persisted.sessionId,
+            resumeSessionId: persisted.claudeResumeId
+          });
+          if (result.type === "success") {
+            logger.log(`Restored session ${persisted.sessionId} (resume=${persisted.claudeResumeId})`);
+            if (isOrphaned) {
+              for (const [, tracked] of pidToTrackedSession) {
+                if (tracked.svampSessionId === persisted.sessionId && tracked.hyphaService) {
+                  tracked.hyphaService.updateMetadata({
+                    ...persisted.metadata || {},
+                    isOrphaned: true,
+                    originalMachineId: persisted.machineId
+                  });
+                  break;
+                }
+              }
+            }
+          } else {
+            logger.log(`Failed to restore session ${persisted.sessionId}: ${result.type}`);
+          }
+        } catch (err) {
+          logger.error(`Error restoring session ${persisted.sessionId}:`, err.message);
+        }
+      }
+    }
+    let appToken;
+    try {
+      appToken = await server.generateToken({});
+      logger.log(`App connection token generated`);
+    } catch (err) {
+      logger.log("Could not generate token (server may not support it):", err);
+    }
+    const localState = {
+      pid: process.pid,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "0.1.0",
+      hyphaServerUrl,
+      workspace: server.config.workspace
+    };
+    writeDaemonStateFile(localState);
+    console.log("Svamp daemon started successfully!");
+    console.log(`  Machine ID: ${machineId}`);
+    console.log(`  Hypha server: ${hyphaServerUrl}`);
+    console.log(`  Workspace: ${server.config.workspace}`);
+    if (appToken) {
+      console.log(`  App token: ${appToken}`);
+    }
+    console.log(`  Service: svamp-machine-${machineId}`);
+    console.log(`  Log file: ${logger.logFilePath}`);
+    const heartbeatInterval = setInterval(async () => {
+      for (const [key, session] of pidToTrackedSession) {
+        const child = session.childProcess;
+        if (child && child.pid) {
+          try {
+            process.kill(child.pid, 0);
+          } catch {
+            logger.log(`Removing stale session (child PID ${child.pid} dead): ${session.svampSessionId}`);
+            session.hyphaService?.disconnect().catch(() => {
+            });
+            pidToTrackedSession.delete(key);
+          }
+        }
+      }
+      try {
+        const state = readDaemonStateFile();
+        if (state && state.pid === process.pid) {
+          state.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+          writeDaemonStateFile(state);
+        }
+      } catch {
+      }
+    }, 6e4);
+    const cleanup = async (source) => {
+      logger.log(`Cleaning up (source: ${source})...`);
+      clearInterval(heartbeatInterval);
+      machineService.updateDaemonState({
+        ...initialDaemonState,
+        status: "shutting-down",
+        shutdownRequestedAt: Date.now(),
+        shutdownSource: source
+      });
+      await new Promise((r) => setTimeout(r, 200));
+      for (const [pid, session] of pidToTrackedSession) {
+        session.hyphaService?.disconnect().catch(() => {
+        });
+        if (session.childProcess) {
+          try {
+            session.childProcess.kill("SIGTERM");
+          } catch {
+          }
+        }
+      }
+      try {
+        await machineService.disconnect();
+      } catch {
+      }
+      try {
+        await debugService.disconnect();
+      } catch {
+      }
+      artifactSync.destroy();
+      try {
+        await server.disconnect();
+      } catch {
+      }
+      cleanupDaemonStateFile();
+      logger.log("Cleanup complete");
+    };
+    const shutdownReq = await resolvesWhenShutdownRequested;
+    await cleanup(shutdownReq.source);
+    process.exit(0);
+  } catch (error) {
+    logger.error("Fatal error:", error);
+    cleanupDaemonStateFile();
+    if (server) {
+      try {
+        await server.disconnect();
+      } catch {
+      }
+    }
+    process.exit(1);
+  }
+}
+async function stopDaemon() {
+  const state = readDaemonStateFile();
+  if (!state) {
+    console.log("No daemon running");
+    return;
+  }
+  try {
+    process.kill(state.pid, 0);
+    process.kill(state.pid, "SIGTERM");
+    console.log(`Sent SIGTERM to daemon PID ${state.pid}`);
+    for (let i = 0; i < 30; i++) {
+      await new Promise((r) => setTimeout(r, 100));
+      try {
+        process.kill(state.pid, 0);
+      } catch {
+        console.log("Daemon stopped");
+        cleanupDaemonStateFile();
+        return;
+      }
+    }
+    console.log("Daemon did not stop in time, sending SIGKILL");
+    process.kill(state.pid, "SIGKILL");
+  } catch {
+    console.log("Daemon is not running (stale state file)");
+  }
+  cleanupDaemonStateFile();
+}
+function daemonStatus() {
+  const state = readDaemonStateFile();
+  if (!state) {
+    console.log("Status: Not running");
+    return;
+  }
+  const alive = isDaemonAlive();
+  console.log(`Status: ${alive ? "Running" : "Dead (stale state)"}`);
+  console.log(`  PID: ${state.pid}`);
+  console.log(`  Started: ${state.startTime}`);
+  console.log(`  Hypha server: ${state.hyphaServerUrl}`);
+  if (state.workspace) {
+    console.log(`  Workspace: ${state.workspace}`);
+  }
+  if (state.lastHeartbeat) {
+    console.log(`  Last heartbeat: ${state.lastHeartbeat}`);
+  }
+  if (!alive) {
+    cleanupDaemonStateFile();
+  }
+}
+
+export { registerSessionService as a, stopDaemon as b, connectToHypha as c, daemonStatus as d, getHyphaServerUrl as g, registerMachineService as r, startDaemon as s };