svamp-cli 0.2.289 → 0.2.291

package/dist/commands-B9puiDBS.mjs

@@ -0,0 +1,329 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import os from 'node:os';
+import { a3 as ChannelStore, a4 as gatewayBase, a5 as genKey } from './run-CKLU1B02.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'util';
+import 'http';
+import 'net';
+import 'node:events';
+import '@agentclientprotocol/sdk';
+import 'node:readline';
+import 'node:fs/promises';
+import 'node:util';
+import 'yaml';
+
+const DEFAULT_DOWNLOAD_BASE = "https://github.com/amun-ai/hypha-cloud/releases/latest/download";
+function shq(v) {
+  return `'${String(v).replace(/'/g, `'\\''`)}'`;
+}
+function psq(v) {
+  return `'${String(v).replace(/'/g, `''`)}'`;
+}
+function buildOutpostInstall(params) {
+  const base = params.serverBase.replace(/\/$/, "");
+  const dl = (params.downloadBase || DEFAULT_DOWNLOAD_BASE).replace(/\/$/, "");
+  const session = params.session || params.channel;
+  const q = `channel=${encodeURIComponent(params.channel)}&token=${encodeURIComponent(params.token)}&session=${encodeURIComponent(session)}&dl=${encodeURIComponent(dl)}`;
+  const unix = `curl -fsSL ${shq(`${base}/outpost/install.sh?${q}`)} | SVAMP_OUTPOST_SERVER=${shq(base)} SVAMP_OUTPOST_CHANNEL=${shq(params.channel)} SVAMP_OUTPOST_TOKEN=${shq(params.token)} SVAMP_OUTPOST_SESSION=${shq(session)} sh`;
+  const windows = `$env:SVAMP_OUTPOST_SERVER=${psq(base)}; $env:SVAMP_OUTPOST_CHANNEL=${psq(params.channel)}; $env:SVAMP_OUTPOST_TOKEN=${psq(params.token)}; $env:SVAMP_OUTPOST_SESSION=${psq(session)}; irm ${psq(`${base}/outpost/install.ps1?${q}`)} | iex`;
+  const direct = `svamp-outpost --server ${shq(base)} --channel ${shq(params.channel)} --token ${shq(params.token)} --session ${shq(session)}`;
+  return { unix, windows, direct };
+}
+
+function loadConfig() {
+  const p = join(os.homedir(), ".svamp", "outpost.json");
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function saveConfig(cfg) {
+  writeFileSync(join(os.homedir(), ".svamp", "outpost.json"), JSON.stringify(cfg, null, 2));
+}
+function envVar(name) {
+  if (process.env[name]) return process.env[name];
+  try {
+    for (const line of readFileSync(join(os.homedir(), ".svamp", ".env"), "utf8").split("\n")) {
+      const m = line.match(/^\s*([A-Za-z0-9_]+)\s*=\s*(.*)\s*$/);
+      if (m && m[1] === name) return m[2].replace(/^["']|["']$/g, "");
+    }
+  } catch {
+  }
+  return void 0;
+}
+function machineId() {
+  try {
+    return JSON.parse(readFileSync(join(os.homedir(), ".svamp", "daemon.state.json"), "utf8")).machineId;
+  } catch {
+    return void 0;
+  }
+}
+function projectDir() {
+  try {
+    return execSync("git rev-parse --show-toplevel", { encoding: "utf8" }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+function remotesPath() {
+  return join(os.homedir(), ".svamp", "outpost-remotes.json");
+}
+function loadRemotes() {
+  try {
+    return JSON.parse(readFileSync(remotesPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function rememberRemote(channel, id, targeted = false) {
+  const all = loadRemotes();
+  const ch = all[channel] ||= {};
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  ch[id] = { firstSeen: ch[id]?.firstSeen || now, ...targeted ? { lastTargeted: now } : ch[id]?.lastTargeted ? { lastTargeted: ch[id].lastTargeted } : {} };
+  try {
+    writeFileSync(remotesPath(), JSON.stringify(all, null, 2));
+  } catch {
+  }
+}
+function forgetRemote(channel, id) {
+  const all = loadRemotes();
+  if (!all[channel]?.[id]) return false;
+  delete all[channel][id];
+  try {
+    writeFileSync(remotesPath(), JSON.stringify(all, null, 2));
+  } catch {
+  }
+  return true;
+}
+async function outpostUp(args) {
+  const session = process.env.SVAMP_SESSION_ID;
+  if (!session) {
+    console.error("SVAMP_SESSION_ID not set \u2014 run this inside a Svamp session.");
+    process.exit(1);
+  }
+  const workspace = envVar("HYPHA_WORKSPACE");
+  const serverUrl = envVar("HYPHA_SERVER_URL") || "https://hypha.aicell.io";
+  const mid = machineId();
+  if (!workspace || !mid) {
+    console.error("Could not resolve workspace/machine (HYPHA_WORKSPACE / daemon.state.json).");
+    process.exit(1);
+  }
+  const channelsServiceId = `${workspace}/${mid}:channels`;
+  const gw = gatewayBase(channelsServiceId, serverUrl);
+  const channelId = `outpost-${session}`;
+  const store = new ChannelStore(projectDir());
+  const existing = store.get(channelId);
+  let token = existing?.identity?.callers?.find((c) => c.name === "outpost")?.key;
+  if (!token) token = genKey();
+  const channel = {
+    id: channelId,
+    name: `Remote outpost \u2014 ${session}`,
+    description: "FDE remote machine: a svamp-outpost binary connects here and the agent runs commands on it.",
+    enabled: true,
+    bind: { session },
+    identity: { mode: "per-key", callers: [{ name: "outpost", kind: "agent", key: token }] },
+    action: { kind: "message" },
+    reply: { mode: "queue" },
+    skill: { name: "remote-outpost", description: "Run commands on the connected remote machine." }
+  };
+  store.save(channel);
+  const dl = argVal(args, "--download-base") || envVar("SVAMP_OUTPOST_DL") || "https://static-outpost-bin-08c08c38.svc.hypha.aicell.io";
+  saveConfig({ control: "", serverBase: gw, serveBase: dl, token, channel: channelId, session });
+  const gen = buildOutpostInstall({ serverBase: gw, channel: channelId, token, session, downloadBase: dl });
+  console.log(`\u2713 outpost channel ready for session ${session} (channel "${channelId}", gateway transport)
+`);
+  console.log("Give this to the person at the remote machine:\n");
+  console.log("  macOS / Linux:\n    " + gen.unix + "\n");
+  console.log("  Windows (PowerShell):\n    " + gen.windows + "\n");
+  console.log("  Direct binaries: " + dl);
+  console.log('\nThen drive it from this session:  svamp outpost exec "<command>"   \xB7   svamp outpost status');
+}
+function argVal(args, name) {
+  const i = args.indexOf(name);
+  return i >= 0 && i + 1 < args.length ? args[i + 1] : void 0;
+}
+async function http(method, url, body) {
+  const resp = await fetch(url, {
+    method,
+    ...body !== void 0 ? { headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {}
+  });
+  const text = await resp.text();
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}: ${text.slice(0, 200)}`);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function usage() {
+  console.log(`svamp outpost \u2014 drive a connected remote machine (FDE outpost)
+
+  svamp outpost up                      Create this session's outpost channel + print the install command
+
+  svamp outpost list                    List the outposts (machines) connected to this session
+  svamp outpost status                  Show connected remotes + counts
+  svamp outpost exec [--machine <id>] "<command>"
+                                        Run a shell command on one outpost (--machine <id>) or, with no
+                                        --machine, broadcast to every connected outpost. Output arrives
+                                        as chat messages. Each outpost's id is shown in its connect banner.
+  svamp outpost forget <id>             Drop a machine id from the local list
+  svamp outpost logs [--json]           Show everything the remote(s) have sent back
+  svamp outpost install [--os <os>]     Print the install one-liner(s) for the current outpost setup
+
+  With several machines connected, target each by id, e.g.:
+    svamp outpost exec --machine build-mac "uname -a"
+    svamp outpost exec "hostname"          # runs on ALL connected outposts
+
+Reads the relay control endpoint from ~/.svamp/outpost.json (or pass --control <url>).`);
+}
+async function outpostCommand(args) {
+  const sub = args[0];
+  const cfg = loadConfig();
+  const control = argVal(args, "--control") || cfg?.control;
+  if (!sub || sub === "help" || sub === "--help") {
+    usage();
+    return;
+  }
+  if (sub === "up") {
+    await outpostUp(args.slice(1));
+    return;
+  }
+  if (sub === "install") {
+    if (!cfg) {
+      console.error("No outpost configured (~/.svamp/outpost.json missing).");
+      process.exit(1);
+    }
+    const gen = buildOutpostInstall({ serverBase: cfg.serverBase, channel: cfg.channel, token: cfg.token, session: cfg.session, downloadBase: cfg.serveBase });
+    const only = argVal(args, "--os");
+    if (only === "windows") console.log(gen.windows);
+    else if (only === "unix" || only === "linux" || only === "darwin" || only === "macos") console.log(gen.unix);
+    else {
+      console.log("macOS / Linux:\n  " + gen.unix + "\n");
+      console.log("Windows (PowerShell):\n  " + gen.windows + "\n");
+      if (cfg.serveBase) console.log("Direct download: " + cfg.serveBase);
+    }
+    return;
+  }
+  const gateway = !!cfg?.serverBase && /\/services\/[^/]*:channels/.test(cfg.serverBase);
+  if (sub === "exec" && gateway) {
+    const target = argVal(args, "--machine") || argVal(args, "-m");
+    const cmd = args.slice(1).filter((a, i, arr) => a !== "--machine" && a !== "-m" && arr[i - 1] !== "--machine" && arr[i - 1] !== "-m").join(" ").trim();
+    if (!cmd) {
+      console.error('usage: svamp outpost exec [--machine <id>] "<command>"');
+      process.exit(1);
+    }
+    const { ChannelOutbox } = await import('./run-CKLU1B02.mjs').then(function (n) { return n.as; });
+    const outbox = new ChannelOutbox(projectDir());
+    const id = "x" + Date.now().toString(36);
+    outbox.append(cfg.channel, { to: "outpost", body: JSON.stringify({ type: "exec", id, cmd, target: target || "" }) });
+    if (target) rememberRemote(cfg.channel, target, true);
+    console.log(target ? `Sent to outpost "${target}" (channel ${cfg.channel}). Its output arrives as a message in this session shortly.` : `Broadcast to all connected outposts (channel ${cfg.channel}). Output from each arrives as a message shortly. Use --machine <id> to target one.`);
+    return;
+  }
+  if (sub === "list" && gateway) {
+    const ch = new ChannelStore(projectDir()).get(cfg.channel);
+    const calls = (ch?.last_calls || []).filter((c) => c.sender === "outpost");
+    const known = loadRemotes()[cfg.channel] || {};
+    const ids = Object.keys(known);
+    if (!ids.length && !calls.length) {
+      console.log(`No outposts known yet on ${cfg.channel}. When one connects it announces itself in this session's chat as \u{1F5A5}\uFE0F outpost "<id>" connected \u2014 then target it with: svamp outpost exec --machine <id> "\u2026"`);
+      return;
+    }
+    console.log(`Outposts addressed from session ${cfg.session || cfg.channel} (each connect banner in chat confirms which are live):`);
+    for (const id of ids) {
+      const r = known[id];
+      console.log(`  \u2022 ${id}${r.lastTargeted ? `   (last targeted ${r.lastTargeted})` : "   (seen)"}`);
+    }
+    if (calls.length) console.log(`  channel activity: ${calls.length} recent message(s); last at ${calls[0]?.at}`);
+    if (!ids.length) console.log("  (no machine ids recorded yet \u2014 the connect banner in chat shows each outpost's id)");
+    console.log("  Drop a stale id with: svamp outpost forget <id>");
+    return;
+  }
+  if ((sub === "forget" || sub === "remove") && gateway) {
+    const id = args[1];
+    if (!id) {
+      console.error("usage: svamp outpost forget <machine-id>");
+      process.exit(1);
+    }
+    console.log(forgetRemote(cfg.channel, id) ? `Forgot outpost "${id}".` : `No such outpost "${id}" recorded.`);
+    return;
+  }
+  if (sub === "status" && gateway) {
+    const ch = new ChannelStore(projectDir()).get(cfg.channel);
+    const calls = (ch?.last_calls || []).filter((c) => c.sender === "outpost");
+    const ids = Object.keys(loadRemotes()[cfg.channel] || {});
+    const who = ids.length ? ` \u2014 known machines: ${ids.join(", ")}` : "";
+    console.log(calls.length ? `outpost active on ${cfg.channel} \u2014 ${calls.length} recent message(s); last at ${calls[0]?.at}${who}` : `no outpost has connected to ${cfg.channel} yet`);
+    return;
+  }
+  if (sub === "logs" && gateway) {
+    console.log(`Gateway mode: the remote's host info + command output arrive as messages in this session's chat (channel ${cfg.channel}).`);
+    return;
+  }
+  if (!control) {
+    console.error("No relay control endpoint (~/.svamp/outpost.json missing; run `svamp outpost up`, or pass --control <url>).");
+    process.exit(1);
+  }
+  if (sub === "status") {
+    const s = await http("GET", `${control}/state`);
+    console.log(`connected remotes: ${s.connectedOutposts}   commands sent: ${s.commands}   results: ${s.results}`);
+    return;
+  }
+  if (sub === "logs") {
+    const r = await http("GET", `${control}/results`);
+    if (args.includes("--json")) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    for (const m of r) {
+      if (m.type === "outpost-hello") console.log(`\u2022 connected: ${m.host?.user}@${m.host?.hostname} (${m.host?.os}/${m.host?.arch}) cwd=${m.host?.cwd}`);
+      else if (m.type === "exec-result") console.log(`\u2022 [${m.id}] exit=${m.exitCode}
+${m.output}`);
+    }
+    return;
+  }
+  if (sub === "exec") {
+    const cmd = args.slice(1).filter((a) => a !== "--control" && a !== control).join(" ").trim();
+    if (!cmd) {
+      console.error('usage: svamp outpost exec "<command>"');
+      process.exit(1);
+    }
+    const { enqueued } = await http("POST", `${control}/enqueue?cmd=${encodeURIComponent(cmd)}`, {});
+    if (!enqueued?.id) {
+      console.error("failed to enqueue");
+      process.exit(1);
+    }
+    const deadline = Date.now() + 6e5;
+    for (; ; ) {
+      const results = await http("GET", `${control}/results`);
+      const hit = results.find((m) => m.type === "exec-result" && m.id === enqueued.id);
+      if (hit) {
+        process.stdout.write(hit.output || "");
+        if (typeof hit.exitCode === "number" && hit.exitCode !== 0) console.error(`
+[exit ${hit.exitCode}]`);
+        return;
+      }
+      if (Date.now() > deadline) {
+        console.error("timed out waiting for the remote to respond (is it connected?)");
+        process.exit(1);
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  console.error(`unknown outpost command: ${sub}`);
+  usage();
+  process.exit(1);
+}
+
+export { outpostCommand };

package/dist/{commands-Cf9KT-Ob.mjs → commands-Bfgme-kK.mjs}

@@ -1,8 +1,8 @@
 import { execSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { f as flushAndExit } from './cli-BH5LIMPI.mjs';
-import { j as resolveProjectRoot, q as searchIssues, o as listIssues, l as resumeIssue, p as pauseIssue, m as addComment, u as updateIssue, k as getIssue, t as isVisibleTo, H as summarize, n as addIssue } from './run-BNeZiySO.mjs';
+import { f as flushAndExit } from './cli-CuzIOUig.mjs';
+import { j as resolveProjectRoot, q as searchIssues, o as listIssues, l as resumeIssue, p as pauseIssue, m as addComment, u as updateIssue, k as getIssue, t as isVisibleTo, H as summarize, n as addIssue } from './run-CKLU1B02.mjs';
 import './serviceManager-hlOVxkhW.mjs';
 import 'os';
 import 'fs/promises';

package/dist/{commands-BNxsrqSl.mjs → commands-Cx8mEjjt.mjs}

@@ -1,8 +1,8 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { connectAndGetMachine, resolveSessionId, createWorktree, connectAndResolveSession } from './commands-BaVcBOKA.mjs';
+import { connectAndGetMachine, resolveSessionId, createWorktree, connectAndResolveSession } from './commands-B-VYM4sA.mjs';
 import { execFileSync } from 'node:child_process';
-import { u as updateIssue, m as addComment, n as addIssue, i as shortId } from './run-BNeZiySO.mjs';
+import { u as updateIssue, m as addComment, n as addIssue, i as shortId } from './run-CKLU1B02.mjs';
 import 'node:os';
 import 'os';
 import 'fs/promises';

package/dist/{commands-CZSPOqtd.mjs → commands-DSI9ZUTG.mjs}

@@ -1,7 +1,7 @@
 import os from 'os';
 import fs__default from 'fs';
 import { resolve, join, relative } from 'path';
-import { Q as parseFrontmatter, T as getSkillsServer, U as getSkillsWorkspaceName, V as getSkillsCollectionName, W as fetchWithTimeout, X as searchSkills, Y as SKILLS_DIR, Z as getSkillInfo, _ as downloadSkillFile, $ as listSkillFiles } from './run-BNeZiySO.mjs';
+import { Q as parseFrontmatter, T as getSkillsServer, U as getSkillsWorkspaceName, V as getSkillsCollectionName, W as fetchWithTimeout, X as searchSkills, Y as SKILLS_DIR, Z as getSkillInfo, _ as downloadSkillFile, $ as listSkillFiles } from './run-CKLU1B02.mjs';
 import 'fs/promises';
 import 'url';
 import 'child_process';

package/dist/{commands-BsiQdwUs.mjs → commands-DwQIShcm.mjs}

@@ -1,11 +1,11 @@
 import { writeFileSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { connectAndGetMachine } from './commands-BaVcBOKA.mjs';
+import { connectAndGetMachine } from './commands-B-VYM4sA.mjs';
 import 'node:fs';
 import 'node:child_process';
 import 'node:path';
 import 'node:os';
-import './run-BNeZiySO.mjs';
+import './run-CKLU1B02.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';

package/dist/{commands-Bb-RzoKB.mjs → commands-eBqn9KgI.mjs}

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { j as resolveProjectRoot, I as workflowSteps, z as setWorkflowEnabled, E as isWorkflowEnabled, A as removeWorkflow, x as getWorkflow, D as listWorkflows, B as saveWorkflow, C as rawWorkflow } from './run-BNeZiySO.mjs';
+import { j as resolveProjectRoot, I as workflowSteps, z as setWorkflowEnabled, E as isWorkflowEnabled, A as removeWorkflow, x as getWorkflow, D as listWorkflows, B as saveWorkflow, C as rawWorkflow } from './run-CKLU1B02.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{commands-DFSD7jBH.mjs → commands-kahqMkYE.mjs}

@@ -60,7 +60,7 @@ async function serviceExpose(args) {
     process.exit(1);
   }
   if (foreground) {
-    const { runFrpcTunnel } = await import('./frpc-CuvdlU0g.mjs');
+    const { runFrpcTunnel } = await import('./frpc-BeGCyERl.mjs');
     await runFrpcTunnel(name, ports, void 0, {
       group,
       groupKey,
@@ -70,7 +70,7 @@ async function serviceExpose(args) {
     });
     return;
   }
-  const { connectAndGetMachine } = await import('./commands-BaVcBOKA.mjs');
+  const { connectAndGetMachine } = await import('./commands-B-VYM4sA.mjs');
   const { server, machine } = await connectAndGetMachine();
   try {
     const status = await machine.tunnelStart({
@@ -92,7 +92,7 @@ async function serviceExpose(args) {
         console.log(`  port ${port}: ${url}`);
       }
       if (process.env.SVAMP_SESSION_ID) {
-        const { autoAddSessionLink } = await import('./agentCommands-B7HQJo3X.mjs');
+        const { autoAddSessionLink } = await import('./agentCommands-CoPsnzwK.mjs');
         let added = 0;
         for (const [port, url] of urlEntries) {
           const label = urlEntries.length > 1 ? `${name}:${port}` : name;
@@ -101,7 +101,7 @@ async function serviceExpose(args) {
         if (added) console.log(`  \u21B3 added to this session's Launch Pad`);
       }
     }
-    console.log(`To stop: svamp service delete ${name}  (or: svamp tunnel stop ${name})`);
+    console.log(`To stop: svamp service delete ${name}`);
   } catch (err) {
     if (/already running/i.test(err?.message || "")) {
       console.error(`Tunnel '${name}' is already running. Use \`svamp service delete ${name}\` first.`);
@@ -129,7 +129,7 @@ async function serviceServe(args) {
     console.log(`Serving ${resolvedDir}`);
     const servePort = 18080;
     const http = await import('http');
-    const { serveStaticMount } = await import('./run-BNeZiySO.mjs').then(function (n) { return n.al; });
+    const { serveStaticMount } = await import('./run-CKLU1B02.mjs').then(function (n) { return n.ao; });
     const server = http.createServer((req, res) => {
       const u = new URL(req.url || "/", "http://127.0.0.1");
       let rel = u.pathname;
@@ -140,7 +140,7 @@ async function serviceServe(args) {
       server.once("error", reject);
       server.listen(servePort, "127.0.0.1", () => resolve());
     });
-    const { runFrpcTunnel } = await import('./frpc-CuvdlU0g.mjs');
+    const { runFrpcTunnel } = await import('./frpc-BeGCyERl.mjs');
     void server;
     await runFrpcTunnel(name, [servePort]);
   } catch (err) {
@@ -150,7 +150,7 @@ async function serviceServe(args) {
 }
 async function serviceList(_args) {
   try {
-    const { connectAndGetMachine } = await import('./commands-BaVcBOKA.mjs');
+    const { connectAndGetMachine } = await import('./commands-B-VYM4sA.mjs');
     const { server, machine } = await connectAndGetMachine();
     try {
       const tunnels = await machine.tunnelList({});
@@ -190,7 +190,7 @@ async function serviceDelete(args) {
     process.exit(1);
   }
   try {
-    const { connectAndGetMachine } = await import('./commands-BaVcBOKA.mjs');
+    const { connectAndGetMachine } = await import('./commands-B-VYM4sA.mjs');
     const { server, machine } = await connectAndGetMachine();
     try {
       await machine.tunnelStop({ name });

package/dist/{fleet-2c-iNucb.mjs → fleet-CqbZhBG2.mjs}

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
-import { c as connectToHypha } from './run-BNeZiySO.mjs';
+import { c as connectToHypha } from './run-CKLU1B02.mjs';
 import { PINNED_CLAUDE_CODE_VERSION } from './pinnedClaudeCode-BaMR97BE.mjs';
 import 'os';
 import 'fs/promises';

package/dist/{frpc-CuvdlU0g.mjs → frpc-BeGCyERl.mjs}

@@ -4,7 +4,7 @@ import { mkdirSync, chmodSync, writeFileSync, unlinkSync, existsSync, readFileSy
 import { join } from 'path';
 import { homedir, platform, arch } from 'os';
 import { randomUUID, createHash } from 'crypto';
-import { e as getFrpsSubdomainHost, f as getFrpsServerPort, h as getFrpsServerAddr } from './run-BNeZiySO.mjs';
+import { e as getFrpsSubdomainHost, f as getFrpsServerPort, h as getFrpsServerAddr } from './run-CKLU1B02.mjs';
 import 'fs/promises';
 import 'url';
 import 'node:crypto';
@@ -278,6 +278,8 @@ class FrpcTunnel {
   _lastErrorAt = 0;
   _firstErrorAt = 0;
   _restartAttempts = 0;
+  _restartTimer = null;
+  // #0583: pending reconnect timer (cancelled on destroy)
   // End-to-end probe state (set when options.probeUrl is provided).
   _probeTimer = null;
   _lastProbeOkAt = 0;
@@ -309,7 +311,8 @@ class FrpcTunnel {
     const multiPort = options.ports.length > 1;
     this.proxies = options.ports.map((port) => {
       const standaloneHash = createHash("sha256").update(multiPort ? `${options.name}|${port}|${machineFingerprint}` : `${options.name}|${machineFingerprint}`).digest("hex").slice(0, 8);
-      const subdomain = options.subdomains?.get(port) || (options.group ? `${options.group}-${createHash("sha256").update(options.group).digest("hex").slice(0, 8)}` : `${options.name}-${standaloneHash}`);
+      const groupSubdomainKey = multiPort ? `${options.group}|${port}` : `${options.group}`;
+      const subdomain = options.subdomains?.get(port) || (options.group ? `${options.group}-${createHash("sha256").update(groupSubdomainKey).digest("hex").slice(0, 8)}` : `${options.name}-${standaloneHash}`);
       const proxyName = `${options.name}-${port}-${machineHash}`;
       return {
         name: proxyName,
@@ -332,6 +335,29 @@ class FrpcTunnel {
     }
     this.configPath = join(configDir, `${options.name}.toml`);
   }
+  /**
+   * #0583: schedule a backoff reconnect after the child went down (spawn error OR exit).
+   * Extracted from the exit handler so BOTH the spawn-'error' and 'exit' paths share it, and
+   * so it is unit-testable without a real spawn. No-op once destroyed.
+   */
+  _reconnectAfterDown(reason) {
+    if (this._destroyed) return;
+    const STABILITY_WINDOW_MS = 3e4;
+    if (this._lastConnectedAt > 0 && Date.now() - this._lastConnectedAt >= STABILITY_WINDOW_MS) {
+      this._restartAttempts = 0;
+    }
+    this._restartAttempts++;
+    const delay = Math.min(3e3 * Math.pow(2, this._restartAttempts - 1), 6e4);
+    this.log(`frpc down (${reason}), restarting in ${Math.round(delay / 1e3)}s (attempt ${this._restartAttempts})...`);
+    this._restartTimer = setTimeout(() => {
+      this._restartTimer = null;
+      if (!this._destroyed) {
+        this.connect().catch((err) => {
+          this.options.onError?.(err);
+        });
+      }
+    }, delay);
+  }
   /** Connect to frps by starting the frpc process. */
   async connect() {
     if (this._destroyed) return;
@@ -404,37 +430,25 @@ class FrpcTunnel {
       };
       child.stdout?.on("data", onOutput);
       child.stderr?.on("data", onOutput);
-      child.on("error", (err) => {
-        this.options.onError?.(err);
-        if (!resolved) {
-          resolved = true;
-          reject(err);
-        }
-      });
-      child.on("exit", (code) => {
+      let downHandled = false;
+      const onChildDown = (rejectErr) => {
+        if (downHandled) return;
+        downHandled = true;
         this._connected = false;
         this.process = null;
         this.options.onDisconnect?.();
         if (!resolved) {
           resolved = true;
-          reject(new Error(`frpc exited with code ${code}`));
-        }
-        if (!this._destroyed) {
-          const STABILITY_WINDOW_MS = 3e4;
-          if (this._lastConnectedAt > 0 && Date.now() - this._lastConnectedAt >= STABILITY_WINDOW_MS) {
-            this._restartAttempts = 0;
-          }
-          this._restartAttempts++;
-          const delay = Math.min(3e3 * Math.pow(2, this._restartAttempts - 1), 6e4);
-          this.log(`frpc exited with code ${code}, restarting in ${Math.round(delay / 1e3)}s (attempt ${this._restartAttempts})...`);
-          setTimeout(() => {
-            if (!this._destroyed) {
-              this.connect().catch((err) => {
-                this.options.onError?.(err);
-              });
-            }
-          }, delay);
+          reject(rejectErr);
         }
+        this._reconnectAfterDown(rejectErr.message);
+      };
+      child.on("error", (err) => {
+        this.options.onError?.(err);
+        onChildDown(err instanceof Error ? err : new Error(String(err)));
+      });
+      child.on("exit", (code) => {
+        onChildDown(new Error(`frpc exited with code ${code}`));
       });
       if (this.options.probeUrl || this.options.probePath) {
         this.startProbeLoop({
@@ -625,6 +639,10 @@ class FrpcTunnel {
     this._connected = false;
     this.stopProbeLoop();
     this.stopAdminStatusLoop();
+    if (this._restartTimer) {
+      clearTimeout(this._restartTimer);
+      this._restartTimer = null;
+    }
     if (this.process) {
       this.process.kill("SIGTERM");
       const p = this.process;

package/dist/{headlessCli-CftEZbxm.mjs → headlessCli-CJiHG0gu.mjs}

@@ -1,5 +1,5 @@
-import { a0 as resolveModel, af as describeMisconfiguration, ag as buildMachineDeps } from './run-BNeZiySO.mjs';
-import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-DB4Uipz9.mjs';
+import { a0 as resolveModel, ai as describeMisconfiguration, aj as buildMachineDeps } from './run-CKLU1B02.mjs';
+import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-BCMGW33d.mjs';
 import { WebSocket } from 'ws';
 import { execSync, spawn } from 'child_process';
 import 'os';

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { c as connectToHypha, a as createSessionStore, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, s as startDaemon, b as stopDaemon } from './run-BNeZiySO.mjs';
+export { c as connectToHypha, a as createSessionStore, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, s as startDaemon, b as stopDaemon } from './run-CKLU1B02.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{notifyCommands-1q8COUDd.mjs → notifyCommands-CXjWSZHe.mjs}

@@ -1,4 +1,4 @@
-import { c as connectToHypha, S as SharingNotificationSync, J as parseJwtEmail } from './run-BNeZiySO.mjs';
+import { c as connectToHypha, S as SharingNotificationSync, J as parseJwtEmail } from './run-CKLU1B02.mjs';
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';