svamp-cli 0.2.60 → 0.2.63

package/dist/{agentCommands-8IVIOSvH.mjs → agentCommands-BH6CIqc7.mjs}

@@ -148,7 +148,7 @@ async function sessionBroadcast(action, args) {
   console.log(`Broadcast sent: ${action}`);
 }
 async function connectToMachineService() {
-  const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+  const { connectAndGetMachine } = await import('./commands-CEazgqvj.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-B0kLKYmc.mjs');
+    const { resolveSessionId } = await import('./commands-CEazgqvj.mjs');
     const sessions = await machine.listSessions();
     const match = resolveSessionId(sessions, targetSessionId);
     const fullTargetId = match.sessionId;

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-Dhliie9Z.mjs';
+import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-DypcS01S.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -7,6 +7,7 @@ import 'url';
 import 'child_process';
 import 'crypto';
 import 'node:fs';
+import 'util';
 import 'node:crypto';
 import 'node:path';
 import 'node:child_process';
@@ -43,7 +44,7 @@ async function main() {
         console.error(`svamp daemon restart: ${err.message || err}`);
         process.exit(1);
       }
-      const { restartDaemon } = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.u; });
+      const { restartDaemon } = await import('./run-DypcS01S.mjs').then(function (n) { return n.u; });
       await restartDaemon();
       process.exit(0);
     }
