svamp-cli 0.2.17 → 0.2.19

package/dist/{agentCommands-Db074BKd.mjs → agentCommands-BVCrgVdi.mjs}

@@ -148,7 +148,7 @@ async function sessionBroadcast(action, args) {
   console.log(`Broadcast sent: ${action}`);
 }
 async function connectToMachineService() {
-  const { connectAndGetMachine } = await import('./commands-D7JEuzau.mjs');
+  const { connectAndGetMachine } = await import('./commands-Bz4ax0Fl.mjs');
   return connectAndGetMachine();
 }
 async function inboxSend(targetSessionId, opts) {
@@ -165,7 +165,7 @@ async function inboxSend(targetSessionId, opts) {
   }
   const { server, machine } = await connectToMachineService();
   try {
-    const { resolveSessionId } = await import('./commands-D7JEuzau.mjs');
+    const { resolveSessionId } = await import('./commands-Bz4ax0Fl.mjs');
     const sessions = await machine.listSessions();
     const match = resolveSessionId(sessions, targetSessionId);
     const fullTargetId = match.sessionId;

package/dist/caddy-fJWXn1kE.mjs

@@ -0,0 +1,325 @@
+import { spawn, execSync } from 'child_process';
+import { mkdirSync, existsSync, statSync, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform, arch } from 'os';
+
+const CADDY_VERSION = "2.9.1";
+const BIN_DIR = join(homedir(), ".svamp", "bin");
+const CADDY_BIN = join(BIN_DIR, platform() === "win32" ? "caddy.exe" : "caddy");
+const ADMIN_PORT = 2019;
+const DEFAULT_LISTEN_PORT = 18080;
+function getCaddyDownloadUrl() {
+  const os = platform();
+  const a = arch();
+  let osStr;
+  let archStr;
+  switch (os) {
+    case "darwin":
+      osStr = "mac";
+      break;
+    case "linux":
+      osStr = "linux";
+      break;
+    case "win32":
+      osStr = "windows";
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+  switch (a) {
+    case "x64":
+      archStr = "amd64";
+      break;
+    case "arm64":
+      archStr = "arm64";
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${a}`);
+  }
+  const ext = os === "win32" ? "zip" : "tar.gz";
+  return `https://github.com/caddyserver/caddy/releases/download/v${CADDY_VERSION}/caddy_${CADDY_VERSION}_${osStr}_${archStr}.${ext}`;
+}
+function isCaddyAvailable() {
+  if (existsSync(CADDY_BIN)) return true;
+  try {
+    execSync("caddy version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCaddyPath() {
+  if (existsSync(CADDY_BIN)) return CADDY_BIN;
+  return "caddy";
+}
+async function ensureCaddy(log) {
+  if (existsSync(CADDY_BIN)) return CADDY_BIN;
+  const logger = log || console.log;
+  mkdirSync(BIN_DIR, { recursive: true });
+  const url = getCaddyDownloadUrl();
+  logger(`Downloading Caddy ${CADDY_VERSION} from ${url}...`);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download Caddy: ${response.status} ${response.statusText}`);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (platform() === "win32") {
+    throw new Error("Windows ZIP extraction not implemented \u2014 please install caddy manually");
+  }
+  const tmpTar = join(BIN_DIR, `caddy-${CADDY_VERSION}.tar.gz`);
+  writeFileSync(tmpTar, buffer);
+  try {
+    execSync(
+      `tar -xzf "${tmpTar}" -C "${BIN_DIR}" caddy`,
+      { stdio: "pipe" }
+    );
+    chmodSync(CADDY_BIN, 493);
+    logger(`Caddy installed at ${CADDY_BIN}`);
+  } finally {
+    try {
+      unlinkSync(tmpTar);
+    } catch {
+    }
+  }
+  return CADDY_BIN;
+}
+const CORS_HEADERS_HANDLER = {
+  handler: "headers",
+  response: {
+    set: {
+      "Access-Control-Allow-Origin": ["*"],
+      "Access-Control-Allow-Methods": ["GET, POST, PUT, DELETE, OPTIONS"],
+      "Access-Control-Allow-Headers": ["*"]
+    }
+  }
+};
+function generateCaddyConfig(listenPort, mounts, adminPort = ADMIN_PORT) {
+  const routes = [];
+  for (const mount of mounts) {
+    if (mount.isFile) {
+      const parentDir = mount.directory.replace(/[\\/][^\\/]+$/, "") || "/";
+      const fileName = mount.directory.replace(/.*[\\/]/, "");
+      routes.push({
+        match: [{ path: [`/${mount.name}`] }],
+        handle: [
+          CORS_HEADERS_HANDLER,
+          { handler: "rewrite", uri: `/${fileName}` },
+          { handler: "file_server", root: parentDir }
+        ]
+      });
+    } else {
+      const fileServerHandler = { handler: "file_server", root: mount.directory };
+      if (mount.browse !== false) fileServerHandler.browse = {};
+      routes.push({
+        match: [{ path: [`/${mount.name}/*`, `/${mount.name}`] }],
+        handle: [
+          CORS_HEADERS_HANDLER,
+          { handler: "rewrite", strip_path_prefix: `/${mount.name}` },
+          fileServerHandler
+        ]
+      });
+    }
+  }
+  routes.push({
+    match: [{ path: ["/"] }],
+    handle: [
+      CORS_HEADERS_HANDLER,
+      {
+        handler: "static_response",
+        status_code: 200,
+        headers: { "Content-Type": ["text/html; charset=utf-8"] },
+        body: generateMountListHtml(mounts)
+      }
+    ]
+  });
+  routes.push({
+    handle: [
+      CORS_HEADERS_HANDLER,
+      { handler: "static_response", status_code: 404, body: "Not Found" }
+    ]
+  });
+  return {
+    admin: {
+      listen: `127.0.0.1:${adminPort}`
+    },
+    apps: {
+      http: {
+        servers: {
+          srv0: {
+            listen: [`127.0.0.1:${listenPort}`],
+            routes
+          }
+        }
+      }
+    }
+  };
+}
+function generateMountListHtml(mounts) {
+  const items = mounts.map(
+    (m) => `<li><a href="/${m.name}/">${m.name}</a> \u2014 ${m.directory}</li>`
+  ).join("\n");
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>Svamp File Server</title>
+<style>
+body{font-family:system-ui,sans-serif;max-width:700px;margin:40px auto;padding:0 20px;color:#333}
+h1{font-size:1.3rem}
+ul{list-style:none;padding:0}
+li{padding:8px 0;border-bottom:1px solid #eee}
+a{color:#0969da;text-decoration:none;font-weight:500}
+a:hover{text-decoration:underline}
+</style>
+</head><body>
+<h1>Svamp File Server</h1>
+<ul>${items || "<li>No mounts registered.</li>"}</ul>
+</body></html>`;
+}
+class CaddyManager {
+  process = null;
+  mounts = /* @__PURE__ */ new Map();
+  listenPort;
+  adminPort;
+  log;
+  configPath;
+  constructor(options = {}) {
+    this.listenPort = options.listenPort || DEFAULT_LISTEN_PORT;
+    this.adminPort = options.adminPort || ADMIN_PORT;
+    this.log = options.log || ((msg) => console.log(`[CADDY] ${msg}`));
+    const configDir = options.configDir || join(homedir(), ".svamp", "caddy");
+    mkdirSync(configDir, { recursive: true });
+    this.configPath = join(configDir, "config.json");
+  }
+  /** Start Caddy if not already running. */
+  async start() {
+    if (this.process) return;
+    const caddyPath = await ensureCaddy(this.log);
+    this.writeConfig();
+    return new Promise((resolve, reject) => {
+      const child = spawn(caddyPath, ["run", "--config", this.configPath], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env }
+      });
+      this.process = child;
+      let resolved = false;
+      const onOutput = (data) => {
+        const text = data.toString().trim();
+        if (!text) return;
+        if (text.includes("serving initial configuration")) {
+          if (!resolved) {
+            resolved = true;
+            this.log(`Caddy started on 127.0.0.1:${this.listenPort}`);
+            resolve();
+          }
+        }
+        if (text.includes('"level":"error"')) {
+          this.log(`Caddy error: ${text}`);
+        }
+      };
+      child.stdout?.on("data", onOutput);
+      child.stderr?.on("data", onOutput);
+      child.on("error", (err) => {
+        if (!resolved) {
+          resolved = true;
+          reject(err);
+        }
+      });
+      child.on("exit", (code) => {
+        this.process = null;
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(`Caddy exited with code ${code}`));
+        }
+      });
+      setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      }, 1e4);
+    });
+  }
+  /** Stop the Caddy process. */
+  async stop() {
+    if (!this.process) return;
+    try {
+      await fetch(`http://127.0.0.1:${this.adminPort}/stop`, { method: "POST" });
+    } catch {
+      this.process.kill("SIGTERM");
+    }
+    await new Promise((resolve) => {
+      if (!this.process) {
+        resolve();
+        return;
+      }
+      const timeout = setTimeout(() => {
+        try {
+          this.process?.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, 5e3);
+      this.process.on("exit", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+    this.process = null;
+    this.log("Caddy stopped");
+  }
+  /** Add a mount and reload config. */
+  async addMount(name, directory, browse = true) {
+    const isFile = existsSync(directory) && statSync(directory).isFile();
+    this.mounts.set(name, { name, directory, browse, isFile });
+    await this.reloadConfig();
+    this.log(`Mount added: ${name} \u2192 ${directory}`);
+  }
+  /** Remove a mount and reload config. */
+  async removeMount(name) {
+    if (!this.mounts.has(name)) {
+      throw new Error(`Mount '${name}' not found`);
+    }
+    this.mounts.delete(name);
+    await this.reloadConfig();
+    this.log(`Mount removed: ${name}`);
+  }
+  /** Get all current mounts. */
+  getMounts() {
+    return Array.from(this.mounts.values());
+  }
+  /** Whether Caddy is running. */
+  get isRunning() {
+    return this.process !== null;
+  }
+  /** The port Caddy listens on. */
+  get port() {
+    return this.listenPort;
+  }
+  // ── Internal ─────────────────────────────────────────────────────
+  writeConfig() {
+    const config = generateCaddyConfig(this.listenPort, Array.from(this.mounts.values()), this.adminPort);
+    writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+  }
+  async reloadConfig() {
+    this.writeConfig();
+    if (!this.process) return;
+    try {
+      const config = generateCaddyConfig(this.listenPort, Array.from(this.mounts.values()), this.adminPort);
+      const resp = await fetch(`http://127.0.0.1:${this.adminPort}/load`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(config)
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        this.log(`Config reload failed: ${resp.status} ${body}`);
+        await this.stop();
+        await this.start();
+      }
+    } catch (err) {
+      this.log(`Config reload error: ${err.message} \u2014 restarting Caddy`);
+      await this.stop();
+      await this.start();
+    }
+  }
+}
+
+export { CaddyManager, ensureCaddy, generateCaddyConfig, getCaddyPath, isCaddyAvailable };

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-CjIqQldq.mjs';
+import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-RmC13Tl0.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -36,7 +36,7 @@ async function main() {
     await logoutFromHypha();
   } else if (subcommand === "daemon") {
     if (daemonSubcommand === "restart") {
-      const { restartDaemon } = await import('./run-CjIqQldq.mjs').then(function (n) { return n.k; });
+      const { restartDaemon } = await import('./run-RmC13Tl0.mjs').then(function (n) { return n.k; });
       await restartDaemon();
       process.exit(0);
     }
@@ -238,7 +238,7 @@ async function main() {
       console.error("svamp service: Service commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { handleServiceCommand } = await import('./commands-BJJTEZD4.mjs');
+    const { handleServiceCommand } = await import('./commands-nqemVu6x.mjs');
     await handleServiceCommand();
   } else if (subcommand === "serve") {
     const { isSandboxed: isSandboxedServe } = await import('./sandboxDetect-DNTcbgWD.mjs');
@@ -246,7 +246,7 @@ async function main() {
       console.error("svamp serve: Serve commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { handleServeCommand } = await import('./serveCommands-DDcqg1UE.mjs');
+    const { handleServeCommand } = await import('./serveCommands-DjrDHb1P.mjs');
     await handleServeCommand();
     process.exit(0);
   } else if (subcommand === "process" || subcommand === "proc") {
@@ -255,7 +255,7 @@ async function main() {
       console.error("svamp process: Process commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { processCommand } = await import('./commands-CClggVP2.mjs');
+    const { processCommand } = await import('./commands-BLKQjEXZ.mjs');
     let machineId;
     const processArgs = args.slice(1);
     const mIdx = processArgs.findIndex((a) => a === "--machine" || a === "-m");
@@ -273,7 +273,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-CUYYyFK6.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-DqW3pzdH.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);
@@ -282,7 +282,7 @@ async function main() {
   }
 }
 async function handleInteractiveCommand() {
-  const { runInteractive } = await import('./run-Dj5-JlUt.mjs');
+  const { runInteractive } = await import('./run-DpjvWCbf.mjs');
   const interactiveArgs = subcommand === "start" ? args.slice(1) : args;
   let directory = process.cwd();
   let resumeSessionId;
@@ -327,7 +327,7 @@ async function handleAgentCommand() {
     return;
   }
   if (agentArgs[0] === "list") {
-    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-CjIqQldq.mjs').then(function (n) { return n.i; });
+    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-RmC13Tl0.mjs').then(function (n) { return n.i; });
     console.log("Known agents:");
     for (const [name, config2] of Object.entries(KNOWN_ACP_AGENTS)) {
       console.log(`  ${name.padEnd(12)} ${config2.command} ${config2.args.join(" ")}  (ACP)`);
@@ -339,7 +339,7 @@ async function handleAgentCommand() {
     console.log('Use "svamp agent -- <command> [args]" for a custom ACP agent.');
     return;
   }
-  const { resolveAcpAgentConfig, KNOWN_MCP_AGENTS } = await import('./run-CjIqQldq.mjs').then(function (n) { return n.i; });
+  const { resolveAcpAgentConfig, KNOWN_MCP_AGENTS } = await import('./run-RmC13Tl0.mjs').then(function (n) { return n.i; });
   let cwd = process.cwd();
   const filteredArgs = [];
   for (let i = 0; i < agentArgs.length; i++) {
@@ -363,12 +363,12 @@ async function handleAgentCommand() {
   console.log(`Starting ${config.agentName} agent in ${cwd}...`);
   let backend;
   if (KNOWN_MCP_AGENTS[config.agentName]) {
-    const { CodexMcpBackend } = await import('./run-CjIqQldq.mjs').then(function (n) { return n.j; });
+    const { CodexMcpBackend } = await import('./run-RmC13Tl0.mjs').then(function (n) { return n.j; });
     backend = new CodexMcpBackend({ cwd, log: logFn });
   } else {
-    const { AcpBackend } = await import('./run-CjIqQldq.mjs').then(function (n) { return n.h; });
-    const { GeminiTransport } = await import('./run-CjIqQldq.mjs').then(function (n) { return n.G; });
-    const { DefaultTransport } = await import('./run-CjIqQldq.mjs').then(function (n) { return n.D; });
+    const { AcpBackend } = await import('./run-RmC13Tl0.mjs').then(function (n) { return n.h; });
+    const { GeminiTransport } = await import('./run-RmC13Tl0.mjs').then(function (n) { return n.G; });
+    const { DefaultTransport } = await import('./run-RmC13Tl0.mjs').then(function (n) { return n.D; });
     const transportHandler = config.agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(config.agentName);
     backend = new AcpBackend({
       agentName: config.agentName,
@@ -495,7 +495,7 @@ async function handleSessionCommand() {
       process.exit(1);
     }
   }
-  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait, sessionShare, sessionRalphStart, sessionRalphCancel, sessionRalphStatus, sessionInboxSend, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxClear } = await import('./commands-D7JEuzau.mjs');
+  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait, sessionShare, sessionRalphStart, sessionRalphCancel, sessionRalphStatus, sessionInboxSend, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxClear } = await import('./commands-Bz4ax0Fl.mjs');
   const parseFlagStr = (flag, shortFlag) => {
     for (let i = 1; i < sessionArgs.length; i++) {
       if ((sessionArgs[i] === flag || shortFlag) && i + 1 < sessionArgs.length) {
@@ -555,7 +555,7 @@ async function handleSessionCommand() {
         allowDomain.push(sessionArgs[++i]);
       }
     }
-    const { parseShareArg } = await import('./commands-D7JEuzau.mjs');
+    const { parseShareArg } = await import('./commands-Bz4ax0Fl.mjs');
     const shareEntries = share.map((s) => parseShareArg(s));
     await sessionSpawn(agent, dir, targetMachineId, {
       message,
@@ -641,7 +641,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session approve <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionApprove } = await import('./commands-D7JEuzau.mjs');
+    const { sessionApprove } = await import('./commands-Bz4ax0Fl.mjs');
     const approveReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionApprove(sessionArgs[1], approveReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -651,7 +651,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session deny <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionDeny } = await import('./commands-D7JEuzau.mjs');
+    const { sessionDeny } = await import('./commands-Bz4ax0Fl.mjs');
     const denyReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionDeny(sessionArgs[1], denyReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -687,7 +687,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session set-title <title>");
       process.exit(1);
     }
-    const { sessionSetTitle } = await import('./agentCommands-Db074BKd.mjs');
+    const { sessionSetTitle } = await import('./agentCommands-BVCrgVdi.mjs');
     await sessionSetTitle(title);
   } else if (sessionSubcommand === "set-link") {
     const url = sessionArgs[1];
@@ -696,7 +696,7 @@ async function handleSessionCommand() {
       process.exit(1);
     }
     const label = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
-    const { sessionSetLink } = await import('./agentCommands-Db074BKd.mjs');
+    const { sessionSetLink } = await import('./agentCommands-BVCrgVdi.mjs');
     await sessionSetLink(url, label);
   } else if (sessionSubcommand === "notify") {
     const message = sessionArgs[1];
@@ -705,7 +705,7 @@ async function handleSessionCommand() {
       process.exit(1);
     }
     const level = parseFlagStr("--level") || "info";
-    const { sessionNotify } = await import('./agentCommands-Db074BKd.mjs');
+    const { sessionNotify } = await import('./agentCommands-BVCrgVdi.mjs');
     await sessionNotify(message, level);
   } else if (sessionSubcommand === "broadcast") {
     const action = sessionArgs[1];
@@ -713,7 +713,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session broadcast <action> [args...]\nActions: open-canvas <url> [label], close-canvas, toast <message>");
       process.exit(1);
     }
-    const { sessionBroadcast } = await import('./agentCommands-Db074BKd.mjs');
+    const { sessionBroadcast } = await import('./agentCommands-BVCrgVdi.mjs');
     await sessionBroadcast(action, sessionArgs.slice(2).filter((a) => !a.startsWith("--")));
   } else if (sessionSubcommand === "inbox") {
     const inboxSubcmd = sessionArgs[1];
@@ -724,7 +724,7 @@ async function handleSessionCommand() {
         process.exit(1);
       }
       if (agentSessionId) {
-        const { inboxSend } = await import('./agentCommands-Db074BKd.mjs');
+        const { inboxSend } = await import('./agentCommands-BVCrgVdi.mjs');
         await inboxSend(sessionArgs[2], {
           body: sessionArgs[3],
           subject: parseFlagStr("--subject"),
@@ -739,7 +739,7 @@ async function handleSessionCommand() {
       }
     } else if (inboxSubcmd === "list" || inboxSubcmd === "ls") {
       if (agentSessionId && !sessionArgs[2]) {
-        const { inboxList } = await import('./agentCommands-Db074BKd.mjs');
+        const { inboxList } = await import('./agentCommands-BVCrgVdi.mjs');
         await inboxList({
           unread: hasFlag("--unread"),
           limit: parseFlagInt("--limit"),
@@ -761,7 +761,7 @@ async function handleSessionCommand() {
         process.exit(1);
       }
       if (agentSessionId && !sessionArgs[3]) {
-        const { inboxList } = await import('./agentCommands-Db074BKd.mjs');
+        const { inboxList } = await import('./agentCommands-BVCrgVdi.mjs');
         await sessionInboxRead(agentSessionId, sessionArgs[2], targetMachineId);
       } else if (sessionArgs[3]) {
         await sessionInboxRead(sessionArgs[2], sessionArgs[3], targetMachineId);
@@ -771,7 +771,7 @@ async function handleSessionCommand() {
       }
     } else if (inboxSubcmd === "reply") {
       if (agentSessionId && sessionArgs[2] && sessionArgs[3] && !sessionArgs[4]) {
-        const { inboxReply } = await import('./agentCommands-Db074BKd.mjs');
+        const { inboxReply } = await import('./agentCommands-BVCrgVdi.mjs');
         await inboxReply(sessionArgs[2], sessionArgs[3]);
       } else if (sessionArgs[2] && sessionArgs[3] && sessionArgs[4]) {
         await sessionInboxReply(sessionArgs[2], sessionArgs[3], sessionArgs[4], targetMachineId);
@@ -807,7 +807,7 @@ async function handleMachineCommand() {
     return;
   }
   if (machineSubcommand === "share") {
-    const { machineShare } = await import('./commands-D7JEuzau.mjs');
+    const { machineShare } = await import('./commands-Bz4ax0Fl.mjs');
     let machineId;
     const shareArgs = [];
     for (let i = 1; i < machineArgs.length; i++) {
@@ -837,7 +837,7 @@ async function handleMachineCommand() {
     }
     await machineShare(machineId, { add, remove, list, configPath, showConfig });
   } else if (machineSubcommand === "exec") {
-    const { machineExec } = await import('./commands-D7JEuzau.mjs');
+    const { machineExec } = await import('./commands-Bz4ax0Fl.mjs');
     let machineId;
     let cwd;
     const cmdParts = [];
@@ -857,7 +857,7 @@ async function handleMachineCommand() {
     }
     await machineExec(machineId, command, cwd);
   } else if (machineSubcommand === "info") {
-    const { machineInfo } = await import('./commands-D7JEuzau.mjs');
+    const { machineInfo } = await import('./commands-Bz4ax0Fl.mjs');
     let machineId;
     for (let i = 1; i < machineArgs.length; i++) {
       if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
@@ -877,10 +877,10 @@ async function handleMachineCommand() {
         level = machineArgs[++i];
       }
     }
-    const { machineNotify } = await import('./agentCommands-Db074BKd.mjs');
+    const { machineNotify } = await import('./agentCommands-BVCrgVdi.mjs');
     await machineNotify(message, level);
   } else if (machineSubcommand === "ls") {
-    const { machineLs } = await import('./commands-D7JEuzau.mjs');
+    const { machineLs } = await import('./commands-Bz4ax0Fl.mjs');
     let machineId;
     let showHidden = false;
     let path;
@@ -908,7 +908,7 @@ async function handleSkillsCommand() {
     printSkillsHelp();
     return;
   }
-  const { skillsFind, skillsInstall, skillsList, skillsRemove, skillsPublish } = await import('./commands-DJoYOM_1.mjs');
+  const { skillsFind, skillsInstall, skillsList, skillsRemove, skillsPublish } = await import('./commands-GMLad6_u.mjs');
   if (skillsSubcommand === "find" || skillsSubcommand === "search") {
     const query = skillsArgs.slice(1).filter((a) => !a.startsWith("--")).join(" ");
     if (!query) {

package/dist/{commands-CClggVP2.mjs → commands-BLKQjEXZ.mjs}

@@ -1,11 +1,11 @@
 import { writeFileSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { connectAndGetMachine } from './commands-D7JEuzau.mjs';
+import { connectAndGetMachine } from './commands-Bz4ax0Fl.mjs';
 import 'node:fs';
 import 'node:child_process';
 import 'node:path';
 import 'node:os';
-import './run-CjIqQldq.mjs';
+import './run-RmC13Tl0.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';

package/dist/{commands-D7JEuzau.mjs → commands-Bz4ax0Fl.mjs}

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { resolve, join } from 'node:path';
 import os from 'node:os';
-import { l as loadSecurityContextConfig, e as resolveSecurityContext, f as buildSecurityContextFromFlags, m as mergeSecurityContexts, c as connectToHypha } from './run-CjIqQldq.mjs';
+import { l as loadSecurityContextConfig, e as resolveSecurityContext, f as buildSecurityContextFromFlags, m as mergeSecurityContexts, c as connectToHypha } from './run-RmC13Tl0.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{commands-DJoYOM_1.mjs → commands-GMLad6_u.mjs}

@@ -1,11 +1,11 @@
-import os__default from 'os';
+import os from 'os';
 import fs__default from 'fs';
 import { join, resolve, relative } from 'path';
 
 const SKILLS_SERVER = process.env.HYPHA_SKILLS_SERVER || "https://hypha.aicell.io";
 const SKILLS_WORKSPACE = process.env.HYPHA_SKILLS_WORKSPACE || "hypha-cloud";
 const SKILLS_COLLECTION = process.env.HYPHA_SKILLS_COLLECTION || "marketplace";
-const SKILLS_DIR = join(os__default.homedir(), ".claude", "skills");
+const SKILLS_DIR = join(os.homedir(), ".claude", "skills");
 function getArtifactBaseUrl() {
   return `${SKILLS_SERVER}/${SKILLS_WORKSPACE}/artifacts`;
 }
@@ -125,7 +125,7 @@ function normalizeSkill(item) {
   };
 }
 
-const SVAMP_HOME = process.env.SVAMP_HOME || join(os__default.homedir(), ".svamp");
+const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
 const ENV_FILE = join(SVAMP_HOME, ".env");
 function loadDotEnv() {
   if (!fs__default.existsSync(ENV_FILE)) return;