svamp-cli 0.1.33 → 0.1.34

package/dist/cli.mjs

@@ -91,7 +91,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-CMmjP_vD.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-D2n0SOTg.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);

package/dist/{package-CMmjP_vD.mjs → package-D2n0SOTg.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.1.32";
+var version = "0.1.34";
 var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
 var author = "Amun AI AB";
 var license = "SEE LICENSE IN LICENSE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",

package/dist/run-DaEcQsPx.mjs

@@ -1,892 +0,0 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { randomUUID } from 'node:crypto';
-import os from 'node:os';
-import { join, resolve } from 'node:path';
-import { mkdirSync, writeFileSync, existsSync, unlinkSync, readFileSync, watch } from 'node:fs';
-import { c as connectToHypha, a as registerSessionService } from './run-fEuWMTdD.mjs';
-import { createServer } from 'node:http';
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import 'os';
-import 'fs/promises';
-import 'fs';
-import 'path';
-import 'url';
-import 'child_process';
-import 'crypto';
-import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
-import 'node:fs/promises';
-import 'node:util';
-
-async function startHookServer(onSessionHook, log) {
-  return new Promise((resolve, reject) => {
-    const server = createServer(async (req, res) => {
-      if (req.method === "POST" && req.url === "/hook/session-start") {
-        const timeout = setTimeout(() => {
-          if (!res.headersSent) res.writeHead(408).end("timeout");
-        }, 5e3);
-        try {
-          const chunks = [];
-          for await (const chunk of req) chunks.push(chunk);
-          clearTimeout(timeout);
-          const body = Buffer.concat(chunks).toString("utf-8");
-          log("[hook] Received:", body.slice(0, 200));
-          let data = {};
-          try {
-            data = JSON.parse(body);
-          } catch {
-          }
-          const sessionId = data.session_id || data.sessionId;
-          if (sessionId) {
-            log(`[hook] Session ID: ${sessionId}`);
-            onSessionHook(sessionId);
-          }
-          res.writeHead(200).end("ok");
-        } catch {
-          clearTimeout(timeout);
-          if (!res.headersSent) res.writeHead(500).end("error");
-        }
-        return;
-      }
-      res.writeHead(404).end("not found");
-    });
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      if (!addr || typeof addr === "string") {
-        reject(new Error("Failed to get server address"));
-        return;
-      }
-      log(`[hook] Listening on port ${addr.port}`);
-      resolve({ port: addr.port, stop: () => server.close() });
-    });
-    server.on("error", reject);
-  });
-}
-
-const SVAMP_HOME$1 = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
-function generateHookSettings(port) {
-  const hooksDir = join(SVAMP_HOME$1, "tmp", "hooks");
-  mkdirSync(hooksDir, { recursive: true });
-  const forwarderPath = join(hooksDir, `forwarder-${process.pid}.cjs`);
-  const forwarderCode = `#!/usr/bin/env node
-const http = require('http');
-const port = parseInt(process.argv[2], 10);
-if (!port || isNaN(port)) process.exit(1);
-const chunks = [];
-process.stdin.on('data', c => chunks.push(c));
-process.stdin.on('end', () => {
-    const body = Buffer.concat(chunks);
-    const req = http.request({
-        host: '127.0.0.1', port, method: 'POST',
-        path: '/hook/session-start',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': body.length }
-    }, res => res.resume());
-    req.on('error', () => {});
-    req.end(body);
-});
-process.stdin.resume();
-`;
-  writeFileSync(forwarderPath, forwarderCode, { mode: 493 });
-  const settingsPath = join(hooksDir, `session-hook-${process.pid}.json`);
-  const hookCommand = `node "${forwarderPath}" ${port}`;
-  const settings = {
-    hooks: {
-      SessionStart: [
-        {
-          matcher: "*",
-          hooks: [{ type: "command", command: hookCommand }]
-        }
-      ]
-    }
-  };
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-  const cleanup = () => {
-    try {
-      if (existsSync(settingsPath)) unlinkSync(settingsPath);
-    } catch {
-    }
-    try {
-      if (existsSync(forwarderPath)) unlinkSync(forwarderPath);
-    } catch {
-    }
-  };
-  return { settingsPath, cleanup };
-}
-
-const INTERNAL_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "file-history-snapshot",
-  "change",
-  "queue-operation"
-]);
-function getProjectDir(workingDirectory) {
-  const projectId = resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
-  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(os.homedir(), ".claude");
-  return join(claudeConfigDir, "projects", projectId);
-}
-function createSessionScanner(opts) {
-  const { workingDirectory, onMessage, log } = opts;
-  const projectDir = getProjectDir(workingDirectory);
-  const processedKeys = /* @__PURE__ */ new Set();
-  let currentSessionId = null;
-  let watcher = null;
-  let syncInterval = null;
-  let stopped = false;
-  function messageKey(msg) {
-    if (msg.type === "summary") return `summary:${msg.leafUuid}:${msg.summary}`;
-    return msg.uuid || "";
-  }
-  function readAndSync() {
-    if (stopped || !currentSessionId) return;
-    const filePath = join(projectDir, `${currentSessionId}.jsonl`);
-    if (!existsSync(filePath)) return;
-    let content;
-    try {
-      content = readFileSync(filePath, "utf-8");
-    } catch {
-      return;
-    }
-    const lines = content.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(trimmed);
-      } catch {
-        continue;
-      }
-      if (parsed.type && INTERNAL_EVENT_TYPES.has(parsed.type)) continue;
-      if (!["user", "assistant", "summary", "system"].includes(parsed.type)) continue;
-      const key = messageKey(parsed);
-      if (!key || processedKeys.has(key)) continue;
-      processedKeys.add(key);
-      onMessage(parsed);
-    }
-  }
-  function startWatching(sessionId) {
-    stopWatching();
-    currentSessionId = sessionId;
-    const filePath = join(projectDir, `${sessionId}.jsonl`);
-    log(`[scanner] Watching: ${filePath}`);
-    readAndSync();
-    try {
-      watcher = watch(filePath, { persistent: false }, () => {
-        readAndSync();
-      });
-      watcher.on("error", () => {
-      });
-    } catch {
-    }
-    syncInterval = setInterval(readAndSync, 2e3);
-  }
-  function stopWatching() {
-    if (watcher) {
-      try {
-        watcher.close();
-      } catch {
-      }
-      watcher = null;
-    }
-    if (syncInterval) {
-      clearInterval(syncInterval);
-      syncInterval = null;
-    }
-  }
-  return {
-    onNewSession(sessionId) {
-      if (sessionId === currentSessionId) return;
-      log(`[scanner] New session: ${sessionId}`);
-      startWatching(sessionId);
-    },
-    sync: readAndSync,
-    cleanup() {
-      stopped = true;
-      stopWatching();
-      if (currentSessionId) readAndSync();
-    }
-  };
-}
-
-async function runLocalMode(opts) {
-  const { cwd, onSessionFound, onMessage, onThinkingChange, log } = opts;
-  const scanner = createSessionScanner({
-    workingDirectory: cwd,
-    onMessage,
-    log
-  });
-  if (opts.claudeSessionId) {
-    scanner.onNewSession(opts.claudeSessionId);
-  }
-  const args = [];
-  if (opts.claudeSessionId) {
-    args.push("--resume", opts.claudeSessionId);
-  }
-  args.push("--settings", opts.hookSettingsPath);
-  if (opts.claudeArgs) {
-    args.push(...opts.claudeArgs);
-  }
-  log(`[local] Spawning: claude ${args.join(" ")}`);
-  const claudeBin = findClaudeBinary();
-  if (!claudeBin) {
-    console.error("Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code");
-    return { type: "exit", code: 1 };
-  }
-  process.stdin.pause();
-  return new Promise((resolve) => {
-    const child = spawn(claudeBin, args, {
-      stdio: ["inherit", "inherit", "inherit"],
-      cwd,
-      signal: opts.abort,
-      env: process.env
-    });
-    child.on("error", (err) => {
-      log(`[local] Spawn error: ${err.message}`);
-      scanner.cleanup();
-      process.stdin.resume();
-      onThinkingChange(false);
-      if (err.code === "ABORT_ERR" || opts.abort.aborted) {
-        resolve({ type: "switch" });
-      } else {
-        resolve({ type: "exit", code: 1 });
-      }
-    });
-    child.on("exit", (code, signal) => {
-      log(`[local] Claude exited: code=${code}, signal=${signal}`);
-      scanner.cleanup();
-      process.stdin.resume();
-      onThinkingChange(false);
-      if (signal === "SIGTERM" && opts.abort.aborted) {
-        resolve({ type: "switch" });
-      } else {
-        resolve({ type: "exit", code: code ?? 0 });
-      }
-    });
-    if (opts.abort.aborted) {
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-    }
-  });
-}
-function findClaudeBinary() {
-  try {
-    const { execSync } = require("child_process");
-    const path = execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
-    if (path && existsSync(path)) return path;
-  } catch {
-  }
-  return null;
-}
-
-async function runRemoteMode(opts) {
-  const { cwd, log, onThinkingChange, onMessage } = opts;
-  let claudeBin = null;
-  try {
-    const { execSync } = require("child_process");
-    claudeBin = execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
-  } catch {
-  }
-  if (!claudeBin || !existsSync(claudeBin)) {
-    console.error("Claude Code CLI not found.");
-    return "exit";
-  }
-  console.log("\n\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m");
-  console.log("\x1B[36m  Remote mode\x1B[0m \u2014 processing message from web app");
-  console.log("\x1B[90m  Press Space Space to switch to local mode\x1B[0m");
-  console.log("\x1B[90m  Press Ctrl-C Ctrl-C to exit\x1B[0m");
-  console.log("\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m\n");
-  let exitReason = null;
-  let lastSpace = 0;
-  let lastCtrlC = 0;
-  const DOUBLE_TAP_MS = 2e3;
-  let spaceHintShown = false;
-  let ctrlcHintShown = false;
-  const stdinWasRaw = process.stdin.isRaw;
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-  }
-  process.stdin.resume();
-  process.stdin.setEncoding("utf8");
-  const keyHandler = (data) => {
-    const now = Date.now();
-    if (data === "") {
-      if (now - lastCtrlC < DOUBLE_TAP_MS) {
-        exitReason = "exit";
-        abortController.abort();
-        return;
-      }
-      lastCtrlC = now;
-      if (!ctrlcHintShown) {
-        ctrlcHintShown = true;
-        process.stdout.write("\n\x1B[33m  Press Ctrl-C again to exit\x1B[0m\n");
-        setTimeout(() => {
-          ctrlcHintShown = false;
-        }, DOUBLE_TAP_MS);
-      }
-      return;
-    }
-    if (data === " ") {
-      if (now - lastSpace < DOUBLE_TAP_MS) {
-        exitReason = "switch";
-        abortController.abort();
-        return;
-      }
-      lastSpace = now;
-      if (!spaceHintShown) {
-        spaceHintShown = true;
-        process.stdout.write("\n\x1B[33m  Press Space again to switch to local mode\x1B[0m\n");
-        setTimeout(() => {
-          spaceHintShown = false;
-        }, DOUBLE_TAP_MS);
-      }
-      return;
-    }
-    lastSpace = 0;
-    lastCtrlC = 0;
-  };
-  process.stdin.on("data", keyHandler);
-  const abortController = new AbortController();
-  if (opts.abort.aborted) {
-    abortController.abort();
-  } else {
-    opts.abort.addEventListener("abort", () => abortController.abort(), { once: true });
-  }
-  try {
-    while (!exitReason && !abortController.signal.aborted) {
-      const message = await Promise.race([
-        opts.nextMessage(),
-        new Promise((_, reject) => {
-          if (abortController.signal.aborted) reject(new Error("aborted"));
-          abortController.signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
-        })
-      ]).catch(() => null);
-      if (!message || exitReason || abortController.signal.aborted) break;
-      const turnResult = await runClaudeTurn({
-        claudeBin,
-        cwd,
-        message,
-        sessionId: opts.claudeSessionId,
-        permissionMode: opts.permissionMode,
-        hookSettingsPath: opts.hookSettingsPath,
-        claudeArgs: opts.claudeArgs,
-        signal: abortController.signal,
-        onSessionFound: opts.onSessionFound,
-        onThinkingChange,
-        onMessage,
-        log
-      });
-      if (turnResult === "error") {
-        continue;
-      }
-      if (!exitReason && !abortController.signal.aborted) {
-        console.log("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m");
-      }
-    }
-  } finally {
-    process.stdin.removeListener("data", keyHandler);
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(stdinWasRaw ?? false);
-    }
-  }
-  return exitReason || "exit";
-}
-async function runClaudeTurn(opts) {
-  const args = [
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    "--input-format",
-    "stream-json",
-    "--settings",
-    opts.hookSettingsPath
-  ];
-  if (opts.sessionId) {
-    args.push("--resume", opts.sessionId);
-  }
-  const claudeMode = mapPermissionMode(opts.permissionMode);
-  if (claudeMode) {
-    args.push("--permission-mode", claudeMode);
-  }
-  if (opts.claudeArgs) {
-    args.push(...opts.claudeArgs);
-  }
-  opts.log(`[remote] Spawning: claude ${args.join(" ")}`);
-  const child = spawn(opts.claudeBin, args, {
-    stdio: ["pipe", "pipe", "pipe"],
-    cwd: opts.cwd,
-    env: process.env
-  });
-  const userMsg = JSON.stringify({
-    type: "user",
-    message: { role: "user", content: opts.message }
-  });
-  child.stdin.write(userMsg + "\n");
-  child.stdin.end();
-  opts.onThinkingChange(true);
-  let currentText = "";
-  return new Promise((resolve) => {
-    const abortHandler = () => {
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-    };
-    if (opts.signal.aborted) {
-      abortHandler();
-    } else {
-      opts.signal.addEventListener("abort", abortHandler, { once: true });
-    }
-    const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
-    rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-      let msg;
-      try {
-        msg = JSON.parse(trimmed);
-      } catch {
-        return;
-      }
-      if (msg.type === "control_request") {
-        handleControlRequest(msg, child, opts.log);
-        return;
-      }
-      handleSDKMessage(msg, opts, (text) => {
-        process.stdout.write(text);
-        currentText += text;
-      });
-    });
-    if (child.stderr) {
-      child.stderr.on("data", (data) => {
-        opts.log(`[remote:stderr] ${data.toString().trim()}`);
-      });
-    }
-    child.on("error", (err) => {
-      opts.log(`[remote] Error: ${err.message}`);
-      opts.onThinkingChange(false);
-      if (currentText && !currentText.endsWith("\n")) process.stdout.write("\n");
-      resolve("error");
-    });
-    child.on("exit", (code, signal) => {
-      opts.log(`[remote] Exit: code=${code}, signal=${signal}`);
-      opts.onThinkingChange(false);
-      if (currentText && !currentText.endsWith("\n")) process.stdout.write("\n");
-      resolve(code === 0 || signal === "SIGTERM" ? "ok" : "error");
-    });
-  });
-}
-function handleSDKMessage(msg, opts, write) {
-  switch (msg.type) {
-    case "system": {
-      if (msg.subtype === "init" && msg.session_id) {
-        opts.onSessionFound(msg.session_id);
-      }
-      break;
-    }
-    case "assistant": {
-      const content = msg.message?.content;
-      if (Array.isArray(content)) {
-        for (const block of content) {
-          if (block.type === "text" && block.text) {
-            write(block.text);
-          } else if (block.type === "tool_use") {
-            const argsStr = JSON.stringify(block.input || {}).slice(0, 100);
-            write(`
-\x1B[33m[tool]\x1B[0m ${block.name}(${argsStr})
-`);
-          }
-        }
-      }
-      if (msg.message) {
-        opts.onMessage({ type: "assistant", uuid: msg.uuid || msg.message?.id, message: msg.message });
-      }
-      break;
-    }
-    case "user": {
-      const content = msg.message?.content;
-      if (Array.isArray(content)) {
-        for (const block of content) {
-          if (block.type === "tool_result") {
-            const text = typeof block.content === "string" ? block.content : JSON.stringify(block.content || "");
-            if (text.length > 0) {
-              const preview = text.length > 200 ? text.slice(0, 200) + "..." : text;
-              write(`\x1B[90m[result]\x1B[0m ${preview}
-`);
-            }
-          }
-        }
-      }
-      break;
-    }
-    case "result": {
-      if (msg.result) {
-        write(`
-\x1B[32m[done]\x1B[0m ${msg.result}
-`);
-      }
-      break;
-    }
-    default:
-      opts.log(`[remote] Unknown msg type: ${msg.type}`);
-  }
-}
-function handleControlRequest(msg, child, log) {
-  const request = msg.request;
-  const requestId = msg.request_id;
-  if (request?.subtype === "can_use_tool") {
-    log(`[remote] Auto-approving tool: ${request.tool_name}`);
-    const response = JSON.stringify({
-      type: "control_response",
-      response: {
-        subtype: "success",
-        request_id: requestId,
-        response: {
-          behavior: "allow",
-          updatedInput: request.input
-        }
-      }
-    });
-    try {
-      child.stdin.write(response + "\n");
-    } catch {
-    }
-  }
-}
-function mapPermissionMode(mode) {
-  const map = {
-    "default": "default",
-    "acceptEdits": "acceptEdits",
-    "bypassPermissions": "bypassPermissions",
-    "plan": "plan",
-    "auto-approve-all": "bypassPermissions"
-  };
-  return map[mode] || null;
-}
-
-async function loop(opts) {
-  const { log } = opts;
-  let mode = opts.startingMode;
-  let claudeSessionId = null;
-  const onSessionFound = (id) => {
-    if (id !== claudeSessionId) {
-      log(`[loop] Session ID: ${id}`);
-      claudeSessionId = id;
-      opts.onSessionFound(id);
-    }
-  };
-  while (true) {
-    log(`[loop] Mode: ${mode}`);
-    switch (mode) {
-      case "local": {
-        if (opts.hasRemoteMessage()) {
-          log("[loop] Pending remote message, switching to remote");
-          mode = "remote";
-          opts.onModeChange(mode);
-          break;
-        }
-        const abortController = new AbortController();
-        let messageWatcher = null;
-        messageWatcher = setInterval(() => {
-          if (opts.hasRemoteMessage() && !abortController.signal.aborted) {
-            log("[loop] Remote message received, switching to remote mode");
-            abortController.abort();
-          }
-        }, 500);
-        const result = await runLocalMode({
-          cwd: opts.cwd,
-          claudeSessionId,
-          onSessionFound,
-          onMessage: opts.onMessage,
-          onThinkingChange: opts.onThinkingChange,
-          abort: abortController.signal,
-          hookSettingsPath: opts.hookSettingsPath,
-          claudeArgs: opts.claudeArgs,
-          log
-        });
-        if (messageWatcher) clearInterval(messageWatcher);
-        if (result.type === "switch") {
-          mode = "remote";
-          opts.onModeChange(mode);
-        } else {
-          return result.code;
-        }
-        break;
-      }
-      case "remote": {
-        const abortController = new AbortController();
-        const result = await runRemoteMode({
-          cwd: opts.cwd,
-          claudeSessionId,
-          onSessionFound,
-          onMessage: opts.onMessage,
-          onThinkingChange: opts.onThinkingChange,
-          nextMessage: opts.waitForRemoteMessage,
-          permissionMode: opts.permissionMode,
-          abort: abortController.signal,
-          hookSettingsPath: opts.hookSettingsPath,
-          claudeArgs: opts.claudeArgs,
-          log
-        });
-        if (result === "switch") {
-          mode = "local";
-          opts.onModeChange(mode);
-        } else {
-          return 0;
-        }
-        break;
-      }
-    }
-  }
-}
-
-const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
-const ENV_FILE = join(SVAMP_HOME, ".env");
-const DAEMON_STATE_FILE = join(SVAMP_HOME, "daemon.state.json");
-const DEBUG = !!process.env.DEBUG;
-const log = (...args) => {
-  if (DEBUG) console.error("[svamp]", ...args);
-};
-async function runInteractive(options) {
-  const cwd = options.directory;
-  const sessionId = randomUUID();
-  const permissionMode = options.permissionMode || "default";
-  log(`Starting interactive session: ${sessionId}`);
-  log(`Directory: ${cwd}`);
-  loadDotEnv();
-  let server = null;
-  let sessionService = null;
-  const serverUrl = process.env.HYPHA_SERVER_URL;
-  const token = process.env.HYPHA_TOKEN;
-  if (serverUrl && token) {
-    try {
-      const origLog = console.log;
-      const origWarn = console.warn;
-      console.log = () => {
-      };
-      console.warn = () => {
-      };
-      server = await connectToHypha({ serverUrl, token, name: "svamp-interactive" });
-      console.log = origLog;
-      console.warn = origWarn;
-      log("Connected to Hypha");
-    } catch (err) {
-      console.error(`\x1B[33mNote:\x1B[0m Could not connect to Hypha (${err.message}). Running in offline mode.`);
-    }
-  } else {
-    console.error("\x1B[33mNote:\x1B[0m No Hypha credentials found. Running in offline mode.");
-    console.error('  Run "svamp login <url>" to enable cloud sync.\n');
-  }
-  const messageQueue = [];
-  let messageWaiter = null;
-  function enqueueMessage(text) {
-    if (messageWaiter) {
-      const w = messageWaiter;
-      messageWaiter = null;
-      w.resolve(text);
-    } else {
-      messageQueue.push(text);
-    }
-  }
-  function waitForRemoteMessage() {
-    if (messageQueue.length > 0) {
-      return Promise.resolve(messageQueue.shift());
-    }
-    return new Promise((resolve) => {
-      messageWaiter = { resolve };
-    });
-  }
-  function hasRemoteMessage() {
-    return messageQueue.length > 0;
-  }
-  const machineId = readMachineId();
-  const metadata = {
-    path: cwd,
-    host: os.hostname(),
-    os: os.platform(),
-    machineId: machineId || void 0,
-    homeDir: os.homedir(),
-    svampHomeDir: SVAMP_HOME,
-    svampLibDir: "",
-    svampToolsDir: "",
-    startedBy: "terminal",
-    lifecycleState: "running",
-    flavor: "claude"
-  };
-  if (server) {
-    const callbacks = {
-      onUserMessage: (content, _meta) => {
-        const text = typeof content === "string" ? content : content?.text || content?.content?.text || JSON.stringify(content);
-        log(`[hypha] User message received: ${text.slice(0, 80)}`);
-        enqueueMessage(text);
-      },
-      onAbort: () => {
-        log("[hypha] Abort requested");
-      },
-      onPermissionResponse: (_params) => {
-        log("[hypha] Permission response");
-      },
-      onSwitchMode: (mode) => {
-        log(`[hypha] Switch mode: ${mode}`);
-      },
-      onRestartClaude: async () => {
-        log("[hypha] Restart requested");
-        return { success: false, message: "Restart not supported in interactive mode" };
-      },
-      onKillSession: () => {
-        log("[hypha] Kill requested");
-        cleanup();
-        process.exit(0);
-      }
-    };
-    try {
-      sessionService = await registerSessionService(
-        server,
-        sessionId,
-        metadata,
-        { controlledByUser: true },
-        callbacks
-      );
-      log(`Session service registered: svamp-session-${sessionId}`);
-    } catch (err) {
-      console.error(`\x1B[33mNote:\x1B[0m Could not register session on Hypha (${err.message}).`);
-    }
-  }
-  let hookServer = null;
-  let hookSettings = null;
-  let claudeSessionId = options.resumeSessionId || null;
-  try {
-    hookServer = await startHookServer((id) => {
-      claudeSessionId = id;
-      log(`Claude session ID from hook: ${id}`);
-      if (sessionService) {
-        sessionService.updateMetadata({ ...metadata, claudeSessionId: id });
-      }
-    }, log);
-    hookSettings = generateHookSettings(hookServer.port);
-    log(`Hook settings: ${hookSettings.settingsPath}`);
-  } catch (err) {
-    log(`Failed to start hook server: ${err.message}`);
-  }
-  let keepAliveInterval = null;
-  if (sessionService) {
-    keepAliveInterval = setInterval(() => {
-      sessionService.sendKeepAlive(false);
-    }, 3e4);
-  }
-  const cleanup = async () => {
-    log("Cleaning up...");
-    if (keepAliveInterval) clearInterval(keepAliveInterval);
-    if (sessionService) {
-      sessionService.sendSessionEnd();
-      await sessionService.disconnect().catch(() => {
-      });
-    }
-    hookSettings?.cleanup();
-    hookServer?.stop();
-    if (server) {
-      await server.disconnect().catch(() => {
-      });
-    }
-    if (messageWaiter) {
-      messageWaiter.resolve(null);
-      messageWaiter = null;
-    }
-  };
-  let exiting = false;
-  const handleExit = async () => {
-    if (exiting) return;
-    exiting = true;
-    await cleanup();
-    process.exit(0);
-  };
-  process.on("SIGTERM", handleExit);
-  process.on("SIGINT", handleExit);
-  const claudeArgs = [...options.claudeArgs || []];
-  if (options.resumeSessionId) ; else if (options.continueSession) {
-    claudeArgs.push("--continue");
-  }
-  console.log(`\x1B[36mSvamp interactive mode\x1B[0m`);
-  if (server && sessionService) {
-    console.log(`\x1B[90mSession synced to Hypha \u2014 visible in the web app\x1B[0m`);
-    console.log(`\x1B[90mSession ID: ${sessionId.slice(0, 8)}\x1B[0m`);
-  }
-  console.log("");
-  try {
-    const exitCode = await loop({
-      cwd,
-      startingMode: "local",
-      hookSettingsPath: hookSettings?.settingsPath || "",
-      permissionMode,
-      claudeArgs: claudeArgs.length > 0 ? claudeArgs : void 0,
-      log,
-      onModeChange: (mode) => {
-        log(`Mode changed: ${mode}`);
-        if (sessionService) {
-          sessionService.updateMetadata({ ...metadata, lifecycleState: "running" });
-          sessionService.sendKeepAlive(false, mode);
-        }
-      },
-      onSessionFound: (id) => {
-        claudeSessionId = id;
-        if (sessionService) {
-          sessionService.updateMetadata({ ...metadata, claudeSessionId: id });
-        }
-      },
-      onMessage: (msg) => {
-        if (!sessionService) return;
-        if (msg.type === "assistant" && msg.message) {
-          sessionService.pushMessage(msg.message, "agent");
-        } else if (msg.type === "user" && msg.message) {
-          const text = typeof msg.message.content === "string" ? msg.message.content : msg.message.content?.text || JSON.stringify(msg.message.content);
-          sessionService.pushMessage({ type: "text", text }, "user");
-        } else if (msg.type === "summary") {
-          sessionService.updateMetadata({
-            ...metadata,
-            claudeSessionId: claudeSessionId || void 0,
-            summary: { text: msg.summary || "", updatedAt: Date.now() }
-          });
-        }
-      },
-      onThinkingChange: (thinking) => {
-        if (sessionService) {
-          sessionService.sendKeepAlive(thinking);
-        }
-      },
-      waitForRemoteMessage,
-      hasRemoteMessage
-    });
-    await cleanup();
-    process.exit(exitCode);
-  } catch (err) {
-    log(`Loop error: ${err.message}`);
-    await cleanup();
-    process.exit(1);
-  }
-}
-function loadDotEnv() {
-  if (!existsSync(ENV_FILE)) return;
-  const lines = readFileSync(ENV_FILE, "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;
-  }
-}
-function readMachineId() {
-  try {
-    if (!existsSync(DAEMON_STATE_FILE)) return null;
-    const state = JSON.parse(readFileSync(DAEMON_STATE_FILE, "utf-8"));
-    return state.machineId || null;
-  } catch {
-    return null;
-  }
-}
-
-export { runInteractive };