svamp-cli 0.1.50 → 0.1.52

package/dist/run-K_S7pfZ-.mjs

@@ -1,1050 +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-BLySdZ1K.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);
-  }
-  if (opts.hookSettingsPath) {
-    args.push("--settings", opts.hookSettingsPath);
-  }
-  if (opts.claudeArgs) {
-    args.push(...opts.claudeArgs);
-  }
-  log(`[local] Spawning: claude ${args.join(" ")}`);
-  const claudeBin = findClaudeBinary();
-  if (!claudeBin) {
-    process.stderr.write("Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code\n");
-    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)) {
-    process.stderr.write("Claude Code CLI not found.\n");
-    return "exit";
-  }
-  const print = (s) => process.stderr.write(s + "\n");
-  print("\n\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m");
-  print("\x1B[36m  Remote mode\x1B[0m \u2014 processing message from web app");
-  print("\x1B[90m  Press Space Space to switch to local mode\x1B[0m");
-  print("\x1B[90m  Press Ctrl-C Ctrl-C to exit\x1B[0m");
-  print("\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) {
-        process.stderr.write("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m\n");
-      }
-    }
-  } 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",
-    "--print",
-    opts.message
-  ];
-  if (opts.hookSettingsPath) {
-    args.push("--settings", opts.hookSettingsPath);
-  }
-  if (opts.sessionId) {
-    args.push("--resume", opts.sessionId);
-  }
-  const claudeMode = mapPermissionMode(opts.permissionMode) || "bypassPermissions";
-  args.push("--permission-mode", claudeMode);
-  if (opts.claudeArgs) {
-    args.push(...opts.claudeArgs);
-  }
-  opts.log(`[remote] Spawning: claude ${args.join(" ")}`);
-  process.stderr.write(`
-\x1B[34m  \u25B6 User:\x1B[0m ${opts.message}
-
-`);
-  const spawnEnv = { ...process.env, CLAUDE_CODE_ENTRYPOINT: "sdk-ts" };
-  delete spawnEnv.CLAUDECODE;
-  const child = spawn(opts.claudeBin, args, {
-    stdio: ["pipe", "pipe", "pipe"],
-    cwd: opts.cwd,
-    env: spawnEnv
-  });
-  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;
-      }
-      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": {
-      write(`
-\x1B[32m[done]\x1B[0m
-`);
-      break;
-    }
-    default:
-      opts.log(`[remote] Unknown msg type: ${msg.type}`);
-  }
-}
-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 {
-      suppressHyphaLogs();
-      server = await connectToHypha({ serverUrl, token, name: "svamp-interactive" });
-      log("Connected to Hypha");
-    } catch (err) {
-      restoreConsoleLogs();
-      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"
-  };
-  let currentMode = "local";
-  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);
-      },
-      // File system operations — run locally since we have direct access
-      // All callbacks use try/catch to prevent errors from leaking
-      // through hypha-rpc's error handler to the terminal
-      onBash: async (command, execCwd) => {
-        try {
-          const { execSync } = await import('child_process');
-          const result = execSync(command, {
-            cwd: execCwd || cwd,
-            encoding: "utf-8",
-            timeout: 3e4,
-            maxBuffer: 1024 * 1024
-          });
-          return { output: result };
-        } catch (err) {
-          return { output: err.stdout || "", error: err.message, exitCode: err.status || 1 };
-        }
-      },
-      onReadFile: async (path) => {
-        try {
-          const { readFileSync: readFileSync2 } = await import('fs');
-          return readFileSync2(path, "utf-8");
-        } catch (err) {
-          throw new Error(`Cannot read file: ${err.message}`);
-        }
-      },
-      onWriteFile: async (path, content) => {
-        try {
-          const { writeFileSync } = await import('fs');
-          writeFileSync(path, content, "utf-8");
-        } catch (err) {
-          throw new Error(`Cannot write file: ${err.message}`);
-        }
-      },
-      onListDirectory: async (path) => {
-        const { readdirSync, statSync } = await import('fs');
-        const { join: joinPath } = await import('path');
-        return readdirSync(path).map((name) => {
-          try {
-            const st = statSync(joinPath(path, name));
-            return { name, type: st.isDirectory() ? "directory" : "file", size: st.size };
-          } catch {
-            return { name, type: "unknown", size: 0 };
-          }
-        });
-      },
-      onRipgrep: async (rgArgs, execCwd) => {
-        try {
-          const { execSync } = await import('child_process');
-          return execSync(`rg ${rgArgs}`, {
-            cwd: execCwd || cwd,
-            encoding: "utf-8",
-            timeout: 15e3,
-            maxBuffer: 1024 * 1024
-          });
-        } catch (err) {
-          return err.stdout || "";
-        }
-      }
-    };
-    try {
-      sessionService = await registerSessionService(
-        server,
-        sessionId,
-        metadata,
-        { controlledByUser: true },
-        callbacks
-      );
-      log(`Session service registered: svamp-session-${sessionId}`);
-    } catch (err) {
-      restoreConsoleLogs();
-      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;
-    }
-    restoreConsoleLogs();
-  };
-  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");
-  }
-  restoreConsoleLogs();
-  console.log(`\x1B[36mSvamp interactive mode\x1B[0m`);
-  if (server && sessionService) {
-    const serviceId = sessionService.serviceInfo?.id || `svamp-session-${sessionId}`;
-    const slashIdx = serviceId.indexOf("/");
-    const colonIdx = serviceId.indexOf(":");
-    let serviceUrl = "";
-    if (slashIdx > 0 && colonIdx > slashIdx) {
-      const workspace = serviceId.slice(0, slashIdx);
-      const clientAndService = serviceId.slice(slashIdx + 1);
-      serviceUrl = `${serverUrl}/${workspace}/services/${clientAndService}`;
-    }
-    console.log(`\x1B[90mSession synced to Hypha \u2014 visible in the web app\x1B[0m`);
-    if (serviceUrl) {
-      console.log(`\x1B[90mService:    ${serviceUrl}\x1B[0m`);
-    }
-    console.log(`\x1B[90mSession ID: ${sessionId.slice(0, 8)}\x1B[0m`);
-  }
-  console.log("");
-  if (server) suppressHyphaLogs();
-  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}`);
-        currentMode = mode;
-        if (sessionService) {
-          sessionService.updateAgentState({
-            controlledByUser: mode === "local"
-          });
-          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({
-            type: "assistant",
-            message: 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;
-  }
-}
-let _origLog = null;
-let _origWarn = null;
-let _origInfo = null;
-let _origDebug = null;
-let _origError = null;
-let _origStdoutWrite = null;
-let _origStderrWrite = null;
-const HYPHA_LOG_PATTERNS = [
-  "WebSocket connection",
-  "Connection established",
-  "reporting services",
-  "Successfully registered",
-  "Subscribing to",
-  "Successfully subscribed",
-  "Cleaning up all sessions",
-  "Cleaned up session",
-  "ClTaned up",
-  "Cleaned up ",
-  "Handling disconnection",
-  "Client ws-user-",
-  "WebSocket connection disconnected",
-  "disconnected, cleaning up",
-  "HYPHA SESSION",
-  "Listener registered",
-  "local RPC disconnection",
-  "not found for method",
-  "likely cleaned up",
-  "Promise method",
-  "not available (detected by session type)",
-  "Session ",
-  // catch-all for "Session X not found" etc.
-  "Failed to find method",
-  "Method not found",
-  "Error during calling method",
-  "Timeout subscribing",
-  "Manager does not support subscribe"
-];
-function isHyphaLogLine(text) {
-  return HYPHA_LOG_PATTERNS.some((p) => text.includes(p));
-}
-function suppressHyphaLogs() {
-  if (_origLog) return;
-  _origLog = console.log;
-  _origWarn = console.warn;
-  _origInfo = console.info;
-  _origDebug = console.debug;
-  _origError = console.error;
-  _origStdoutWrite = process.stdout.write.bind(process.stdout);
-  _origStderrWrite = process.stderr.write.bind(process.stderr);
-  console.log = (...args) => {
-    if (DEBUG) _origLog.call(console, "[hypha-log]", ...args);
-  };
-  console.warn = (...args) => {
-    if (DEBUG) _origWarn.call(console, "[hypha-warn]", ...args);
-  };
-  console.info = (...args) => {
-    if (DEBUG) _origInfo.call(console, "[hypha-info]", ...args);
-  };
-  console.debug = (...args) => {
-    if (DEBUG) _origDebug.call(console, "[hypha-debug]", ...args);
-  };
-  console.error = (...args) => {
-    const text = args.map((a) => typeof a === "string" ? a : String(a)).join(" ");
-    if (isHyphaLogLine(text)) {
-      if (DEBUG) _origError.call(console, "[hypha-err]", ...args);
-      return;
-    }
-    _origError.call(console, ...args);
-  };
-  process.stdout.write = function(chunk, ...rest) {
-    const text = typeof chunk === "string" ? chunk : chunk?.toString?.() || "";
-    if (isHyphaLogLine(text)) {
-      if (DEBUG) _origStdoutWrite(`[hypha-stdout] ${text}`);
-      return true;
-    }
-    return _origStdoutWrite.call(process.stdout, chunk, ...rest);
-  };
-  process.stderr.write = function(chunk, ...rest) {
-    const text = typeof chunk === "string" ? chunk : chunk?.toString?.() || "";
-    if (isHyphaLogLine(text)) {
-      if (DEBUG) _origStderrWrite(`[hypha-stderr] ${text}`);
-      return true;
-    }
-    return _origStderrWrite.call(process.stderr, chunk, ...rest);
-  };
-}
-function restoreConsoleLogs() {
-  if (!_origLog) return;
-  console.log = _origLog;
-  console.warn = _origWarn;
-  console.info = _origInfo;
-  console.debug = _origDebug;
-  console.error = _origError;
-  if (_origStdoutWrite) {
-    process.stdout.write = _origStdoutWrite;
-  }
-  if (_origStderrWrite) {
-    process.stderr.write = _origStderrWrite;
-  }
-  _origLog = null;
-  _origWarn = null;
-  _origInfo = null;
-  _origDebug = null;
-  _origError = null;
-  _origStdoutWrite = null;
-  _origStderrWrite = null;
-}
-
-export { runInteractive };