@@ -279,7 +280,7 @@ async function main() {
       console.error("svamp service: Service commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { handleServiceCommand } = await import('./commands-BSPSCqBa.mjs');
+    const { handleServiceCommand } = await import('./commands-CY-HbTVN.mjs');
     await handleServiceCommand();
   } else if (subcommand === "serve") {
     const { isSandboxed: isSandboxedServe } = await import('./sandboxDetect-DNTcbgWD.mjs');
@@ -287,7 +288,7 @@ async function main() {
       console.error("svamp serve: Serve commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { handleServeCommand } = await import('./serveCommands-CMSmcjsp.mjs');
+    const { handleServeCommand } = await import('./serveCommands-CtAX-CMI.mjs');
     await handleServeCommand();
     process.exit(0);
   } else if (subcommand === "process" || subcommand === "proc") {
@@ -296,7 +297,7 @@ async function main() {
       console.error("svamp process: Process commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { processCommand } = await import('./commands-qvlNefLf.mjs');
+    const { processCommand } = await import('./commands-BFeHwsR-.mjs');
     let machineId;
     const processArgs = args.slice(1);
     const mIdx = processArgs.findIndex((a) => a === "--machine" || a === "-m");
@@ -314,7 +315,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-B7BB3yVn.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-QQovcM_B.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);
@@ -323,7 +324,7 @@ async function main() {
   }
 }
 async function handleInteractiveCommand() {
-  const { runInteractive } = await import('./run-DmWqzmqX.mjs');
+  const { runInteractive } = await import('./run-DB2WIjmZ.mjs');
   const interactiveArgs = subcommand === "start" ? args.slice(1) : args;
   let directory = process.cwd();
   let resumeSessionId;
@@ -368,7 +369,7 @@ async function handleAgentCommand() {
     return;
   }
   if (agentArgs[0] === "list") {
-    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.p; });
+    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-DypcS01S.mjs').then(function (n) { return n.p; });
     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)`);
@@ -380,7 +381,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-Dhliie9Z.mjs').then(function (n) { return n.p; });
+  const { resolveAcpAgentConfig, KNOWN_MCP_AGENTS } = await import('./run-DypcS01S.mjs').then(function (n) { return n.p; });
   let cwd = process.cwd();
   const filteredArgs = [];
   for (let i = 0; i < agentArgs.length; i++) {
@@ -404,12 +405,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-Dhliie9Z.mjs').then(function (n) { return n.q; });
+    const { CodexMcpBackend } = await import('./run-DypcS01S.mjs').then(function (n) { return n.q; });
     backend = new CodexMcpBackend({ cwd, log: logFn });
   } else {
-    const { AcpBackend } = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.o; });
-    const { GeminiTransport } = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.G; });
-    const { DefaultTransport } = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.D; });
+    const { AcpBackend } = await import('./run-DypcS01S.mjs').then(function (n) { return n.o; });
+    const { GeminiTransport } = await import('./run-DypcS01S.mjs').then(function (n) { return n.G; });
+    const { DefaultTransport } = await import('./run-DypcS01S.mjs').then(function (n) { return n.D; });
     const transportHandler = config.agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(config.agentName);
     backend = new AcpBackend({
       agentName: config.agentName,
@@ -536,7 +537,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-B0kLKYmc.mjs');
+  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait, sessionShare, sessionRalphStart, sessionRalphCancel, sessionRalphStatus, sessionInboxSend, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxClear } = await import('./commands-CEazgqvj.mjs');
   const parseFlagStr = (flag, shortFlag) => {
     for (let i = 1; i < sessionArgs.length; i++) {
       if ((sessionArgs[i] === flag || shortFlag) && i + 1 < sessionArgs.length) {
@@ -596,7 +597,7 @@ async function handleSessionCommand() {
         allowDomain.push(sessionArgs[++i]);
       }
     }
-    const { parseShareArg } = await import('./commands-B0kLKYmc.mjs');
+    const { parseShareArg } = await import('./commands-CEazgqvj.mjs');
     const shareEntries = share.map((s) => parseShareArg(s));
     await sessionSpawn(agent, dir, targetMachineId, {
       message,
@@ -682,7 +683,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session approve <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionApprove } = await import('./commands-B0kLKYmc.mjs');
+    const { sessionApprove } = await import('./commands-CEazgqvj.mjs');
     const approveReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionApprove(sessionArgs[1], approveReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -692,7 +693,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session deny <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionDeny } = await import('./commands-B0kLKYmc.mjs');
+    const { sessionDeny } = await import('./commands-CEazgqvj.mjs');
     const denyReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionDeny(sessionArgs[1], denyReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -728,7 +729,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session set-title <title>");
       process.exit(1);
     }
-    const { sessionSetTitle } = await import('./agentCommands-8IVIOSvH.mjs');
+    const { sessionSetTitle } = await import('./agentCommands-BH6CIqc7.mjs');
     await sessionSetTitle(title);
   } else if (sessionSubcommand === "set-link") {
     const url = sessionArgs[1];
@@ -737,7 +738,7 @@ async function handleSessionCommand() {
       process.exit(1);
     }
     const label = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
-    const { sessionSetLink } = await import('./agentCommands-8IVIOSvH.mjs');
+    const { sessionSetLink } = await import('./agentCommands-BH6CIqc7.mjs');
     await sessionSetLink(url, label);
   } else if (sessionSubcommand === "notify") {
     const message = sessionArgs[1];
@@ -746,7 +747,7 @@ async function handleSessionCommand() {
       process.exit(1);
     }
     const level = parseFlagStr("--level") || "info";
-    const { sessionNotify } = await import('./agentCommands-8IVIOSvH.mjs');
+    const { sessionNotify } = await import('./agentCommands-BH6CIqc7.mjs');
     await sessionNotify(message, level);
   } else if (sessionSubcommand === "broadcast") {
     const action = sessionArgs[1];
@@ -754,7 +755,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-8IVIOSvH.mjs');
+    const { sessionBroadcast } = await import('./agentCommands-BH6CIqc7.mjs');
     await sessionBroadcast(action, sessionArgs.slice(2).filter((a) => !a.startsWith("--")));
   } else if (sessionSubcommand === "inbox") {
     const inboxSubcmd = sessionArgs[1];
@@ -765,7 +766,7 @@ async function handleSessionCommand() {
         process.exit(1);
       }
       if (agentSessionId) {
-        const { inboxSend } = await import('./agentCommands-8IVIOSvH.mjs');
+        const { inboxSend } = await import('./agentCommands-BH6CIqc7.mjs');
         await inboxSend(sessionArgs[2], {
           body: sessionArgs[3],
           subject: parseFlagStr("--subject"),
@@ -780,7 +781,7 @@ async function handleSessionCommand() {
       }
     } else if (inboxSubcmd === "list" || inboxSubcmd === "ls") {
       if (agentSessionId && !sessionArgs[2]) {
-        const { inboxList } = await import('./agentCommands-8IVIOSvH.mjs');
+        const { inboxList } = await import('./agentCommands-BH6CIqc7.mjs');
         await inboxList({
           unread: hasFlag("--unread"),
           limit: parseFlagInt("--limit"),
@@ -802,7 +803,7 @@ async function handleSessionCommand() {
         process.exit(1);
       }
       if (agentSessionId && !sessionArgs[3]) {
-        const { inboxList } = await import('./agentCommands-8IVIOSvH.mjs');
+        const { inboxList } = await import('./agentCommands-BH6CIqc7.mjs');
         await sessionInboxRead(agentSessionId, sessionArgs[2], targetMachineId);
       } else if (sessionArgs[3]) {
         await sessionInboxRead(sessionArgs[2], sessionArgs[3], targetMachineId);
@@ -812,7 +813,7 @@ async function handleSessionCommand() {
       }
     } else if (inboxSubcmd === "reply") {
       if (agentSessionId && sessionArgs[2] && sessionArgs[3] && !sessionArgs[4]) {
-        const { inboxReply } = await import('./agentCommands-8IVIOSvH.mjs');
+        const { inboxReply } = await import('./agentCommands-BH6CIqc7.mjs');
         await inboxReply(sessionArgs[2], sessionArgs[3]);
       } else if (sessionArgs[2] && sessionArgs[3] && sessionArgs[4]) {
         await sessionInboxReply(sessionArgs[2], sessionArgs[3], sessionArgs[4], targetMachineId);
@@ -848,7 +849,7 @@ async function handleMachineCommand() {
     return;
   }
   if (machineSubcommand === "share") {
-    const { machineShare } = await import('./commands-B0kLKYmc.mjs');
+    const { machineShare } = await import('./commands-CEazgqvj.mjs');
     let machineId;
     const shareArgs = [];
     for (let i = 1; i < machineArgs.length; i++) {
@@ -878,7 +879,7 @@ async function handleMachineCommand() {
     }
     await machineShare(machineId, { add, remove, list, configPath, showConfig });
   } else if (machineSubcommand === "exec") {
-    const { machineExec } = await import('./commands-B0kLKYmc.mjs');
+    const { machineExec } = await import('./commands-CEazgqvj.mjs');
     let machineId;
     let cwd;
     const cmdParts = [];
@@ -898,7 +899,7 @@ async function handleMachineCommand() {
     }
     await machineExec(machineId, command, cwd);
   } else if (machineSubcommand === "info") {
-    const { machineInfo } = await import('./commands-B0kLKYmc.mjs');
+    const { machineInfo } = await import('./commands-CEazgqvj.mjs');
     let machineId;
     for (let i = 1; i < machineArgs.length; i++) {
       if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
@@ -918,10 +919,10 @@ async function handleMachineCommand() {
         level = machineArgs[++i];
       }
     }
-    const { machineNotify } = await import('./agentCommands-8IVIOSvH.mjs');
+    const { machineNotify } = await import('./agentCommands-BH6CIqc7.mjs');
     await machineNotify(message, level);
   } else if (machineSubcommand === "ls") {
-    const { machineLs } = await import('./commands-B0kLKYmc.mjs');
+    const { machineLs } = await import('./commands-CEazgqvj.mjs');
     let machineId;
     let showHidden = false;
     let path;
@@ -1388,7 +1389,7 @@ async function applyClaudeAuthFlags(argv) {
       "--use-hypha-proxy, --use-claude-login, and --anthropic-base-url/--anthropic-api-key are mutually exclusive"
     );
   }
-  const mod = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.t; });
+  const mod = await import('./run-DypcS01S.mjs').then(function (n) { return n.t; });
   if (hasHypha) {
     mod.setClaudeAuthHyphaProxy();
     console.log("Claude auth configured: hypha-proxy (uses HYPHA_TOKEN live at each spawn).");
@@ -1426,7 +1427,7 @@ async function applyDaemonShareFlag(argv) {
     }
   }
   if (collected.length === 0) return;
-  const { updateEnvFile } = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.t; });
+  const { updateEnvFile } = await import('./run-DypcS01S.mjs').then(function (n) { return n.t; });
   const seen = /* @__PURE__ */ new Set();
   const deduped = collected.filter((e) => {
     const k = e.toLowerCase();
@@ -1439,7 +1440,7 @@ async function applyDaemonShareFlag(argv) {
 }
 async function handleDaemonAuthCommand(argv) {
   const sub = (argv[0] || "status").toLowerCase();
-  const mod = await import('./run-Dhliie9Z.mjs').then(function (n) { return n.t; });
+  const mod = await import('./run-DypcS01S.mjs').then(function (n) { return n.t; });
   if (sub === "--help" || sub === "-h" || sub === "help") {
     console.log(`
 svamp daemon auth \u2014 Configure how Claude subprocesses authenticate

package/dist/{commands-qvlNefLf.mjs → commands-BFeHwsR-.mjs}

@@ -1,16 +1,17 @@
 import { writeFileSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { connectAndGetMachine } from './commands-B0kLKYmc.mjs';
+import { connectAndGetMachine } from './commands-CEazgqvj.mjs';
 import 'node:fs';
 import 'node:child_process';
 import 'node:path';
 import 'node:os';
-import './run-Dhliie9Z.mjs';
+import './run-DypcS01S.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';
 import 'child_process';
 import 'crypto';
+import 'util';
 import 'node:crypto';
 import '@agentclientprotocol/sdk';
 import '@modelcontextprotocol/sdk/client/index.js';
@@ -149,6 +150,7 @@ function normalizeSpec(raw) {
     console.error("Error: spec.command is required");
     process.exit(1);
   }
+  const sessionId = typeof raw.sessionId === "string" ? raw.sessionId : process.env.SVAMP_SESSION_ID || void 0;
   return {
     name: raw.name,
     command: raw.command,
@@ -169,7 +171,8 @@ function normalizeSpec(raw) {
     // ttl: 0 / negative / missing all mean "no TTL, run forever". Any positive value is seconds.
     ttl: raw.ttl !== void 0 && Number(raw.ttl) > 0 ? Number(raw.ttl) : void 0,
     serviceGroup: raw.serviceGroup,
-    ports: Array.isArray(raw.ports) ? raw.ports.map(Number) : void 0
+    ports: Array.isArray(raw.ports) ? raw.ports.map(Number) : void 0,
+    ...sessionId ? { sessionId } : {}
   };
 }
 function statusIcon(status) {
@@ -439,6 +442,7 @@ async function startCommand(args, machineId) {
     }
     env[pair.slice(0, eq)] = pair.slice(eq + 1);
   }
+  const sessionId = process.env.SVAMP_SESSION_ID || void 0;
   const spec = {
     name: idOrName,
     command,
@@ -449,7 +453,8 @@ async function startCommand(args, machineId) {
     maxRestarts,
     restartDelay,
     ...probe ? { probe } : {},
-    ...ttl !== void 0 ? { ttl } : {}
+    ...ttl !== void 0 ? { ttl } : {},
+    ...sessionId ? { sessionId } : {}
   };
   const saveFile = getFlag(flagArgs, "--save");
   const { server, machine } = await connectAndGetMachine(machineId);

package/dist/{commands-B0kLKYmc.mjs → commands-CEazgqvj.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 { n as normalizeAllowedUser, l as loadSecurityContextConfig, e as resolveSecurityContext, f as buildSecurityContextFromFlags, m as mergeSecurityContexts, c as connectToHypha, i as buildSessionShareUrl, j as buildMachineShareUrl } from './run-Dhliie9Z.mjs';
+import { n as normalizeAllowedUser, l as loadSecurityContextConfig, e as resolveSecurityContext, f as buildSecurityContextFromFlags, m as mergeSecurityContexts, c as connectToHypha, i as buildSessionShareUrl, j as buildMachineShareUrl } from './run-DypcS01S.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -10,6 +10,7 @@ import 'path';
 import 'url';
 import 'child_process';
 import 'crypto';
+import 'util';
 import 'node:crypto';
 import '@agentclientprotocol/sdk';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/{commands-BSPSCqBa.mjs → commands-CY-HbTVN.mjs}

@@ -68,7 +68,7 @@ async function serviceExpose(args) {
     });
     return;
   }
-  const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+  const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
   const { server, machine } = await connectAndGetMachine();
   try {
     const status = await machine.tunnelStart({
@@ -132,7 +132,7 @@ async function serviceServe(args) {
 }
 async function serviceList(_args) {
   try {
-    const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+    const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
     const { server, machine } = await connectAndGetMachine();
     try {
       const tunnels = await machine.tunnelList({});
@@ -161,7 +161,7 @@ async function serviceDelete(args) {
     process.exit(1);
   }
   try {
-    const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+    const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
     const { server, machine } = await connectAndGetMachine();
     try {
       await machine.tunnelStop({ name });

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { c as connectToHypha, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, a as registerSessionService, s as startDaemon, b as stopDaemon } from './run-Dhliie9Z.mjs';
+export { c as connectToHypha, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, a as registerSessionService, s as startDaemon, b as stopDaemon } from './run-DypcS01S.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -7,6 +7,7 @@ import 'url';
 import 'child_process';
 import 'crypto';
 import 'node:fs';
+import 'util';
 import 'node:crypto';
 import 'node:path';
 import 'node:child_process';

package/dist/{package-B7BB3yVn.mjs → package-QQovcM_B.mjs}

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

package/dist/{run-DmWqzmqX.mjs → run-DB2WIjmZ.mjs}

@@ -2,7 +2,7 @@ import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(im
 import os from 'node:os';
 import { resolve, join } from 'node:path';
 import { existsSync, readFileSync, watch } from 'node:fs';
-import { c as connectToHypha, a as registerSessionService, k as generateHookSettings } from './run-Dhliie9Z.mjs';
+import { c as connectToHypha, a as registerSessionService, k as generateHookSettings } from './run-DypcS01S.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
@@ -13,6 +13,7 @@ import 'path';
 import 'url';
 import 'child_process';
 import 'crypto';
+import 'util';
 import '@agentclientprotocol/sdk';
 import '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/client/stdio.js';

package/dist/{run-Dhliie9Z.mjs → run-DypcS01S.mjs}

@@ -3,12 +3,13 @@ import fs, { mkdir as mkdir$1, readdir as readdir$1, readFile, writeFile as writ
 import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync, existsSync as existsSync$1, copyFileSync, unlinkSync as unlinkSync$1, watch, rmdirSync, readdirSync } from 'fs';
 import path__default, { join, dirname, resolve, basename } from 'path';
 import { fileURLToPath } from 'url';
-import { spawn as spawn$1, execSync as execSync$1 } from 'child_process';
+import { execFile, spawn as spawn$1, execSync as execSync$1 } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
 import { existsSync, readFileSync, writeFileSync as writeFileSync$1, mkdirSync as mkdirSync$1, appendFileSync, unlinkSync } from 'node:fs';
+import { promisify } from 'util';
 import { randomUUID, createHash } from 'node:crypto';
 import { join as join$1 } from 'node:path';
-import { spawn, execSync, execFile, execFileSync } from 'node:child_process';
+import { spawn, execSync, execFile as execFile$1, execFileSync } from 'node:child_process';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
 import os, { homedir, platform } from 'node:os';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -16,7 +17,7 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { mkdir, rm, chmod, access, mkdtemp, copyFile, writeFile, readdir, stat, readFile as readFile$1 } from 'node:fs/promises';
-import { promisify } from 'node:util';
+import { promisify as promisify$1 } from 'node:util';
 
 let connectToServerFn = null;
 async function getConnectToServer() {
@@ -72,9 +73,10 @@ const ROLE_HIERARCHY = {
   admin: 2
 };
 function normalizeAllowedUser(input, addedBy) {
+  const role = input.role && input.role in ROLE_HIERARCHY ? input.role : "admin";
   return {
-    email: input.email.trim(),
-    role: "admin",
+    email: input.email.trim().toLowerCase(),
+    role,
     addedAt: typeof input.addedAt === "number" ? input.addedAt : Date.now(),
     addedBy: input.addedBy ?? addedBy
   };
@@ -88,7 +90,8 @@ function resolveRoleLevel(sharing, userEmail) {
       (u) => u.email.toLowerCase() === userEmail.toLowerCase()
     );
     if (sharedUser) {
-      level = ROLE_HIERARCHY.admin;
+      const storedLevel = ROLE_HIERARCHY[sharedUser.role];
+      level = typeof storedLevel === "number" ? storedLevel : ROLE_HIERARCHY.admin;
     }
   }
   if (sharing.publicAccess) {
@@ -302,6 +305,98 @@ function applySecurityContext(baseConfig, context) {
   return config;
 }
 
+const execFileAsync$1 = promisify(execFile);
+function parseEtime(s) {
+  if (!s) return 0;
+  const dayParts = s.split("-");
+  let dayPrefix = 0;
+  let rest = s;
+  if (dayParts.length === 2) {
+    dayPrefix = parseInt(dayParts[0], 10) || 0;
+    rest = dayParts[1];
+  }
+  const parts = rest.split(":").map((p) => parseInt(p, 10) || 0);
+  let total = 0;
+  if (parts.length === 3) total = parts[0] * 3600 + parts[1] * 60 + parts[2];
+  else if (parts.length === 2) total = parts[0] * 60 + parts[1];
+  else if (parts.length === 1) total = parts[0];
+  return dayPrefix * 86400 + total;
+}
+async function readProcessTable() {
+  if (process.platform === "win32") return [];
+  let stdout;
+  try {
+    const result = await execFileAsync$1("ps", ["-A", "-o", "pid=,ppid=,etime=,%cpu=,rss=,command="], {
+      maxBuffer: 8 * 1024 * 1024
+      // 8MB — plenty for any realistic process table
+    });
+    stdout = result.stdout;
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 6) continue;
+    const pid = parseInt(parts[0], 10);
+    const ppid = parseInt(parts[1], 10);
+    if (!pid || isNaN(ppid)) continue;
+    const etimeSec = parseEtime(parts[2]);
+    const cpu = parseFloat(parts[3]) || 0;
+    const rssKb = parseInt(parts[4], 10) || 0;
+    const command = parts.slice(5).join(" ");
+    rows.push({ pid, ppid, etimeSec, cpu, rssKb, command });
+  }
+  return rows;
+}
+async function detectDescendants(rootPid, excludePids = /* @__PURE__ */ new Set()) {
+  if (!rootPid || rootPid < 1) return [];
+  const table = await readProcessTable();
+  if (table.length === 0) return [];
+  const byPpid = /* @__PURE__ */ new Map();
+  for (const row of table) {
+    const list = byPpid.get(row.ppid);
+    if (list) list.push(row);
+    else byPpid.set(row.ppid, [row]);
+  }
+  const descendants = [];
+  const visited = /* @__PURE__ */ new Set([rootPid]);
+  const queue = [rootPid];
+  const MAX_NODES = 5e3;
+  while (queue.length > 0 && descendants.length < MAX_NODES) {
+    const next = queue.shift();
+    const children = byPpid.get(next);
+    if (!children) continue;
+    for (const child of children) {
+      if (visited.has(child.pid)) continue;
+      visited.add(child.pid);
+      queue.push(child.pid);
+      if (!excludePids.has(child.pid)) {
+        descendants.push(child);
+      }
+    }
+  }
+  descendants.sort((a, b) => a.etimeSec - b.etimeSec);
+  return descendants;
+}
+async function killDescendant(rootPid, targetPid, signal = "SIGTERM") {
+  if (!rootPid || rootPid < 1) return { killed: false, reason: "no root pid" };
+  if (!targetPid || targetPid < 1) return { killed: false, reason: "invalid target pid" };
+  if (targetPid === rootPid) return { killed: false, reason: "cannot kill session root pid" };
+  const descendants = await detectDescendants(rootPid);
+  if (!descendants.some((d) => d.pid === targetPid)) {
+    return { killed: false, reason: "pid is not a descendant of this session" };
+  }
+  try {
+    process.kill(targetPid, signal);
+    return { killed: true };
+  } catch (err) {
+    return { killed: false, reason: err?.message ?? "kill failed" };
+  }
+}
+
 function getParamNames(fn) {
   const src = fn.toString();
   const match = src.match(/^(?:async\s+)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
@@ -375,6 +470,20 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       }
     }
   };
+  const ROLE_RANK = { view: 1, interact: 2, admin: 3 };
+  const authorizeSessionAccess = async (sessionId, requiredRole, context) => {
+    try {
+      authorizeRequest(context, currentMetadata.sharing, requiredRole);
+      return;
+    } catch {
+    }
+    const rpc = handlers.getSessionRPCHandlers?.(sessionId);
+    if (!rpc) throw new Error(`Session '${sessionId}' not found`);
+    const role = await rpc.getEffectiveRole(context).catch(() => null);
+    if (!role || (ROLE_RANK[role] ?? 0) < ROLE_RANK[requiredRole]) {
+      throw new Error(`Access denied: ${requiredRole} role required on session ${sessionId}`);
+    }
+  };
   const notifyListeners = (update) => {
     const snapshot = [...listeners];
     for (let i = snapshot.length - 1; i >= 0; i--) {
@@ -737,10 +846,22 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         authorizeRequest(context, currentMetadata.sharing, "view");
         return { sharing: currentMetadata.sharing || null };
       },
+      /** Returns the caller's effective role on this machine (null if no access). */
+      getEffectiveRole: async (context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        const role = getEffectiveRole(context, currentMetadata.sharing);
+        return { role };
+      },
       updateSharing: async (newSharing, context) => {
         authorizeRequest(context, currentMetadata.sharing, "admin");
-        if (currentMetadata.sharing && context?.user?.email && currentMetadata.sharing.owner && context.user.email.toLowerCase() !== currentMetadata.sharing.owner.toLowerCase()) {
-          throw new Error("Only the machine owner can update sharing settings");
+        const currentOwner = currentMetadata.sharing?.owner;
+        const callerEmail = context?.user?.email;
+        const callerIsOwner = !!currentOwner && !!callerEmail && callerEmail.toLowerCase() === currentOwner.toLowerCase();
+        if (currentOwner && newSharing.owner && newSharing.owner.toLowerCase() !== currentOwner.toLowerCase() && !callerIsOwner) {
+          throw new Error("Only the machine owner can transfer ownership");
+        }
+        if (currentOwner && !newSharing.owner) {
+          newSharing = { ...newSharing, owner: currentOwner };
         }
         if (newSharing.enabled && !newSharing.owner && context?.user?.email) {
           newSharing = { ...newSharing, owner: context.user.email };
@@ -1096,6 +1217,126 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         if (!handlers.supervisor) return [];
         return handlers.supervisor.getLogs(params.idOrName, params.last ?? 50);
       },
+      // ── Session-scoped Tasks panel ───────────────────────────────────
+      // Frontend-facing views that filter by sessionId and also walk the
+      // OS process tree to surface unsupervised child processes (e.g.
+      // `node server.js &` spawned from a bash tool call). These are
+      // separate from the global `process*` RPCs above so that a shared
+      // user can manage their own session's tasks without machine-level
+      // access.
+      /**
+       * Snapshot of everything the session's Tasks panel needs to render:
+       *   - supervised: ProcessSpec/state filtered to this session
+       *   - detected:   descendants of the agent PID that aren't supervised
+       */
+      sessionProcessList: async (params, context) => {
+        await authorizeSessionAccess(params.sessionId, "view", context);
+        const supervisor = handlers.supervisor;
+        const all = supervisor ? supervisor.list() : [];
+        const supervised = all.filter((p) => p.spec.sessionId === params.sessionId);
+        const agentPid = handlers.getSessionPid?.(params.sessionId);
+        let detected = [];
+        if (agentPid) {
+          const supervisedPids = /* @__PURE__ */ new Set();
+          for (const info of all) {
+            if (info.state.pid) supervisedPids.add(info.state.pid);
+          }
+          detected = await detectDescendants(agentPid, supervisedPids);
+        }
+        return { supervised, detected, agentPid };
+      },
+      /**
+       * Cheap counts for the input-bar badge — avoids the cost of a full
+       * detection walk when the panel is closed. Counts are still
+       * accurate enough to indicate "is anything running for this session".
+       */
+      sessionProcessCounts: async (params, context) => {
+        await authorizeSessionAccess(params.sessionId, "view", context);
+        const supervisor = handlers.supervisor;
+        const all = supervisor ? supervisor.list() : [];
+        const supervised = all.filter((p) => p.spec.sessionId === params.sessionId);
+        const supervisedRunning = supervised.filter((p) => p.state.status === "running" || p.state.status === "starting").length;
+        const agentPid = handlers.getSessionPid?.(params.sessionId);
+        let detected = 0;
+        if (agentPid) {
+          const supervisedPids = /* @__PURE__ */ new Set();
+          for (const info of all) if (info.state.pid) supervisedPids.add(info.state.pid);
+          const list = await detectDescendants(agentPid, supervisedPids);
+          detected = list.length;
+        }
+        return { supervised: supervised.length, supervisedRunning, detected, agentPid };
+      },
+      /** Logs for a supervised process, gated by session ownership. */
+      sessionProcessLogs: async (params, context) => {
+        await authorizeSessionAccess(params.sessionId, "view", context);
+        if (!handlers.supervisor) return [];
+        const info = handlers.supervisor.get(params.idOrName);
+        if (!info || info.spec.sessionId !== params.sessionId) return [];
+        return handlers.supervisor.getLogs(params.idOrName, params.last ?? 100);
+      },
+      /**
+       * Lifecycle actions on a session-bound supervised process.
+       * `remove` requires admin; start/stop/restart require interact.
+       */
+      sessionProcessAction: async (params, context) => {
+        const requiredRole = params.action === "remove" ? "admin" : "interact";
+        await authorizeSessionAccess(params.sessionId, requiredRole, context);
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        const info = handlers.supervisor.get(params.idOrName);
+        if (!info) throw new Error(`Process '${params.idOrName}' not found`);
+        if (info.spec.sessionId !== params.sessionId) {
+          throw new Error(`Process '${params.idOrName}' does not belong to this session`);
+        }
+        switch (params.action) {
+          case "start":
+            return handlers.supervisor.start(params.idOrName);
+          case "stop":
+            return handlers.supervisor.stop(params.idOrName);
+          case "restart":
+            return handlers.supervisor.restart(params.idOrName);
+          case "remove":
+            return handlers.supervisor.remove(params.idOrName);
+        }
+      },
+      /**
+       * Kill an unsupervised descendant of the agent. Verified by the
+       * detection helper so callers can only target PIDs that are
+       * actually children of this session.
+       */
+      sessionProcessKill: async (params, context) => {
+        await authorizeSessionAccess(params.sessionId, "admin", context);
+        const agentPid = handlers.getSessionPid?.(params.sessionId);
+        if (!agentPid) return { killed: false, reason: "no agent pid for session" };
+        return killDescendant(agentPid, Number(params.pid), params.signal ?? "SIGTERM");
+      },
+      /**
+       * Promote a detected child into supervision. Kills the original
+       * PID and re-spawns the same command under the supervisor, so the
+       * new process is properly tracked (PID re-parenting isn't
+       * achievable without ptrace).
+       */
+      sessionProcessAdopt: async (params, context) => {
+        await authorizeSessionAccess(params.sessionId, "admin", context);
+        if (!handlers.supervisor) throw new Error("Process supervisor not available");
+        const agentPid = handlers.getSessionPid?.(params.sessionId);
+        if (!agentPid) throw new Error("No agent pid for session");
+        if (params.pid && params.pid > 0) {
+          const res = await killDescendant(agentPid, Number(params.pid), "SIGTERM");
+          if (!res.killed && res.reason !== "pid is not a descendant of this session") ;
+        }
+        const spec = {
+          name: params.name,
+          command: params.command,
+          args: params.args ?? [],
+          workdir: params.workdir ?? process.cwd(),
+          keepAlive: params.keepAlive ?? false,
+          maxRestarts: 0,
+          restartDelay: 2,
+          sessionId: params.sessionId
+        };
+        const result = await handlers.supervisor.apply(spec);
+        return result.info;
+      },
       // ── Service / Tunnel management ──────────────────────────────────
       /** List active tunnels (replaces the old agent-sandbox serviceList). */
       serviceList: async (context) => {
@@ -1804,8 +2045,14 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     },
     updateSharing: async (newSharing, context) => {
       authorizeRequest(context, metadata.sharing, "admin");
-      if (metadata.sharing && context?.user?.email && metadata.sharing.owner && context.user.email.toLowerCase() !== metadata.sharing.owner.toLowerCase()) {
-        throw new Error("Only the session owner can update sharing settings");
+      const currentOwner = metadata.sharing?.owner;
+      const callerEmail = context?.user?.email;
+      const callerIsOwner = !!currentOwner && !!callerEmail && callerEmail.toLowerCase() === currentOwner.toLowerCase();
+      if (currentOwner && newSharing.owner && newSharing.owner.toLowerCase() !== currentOwner.toLowerCase() && !callerIsOwner) {
+        throw new Error("Only the session owner can transfer ownership");
+      }
+      if (currentOwner && !newSharing.owner) {
+        newSharing = { ...newSharing, owner: currentOwner };
       }
       if (newSharing.enabled && !newSharing.owner && context?.user?.email) {
         newSharing = { ...newSharing, owner: context.user.email };
@@ -1828,12 +2075,10 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       return { success: true, sharing: newSharing };
     },
     /** Update security context and restart the agent process with new rules.
-     *  Pass '__disable__' sentinel (from frontend) or null to disable isolation entirely. */
+     *  Pass '__disable__' sentinel (from frontend) or null to disable isolation entirely.
+     *  Admin tier (owner or admin-shared user) can perform this. */
     updateSecurityContext: async (newSecurityContext, context) => {
       authorizeRequest(context, metadata.sharing, "admin");
-      if (metadata.sharing && context?.user?.email && metadata.sharing.owner && context.user.email.toLowerCase() !== metadata.sharing.owner.toLowerCase()) {
-        throw new Error("Only the session owner can update security context");
-      }
       if (!callbacks.onUpdateSecurityContext) {
         throw new Error("Security context updates are not supported for this session");
       }
@@ -4655,7 +4900,7 @@ var GeminiTransport$1 = /*#__PURE__*/Object.freeze({
     GeminiTransport: GeminiTransport
 });
 
-const execFileAsync = promisify(execFile);
+const execFileAsync = promisify$1(execFile$1);
 const SVAMP_TOOLS_DIR = join$1(homedir(), ".svamp", "tools");
 const SVAMP_BIN_DIR = join$1(SVAMP_TOOLS_DIR, "bin");
 async function checkCommand(command, versionArgs) {
@@ -5401,9 +5646,13 @@ class ServeAuth {
   }
   /**
    * Check if a user email is authorized for a mount's access level.
+   * Note: 'link' mounts are gated by the auth proxy at the path-segment
+   * level (capability token), not by this method — they should never reach
+   * here. We treat them as deny-by-default just in case.
    */
   isAuthorized(email, access, ownerEmail) {
     if (access === "public") return true;
+    if (access === "link") return false;
     if (!email) return false;
     if (access === "owner") {
       return !!ownerEmail && email.toLowerCase() === ownerEmail.toLowerCase();
@@ -7441,7 +7690,7 @@ async function startDaemon(options) {
     const list = loadExposedTunnels().filter((t) => t.name !== name);
     saveExposedTunnels(list);
   }
-  const { ServeManager } = await import('./serveManager-C9pzi-2O.mjs');
+  const { ServeManager } = await import('./serveManager-G9PiLNKm.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -7738,6 +7987,9 @@ async function startDaemon(options) {
         let isKillingClaude = false;
         let isRestartingClaude = false;
         let isSwitchingMode = false;
+        const OVERLOAD_BAIL_THRESHOLD = 3;
+        let consecutiveOverloadRetries = 0;
+        let overloadBailedThisTurn = false;
         let checkSvampConfig;
         let cleanupSvampConfig;
         const VALID_CLAUDE_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "bypassPermissions"]);
@@ -7993,13 +8245,21 @@ async function startDaemon(options) {
                         logger.log(`[Session ${sessionId}] Startup failure detected \u2014 scheduling silent retry without --resume`);
                         startupFailureRetryPending = true;
                         lastErrorMessagePushed = true;
+                      } else if (overloadBailedThisTurn) {
+                        logger.log(`[Session ${sessionId}] Suppressing duplicate error \u2014 overload hint already pushed for this turn`);
+                        lastErrorMessagePushed = true;
                       } else {
                         const lower = resultText.toLowerCase();
+                        const isOverload = msg.api_error_status === 529 || lower.includes("529") || lower.includes("overload");
                         const isLoginIssue = lower.includes("login") || lower.includes("logged in") || lower.includes("auth") || lower.includes("api key") || lower.includes("unauthorized");
                         const isResumeIssue = lower.includes("tool_use.name") || lower.includes("invalid_request") || lower.includes("messages.");
                         const isBillingIssue = lower.includes("credit") || lower.includes("balance") || lower.includes("billing") || lower.includes("quota") || lower.includes("subscription") || lower.includes("payment");
                         let hint = "";
-                        if (isBillingIssue) {
+                        if (isOverload) {
+                          const onHyphaProxy = (process.env.SVAMP_CLAUDE_PROXY || "").toLowerCase() === "hypha";
+                          const proxyHint = onHyphaProxy ? "" : "\n\u2022 Switch the daemon to the Hypha proxy (rotates across accounts on 529): `svamp daemon auth use-hypha-proxy && svamp daemon restart`";
+                          hint = "\n\nAnthropic returned HTTP 529 Overloaded \u2014 server-side capacity, not your account. This session may be pinned to a hot backend shard.\n\u2022 Start a fresh session (different conversation id \u2192 different shard).\n\u2022 Wait a minute and resend.\n\u2022 Check https://status.claude.com." + proxyHint;
+                        } else if (isBillingIssue) {
                           hint = "\n\nCheck your Claude account credits or subscription at https://console.anthropic.com.";
                         } else if (isLoginIssue) {
                           checkAndRefreshOAuthToken(true, logger).then((r) => {
@@ -8287,6 +8547,8 @@ The automated loop has finished. Review the progress above and let me know if yo
                   sessionService.pushMessage(msg, "agent");
                 } else if (msg.type === "system" && msg.subtype === "init") {
                   lastAssistantText = "";
+                  consecutiveOverloadRetries = 0;
+                  overloadBailedThisTurn = false;
                   if (!userMessagePending) {
                     turnInitiatedByUser = false;
                     logger.log(`[Session ${sessionId}] SDK-initiated turn (likely stale task_notification)`);
@@ -8331,6 +8593,34 @@ The automated loop has finished. Review the progress above and let me know if yo
                     sessionService.updateMetadata(sessionMetadata);
                   }
                   sessionService.pushMessage(msg, "session");
+                } else if (msg.type === "system" && msg.subtype === "api_retry") {
+                  if (msg.error_status === 529) {
+                    consecutiveOverloadRetries++;
+                    if (consecutiveOverloadRetries >= OVERLOAD_BAIL_THRESHOLD && !overloadBailedThisTurn) {
+                      overloadBailedThisTurn = true;
+                      const onHyphaProxy = (process.env.SVAMP_CLAUDE_PROXY || "").toLowerCase() === "hypha";
+                      const proxyHint = onHyphaProxy ? "" : "\n\u2022 Switch the daemon to the Hypha proxy (which rotates across accounts on 529): `svamp daemon auth use-hypha-proxy && svamp daemon restart`";
+                      const hint = `Anthropic returned HTTP 529 Overloaded ${consecutiveOverloadRetries} times in a row. This is server-side capacity, not your account \u2014 typically a hot backend shard pinned to this session. Stopping early so you don't wait for the SDK's full ~4 min retry storm.
+
+**Try:**
+\u2022 Start a fresh session (different conversation id \u2192 different shard).
+\u2022 Wait a minute and resend.
+\u2022 Check https://status.claude.com.` + proxyHint;
+                      logger.log(`[Session ${sessionId}] Bailing on ${consecutiveOverloadRetries}\xD7 consecutive 529 retries \u2014 sending interrupt`);
+                      sessionService.pushMessage({ type: "message", message: hint, level: "warning" }, "event");
+                      try {
+                        if (claudeProcess && !claudeProcess.killed && claudeProcess.stdin) {
+                          const interruptMsg = JSON.stringify({ type: "control_request", request: { type: "interrupt" } });
+                          claudeProcess.stdin.write(interruptMsg + "\n");
+                        }
+                      } catch (err) {
+                        logger.log(`[Session ${sessionId}] Failed to send overload interrupt: ${err.message}`);
+                      }
+                    }
+                  } else {
+                    consecutiveOverloadRetries = 0;
+                  }
+                  sessionService.pushMessage(msg, "agent");
                 } else if (msg.type === "system" && msg.subtype === "task_notification" && msg.status === "completed") {
                   backgroundTaskCount = Math.max(0, backgroundTaskCount - 1);
                   if (backgroundTaskNames.length > 0) {
@@ -9820,6 +10110,14 @@ The automated loop has finished. Review the progress above and let me know if yo
           }
           return ids;
         },
+        getSessionPid: (sessionId) => {
+          for (const [, session] of pidToTrackedSession) {
+            if (session.svampSessionId === sessionId && !session.stopped) {
+              return session.childProcess?.pid;
+            }
+          }
+          return void 0;
+        },
         supervisor,
         tunnels,
         serveManager,

package/dist/{serveCommands-CMSmcjsp.mjs → serveCommands-CtAX-CMI.mjs}

@@ -54,17 +54,20 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+  const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
-    console.error("Usage: svamp serve [add] <name> [directory] [--public | --access email1,email2]");
+    console.error("Usage: svamp serve [add] <name> [directory] [--public | --owner | --access email1,email2]");
+    console.error("  Default: capability URL (link mode) \u2014 anyone with the URL can view, no login required.");
     process.exit(1);
   }
   const directory = path.resolve(pos[1] || ".");
-  let access = "owner";
+  let access = "link";
   if (hasFlag(args, "--public")) {
     access = "public";
+  } else if (hasFlag(args, "--owner")) {
+    access = "owner";
   } else {
     const accessFlag = getFlag(args, "--access");
     if (accessFlag) {
@@ -75,8 +78,12 @@ async function serveAdd(args, machineId) {
   try {
     const result = await machine.serveAdd({ name, directory, access });
     console.log(`Mount added: ${name} \u2192 ${directory}`);
-    console.log(`Access: ${access === "public" ? "public" : access === "owner" ? "owner only" : access.join(", ")}`);
+    const accessLabel = access === "public" ? "public (no auth)" : access === "link" ? "link (capability URL \u2014 anyone with the URL can view)" : access === "owner" ? "owner only (Hypha login)" : `${access.join(", ")} (Hypha login)`;
+    console.log(`Access: ${accessLabel}`);
     console.log(`URL: ${result.url}`);
+    if (access === "link") {
+      console.log(`(URL embeds a long capability token; keep it secret to keep the mount private.)`);
+    }
   } catch (err) {
     console.error(`Error: ${err.message || err}`);
     process.exit(1);
@@ -86,7 +93,7 @@ async function serveAdd(args, machineId) {
   }
 }
 async function serveApply(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+  const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
   const fs = await import('fs');
   const yaml = await import('yaml');
   const file = positionalArgs(args)[0];
@@ -107,7 +114,10 @@ async function serveApply(args, machineId) {
     console.error("    warmup_timeout_ms: 30000");
     console.error("    idle_timeout_sec: 600   # 0 = always running");
     console.error("    wake_on_request: true   # spawn lazily on first request");
-    console.error("  access: public            # public | owner (default) | [emails]");
+    console.error("  access: link              # link (default) | public | owner | [emails]");
+    console.error("  # link  \u2014 capability URL, anyone with the URL can view");
+    console.error("  # public \u2014 fully open, short URL");
+    console.error("  # owner / [emails] \u2014 Hypha login required");
     process.exit(1);
   }
   if (!fs.existsSync(file)) {
@@ -150,7 +160,8 @@ async function serveApply(args, machineId) {
     directory: parsed.directory ? path.resolve(parsed.directory) : void 0,
     process: proc,
     sessionId: parsed.sessionId ?? parsed.session_id,
-    access: parsed.access ?? "owner",
+    access: parsed.access ?? "link",
+    // default flipped from 'owner' to 'link' (capability URL)
     ownerEmail: parsed.ownerEmail ?? parsed.owner_email
   };
   const { machine, server } = await connectAndGetMachine(machineId);
@@ -171,7 +182,7 @@ async function serveApply(args, machineId) {
   }
 }
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+  const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -191,7 +202,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+  const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -224,7 +235,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-B0kLKYmc.mjs');
+  const { connectAndGetMachine } = await import('./commands-CEazgqvj.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();
@@ -258,10 +269,14 @@ Usage:
   svamp serve list [--all] [--json]    List mounts (default: current session only)
   svamp serve info                     Show server status and URL
 
-Access control (default: owner only):
-  --public                  Allow anyone to access (no auth)
-  --access email1,email2    Allow specific users (comma-separated emails)
-  (no flag)                 Owner only \u2014 requires Hypha login
+Access tiers (default: link):
+  (no flag)                 Capability URL \u2014 anyone with the URL can view.
+                            URL embeds a long random token (~192-bit entropy)
+                            as the first path segment. No login required.
+                            Best for embedding in agent artifact iframes.
+  --public                  Fully public \u2014 no auth, short URL.
+  --owner                   Hypha login required, owner-only.
+  --access email1,email2    Hypha login required, specific allowed emails.
 
 Options:
   -m, --machine <id>    Target a specific machine
@@ -270,12 +285,13 @@ Options:
   --json                Output as JSON
 
 Examples:
-  svamp serve my-report ./output               # Owner-only (default)
-  svamp serve dashboard ./dist --public        # Anyone can access
-  svamp serve data ./csv --access a@x.com,b@y.com  # Specific users
-  svamp serve apply my-app.yaml                # Declarative apply
-  svamp serve list --all                       # Show all mounts
-  svamp serve remove my-report                 # Stop serving
+  svamp serve my-report ./output                   # Default: capability URL
+  svamp serve dashboard ./dist --public            # Anyone, short URL
+  svamp serve data ./csv --owner                   # Hypha login required
+  svamp serve data ./csv --access a@x.com,b@y.com  # Specific Hypha users
+  svamp serve apply my-app.yaml                    # Declarative apply
+  svamp serve list --all                           # Show all mounts
+  svamp serve remove my-report                     # Stop serving
 
 Declarative apply (svamp serve apply <yaml>):
   name: my-app

package/dist/{serveManager-C9pzi-2O.mjs → serveManager-G9PiLNKm.mjs}

@@ -1,14 +1,15 @@
 import { spawn } from 'child_process';
+import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as http from 'http';
 import * as net from 'net';
 import * as path from 'path';
-import { S as ServeAuth, h as hasCookieToken } from './run-Dhliie9Z.mjs';
+import { S as ServeAuth, h as hasCookieToken } from './run-DypcS01S.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';
-import 'crypto';
 import 'node:fs';
+import 'util';
 import 'node:crypto';
 import 'node:path';
 import 'node:child_process';
@@ -21,6 +22,9 @@ import 'zod';
 import 'node:fs/promises';
 import 'node:util';
 
+function generateLinkToken() {
+  return crypto.randomBytes(16).toString("hex");
+}
 function findFreePort() {
   return new Promise((resolve, reject) => {
     const srv = net.createServer();
@@ -88,7 +92,7 @@ class ServeManager {
    * Throws if a mount with the same name already exists, preserving the
    * pre-existing semantics that callers may depend on.
    */
-  async addMount(name, directory, sessionId, access = "owner", ownerEmail) {
+  async addMount(name, directory, sessionId, access = "link", ownerEmail) {
     if (this.mounts.has(name)) {
       throw new Error(`Mount '${name}' already exists. Remove it first or choose a different name.`);
     }
@@ -123,13 +127,18 @@ class ServeManager {
     if (this.mounts.has(spec.name)) {
       await this.removeMount(spec.name);
     }
+    const access = spec.access ?? "link";
     const mount = {
       name: spec.name,
       directory: resolvedDir,
       process: spec.process,
       sessionId: spec.sessionId,
       ownerEmail: spec.ownerEmail,
-      access: spec.access ?? "owner",
+      access,
+      // Generate a capability token if access is 'link' and we don't
+      // already have one from persisted state (token is stable across
+      // restarts).
+      linkToken: access === "link" ? spec.linkToken || generateLinkToken() : void 0,
       addedAt: Date.now()
     };
     this.mounts.set(spec.name, mount);
@@ -432,11 +441,18 @@ class ServeManager {
     }, 3e4);
   }
   // ── Internal ─────────────────────────────────────────────────────────
-  /** Get the public URL for a mount (mount-specific subdomain). */
+  /**
+   * Get the public URL for a mount (mount-specific subdomain).
+   * For `access: 'link'` mounts, the subdomain itself carries the capability —
+   * the tunnel registers a long random suffix (~128 bits of entropy), so the
+   * URL is identical in shape to other tiers, just longer. Content serves
+   * from the root, so HTML with absolute paths (`/style.css`, `/app.js`)
+   * works unchanged.
+   */
   getMountUrl(name) {
     const tunnel = this.mountTunnels.get(name);
-    const url = tunnel?.getUrls().get(this.port);
-    if (url) return `${url}/`;
+    const tunnelUrl = tunnel?.getUrls().get(this.port);
+    if (tunnelUrl) return `${tunnelUrl}/`;
     if (this.port) return `http://127.0.0.1:${this.port}/${name}/`;
     return null;
   }
@@ -523,7 +539,7 @@ class ServeManager {
           res.end(html);
           return;
         }
-        if (mount && mount.access !== "public") {
+        if (mount && mount.access !== "public" && mount.access !== "link") {
           const userEmail = this.auth ? await this.auth.authenticate(req).catch(() => null) : null;
           const allowed = this.auth ? this.auth.isAuthorized(userEmail, mount.access, mount.ownerEmail) : false;
           if (!allowed) {
@@ -668,12 +684,15 @@ class ServeManager {
     if (!this.port) throw new Error("Auth proxy not running \u2014 call ensureRunning() first");
     const subdomainSafe = mountName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
     const tunnelName = `static-${subdomainSafe}`;
+    const mount = this.mounts.get(mountName);
+    const subdomainOverride = mount?.access === "link" && mount.linkToken ? /* @__PURE__ */ new Map([[this.port, `static-${subdomainSafe}-${mount.linkToken}`]]) : void 0;
     try {
       const { FrpcTunnel } = await import('./frpc-j60b46eU.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,
         ports: [this.port],
+        subdomains: subdomainOverride,
         // End-to-end probe: the daemon's health loop watches probe.ok
         // to detect ghosted tunnel registrations (frpc says "connected"
         // but no traffic actually flows). The sentinel route is served

package/package.json

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