svamp-cli 0.2.46 → 0.2.48

package/dist/{agentCommands-Bqjcj1EX.mjs → agentCommands-BuGwfYhd.mjs}

@@ -148,7 +148,7 @@ async function sessionBroadcast(action, args) {
   console.log(`Broadcast sent: ${action}`);
 }
 async function connectToMachineService() {
-  const { connectAndGetMachine } = await import('./commands-B6zZtCuh.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.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-B6zZtCuh.mjs');
+    const { resolveSessionId } = await import('./commands-JWrmpGcs.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-wfhhtkl1.mjs';
+import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-6umeTX-K.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -42,7 +42,7 @@ async function main() {
         console.error(`svamp daemon restart: ${err.message || err}`);
         process.exit(1);
       }
-      const { restartDaemon } = await import('./run-wfhhtkl1.mjs').then(function (n) { return n.o; });
+      const { restartDaemon } = await import('./run-6umeTX-K.mjs').then(function (n) { return n.o; });
       await restartDaemon();
       process.exit(0);
     }
@@ -277,7 +277,7 @@ async function main() {
       console.error("svamp service: Service commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { handleServiceCommand } = await import('./commands-DsCkxa3k.mjs');
+    const { handleServiceCommand } = await import('./commands-TyAIFJx-.mjs');
     await handleServiceCommand();
   } else if (subcommand === "serve") {
     const { isSandboxed: isSandboxedServe } = await import('./sandboxDetect-DNTcbgWD.mjs');
@@ -285,7 +285,7 @@ async function main() {
       console.error("svamp serve: Serve commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { handleServeCommand } = await import('./serveCommands-DhtNhaur.mjs');
+    const { handleServeCommand } = await import('./serveCommands-FUE8m232.mjs');
     await handleServeCommand();
     process.exit(0);
   } else if (subcommand === "process" || subcommand === "proc") {
@@ -294,7 +294,7 @@ async function main() {
       console.error("svamp process: Process commands are not available in sandboxed sessions.");
       process.exit(1);
     }
-    const { processCommand } = await import('./commands-Cs5-T_lh.mjs');
+    const { processCommand } = await import('./commands-BJR_98XX.mjs');
     let machineId;
     const processArgs = args.slice(1);
     const mIdx = processArgs.findIndex((a) => a === "--machine" || a === "-m");
@@ -312,7 +312,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-CyXoMaC5.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-DVfaovNL.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);
@@ -321,7 +321,7 @@ async function main() {
   }
 }
 async function handleInteractiveCommand() {
-  const { runInteractive } = await import('./run-yJ1mtT8S.mjs');
+  const { runInteractive } = await import('./run-DR7E3IZL.mjs');
   const interactiveArgs = subcommand === "start" ? args.slice(1) : args;
   let directory = process.cwd();
   let resumeSessionId;
@@ -366,7 +366,7 @@ async function handleAgentCommand() {
     return;
   }
   if (agentArgs[0] === "list") {
-    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-wfhhtkl1.mjs').then(function (n) { return n.j; });
+    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-6umeTX-K.mjs').then(function (n) { return n.j; });
     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)`);
@@ -378,7 +378,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-wfhhtkl1.mjs').then(function (n) { return n.j; });
+  const { resolveAcpAgentConfig, KNOWN_MCP_AGENTS } = await import('./run-6umeTX-K.mjs').then(function (n) { return n.j; });
   let cwd = process.cwd();
   const filteredArgs = [];
   for (let i = 0; i < agentArgs.length; i++) {
@@ -402,12 +402,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-wfhhtkl1.mjs').then(function (n) { return n.k; });
+    const { CodexMcpBackend } = await import('./run-6umeTX-K.mjs').then(function (n) { return n.k; });
     backend = new CodexMcpBackend({ cwd, log: logFn });
   } else {
-    const { AcpBackend } = await import('./run-wfhhtkl1.mjs').then(function (n) { return n.i; });
-    const { GeminiTransport } = await import('./run-wfhhtkl1.mjs').then(function (n) { return n.G; });
-    const { DefaultTransport } = await import('./run-wfhhtkl1.mjs').then(function (n) { return n.D; });
+    const { AcpBackend } = await import('./run-6umeTX-K.mjs').then(function (n) { return n.i; });
+    const { GeminiTransport } = await import('./run-6umeTX-K.mjs').then(function (n) { return n.G; });
+    const { DefaultTransport } = await import('./run-6umeTX-K.mjs').then(function (n) { return n.D; });
     const transportHandler = config.agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(config.agentName);
     backend = new AcpBackend({
       agentName: config.agentName,
@@ -534,7 +534,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-B6zZtCuh.mjs');
+  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait, sessionShare, sessionRalphStart, sessionRalphCancel, sessionRalphStatus, sessionInboxSend, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxClear } = await import('./commands-JWrmpGcs.mjs');
   const parseFlagStr = (flag, shortFlag) => {
     for (let i = 1; i < sessionArgs.length; i++) {
       if ((sessionArgs[i] === flag || shortFlag) && i + 1 < sessionArgs.length) {
@@ -594,7 +594,7 @@ async function handleSessionCommand() {
         allowDomain.push(sessionArgs[++i]);
       }
     }
-    const { parseShareArg } = await import('./commands-B6zZtCuh.mjs');
+    const { parseShareArg } = await import('./commands-JWrmpGcs.mjs');
     const shareEntries = share.map((s) => parseShareArg(s));
     await sessionSpawn(agent, dir, targetMachineId, {
       message,
@@ -680,7 +680,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session approve <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionApprove } = await import('./commands-B6zZtCuh.mjs');
+    const { sessionApprove } = await import('./commands-JWrmpGcs.mjs');
     const approveReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionApprove(sessionArgs[1], approveReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -690,7 +690,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session deny <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionDeny } = await import('./commands-B6zZtCuh.mjs');
+    const { sessionDeny } = await import('./commands-JWrmpGcs.mjs');
     const denyReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionDeny(sessionArgs[1], denyReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -726,7 +726,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session set-title <title>");
       process.exit(1);
     }
-    const { sessionSetTitle } = await import('./agentCommands-Bqjcj1EX.mjs');
+    const { sessionSetTitle } = await import('./agentCommands-BuGwfYhd.mjs');
     await sessionSetTitle(title);
   } else if (sessionSubcommand === "set-link") {
     const url = sessionArgs[1];
@@ -735,7 +735,7 @@ async function handleSessionCommand() {
       process.exit(1);
     }
     const label = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
-    const { sessionSetLink } = await import('./agentCommands-Bqjcj1EX.mjs');
+    const { sessionSetLink } = await import('./agentCommands-BuGwfYhd.mjs');
     await sessionSetLink(url, label);
   } else if (sessionSubcommand === "notify") {
     const message = sessionArgs[1];
@@ -744,7 +744,7 @@ async function handleSessionCommand() {
       process.exit(1);
     }
     const level = parseFlagStr("--level") || "info";
-    const { sessionNotify } = await import('./agentCommands-Bqjcj1EX.mjs');
+    const { sessionNotify } = await import('./agentCommands-BuGwfYhd.mjs');
     await sessionNotify(message, level);
   } else if (sessionSubcommand === "broadcast") {
     const action = sessionArgs[1];
@@ -752,7 +752,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-Bqjcj1EX.mjs');
+    const { sessionBroadcast } = await import('./agentCommands-BuGwfYhd.mjs');
     await sessionBroadcast(action, sessionArgs.slice(2).filter((a) => !a.startsWith("--")));
   } else if (sessionSubcommand === "inbox") {
     const inboxSubcmd = sessionArgs[1];
@@ -763,7 +763,7 @@ async function handleSessionCommand() {
         process.exit(1);
       }
       if (agentSessionId) {
-        const { inboxSend } = await import('./agentCommands-Bqjcj1EX.mjs');
+        const { inboxSend } = await import('./agentCommands-BuGwfYhd.mjs');
         await inboxSend(sessionArgs[2], {
           body: sessionArgs[3],
           subject: parseFlagStr("--subject"),
@@ -778,7 +778,7 @@ async function handleSessionCommand() {
       }
     } else if (inboxSubcmd === "list" || inboxSubcmd === "ls") {
       if (agentSessionId && !sessionArgs[2]) {
-        const { inboxList } = await import('./agentCommands-Bqjcj1EX.mjs');
+        const { inboxList } = await import('./agentCommands-BuGwfYhd.mjs');
         await inboxList({
           unread: hasFlag("--unread"),
           limit: parseFlagInt("--limit"),
@@ -800,7 +800,7 @@ async function handleSessionCommand() {
         process.exit(1);
       }
       if (agentSessionId && !sessionArgs[3]) {
-        const { inboxList } = await import('./agentCommands-Bqjcj1EX.mjs');
+        const { inboxList } = await import('./agentCommands-BuGwfYhd.mjs');
         await sessionInboxRead(agentSessionId, sessionArgs[2], targetMachineId);
       } else if (sessionArgs[3]) {
         await sessionInboxRead(sessionArgs[2], sessionArgs[3], targetMachineId);
@@ -810,7 +810,7 @@ async function handleSessionCommand() {
       }
     } else if (inboxSubcmd === "reply") {
       if (agentSessionId && sessionArgs[2] && sessionArgs[3] && !sessionArgs[4]) {
-        const { inboxReply } = await import('./agentCommands-Bqjcj1EX.mjs');
+        const { inboxReply } = await import('./agentCommands-BuGwfYhd.mjs');
         await inboxReply(sessionArgs[2], sessionArgs[3]);
       } else if (sessionArgs[2] && sessionArgs[3] && sessionArgs[4]) {
         await sessionInboxReply(sessionArgs[2], sessionArgs[3], sessionArgs[4], targetMachineId);
@@ -846,7 +846,7 @@ async function handleMachineCommand() {
     return;
   }
   if (machineSubcommand === "share") {
-    const { machineShare } = await import('./commands-B6zZtCuh.mjs');
+    const { machineShare } = await import('./commands-JWrmpGcs.mjs');
     let machineId;
     const shareArgs = [];
     for (let i = 1; i < machineArgs.length; i++) {
@@ -876,7 +876,7 @@ async function handleMachineCommand() {
     }
     await machineShare(machineId, { add, remove, list, configPath, showConfig });
   } else if (machineSubcommand === "exec") {
-    const { machineExec } = await import('./commands-B6zZtCuh.mjs');
+    const { machineExec } = await import('./commands-JWrmpGcs.mjs');
     let machineId;
     let cwd;
     const cmdParts = [];
@@ -896,7 +896,7 @@ async function handleMachineCommand() {
     }
     await machineExec(machineId, command, cwd);
   } else if (machineSubcommand === "info") {
-    const { machineInfo } = await import('./commands-B6zZtCuh.mjs');
+    const { machineInfo } = await import('./commands-JWrmpGcs.mjs');
     let machineId;
     for (let i = 1; i < machineArgs.length; i++) {
       if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
@@ -916,10 +916,10 @@ async function handleMachineCommand() {
         level = machineArgs[++i];
       }
     }
-    const { machineNotify } = await import('./agentCommands-Bqjcj1EX.mjs');
+    const { machineNotify } = await import('./agentCommands-BuGwfYhd.mjs');
     await machineNotify(message, level);
   } else if (machineSubcommand === "ls") {
-    const { machineLs } = await import('./commands-B6zZtCuh.mjs');
+    const { machineLs } = await import('./commands-JWrmpGcs.mjs');
     let machineId;
     let showHidden = false;
     let path;
@@ -1381,7 +1381,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-wfhhtkl1.mjs').then(function (n) { return n.n; });
+  const mod = await import('./run-6umeTX-K.mjs').then(function (n) { return n.n; });
   if (hasHypha) {
     mod.setClaudeAuthHyphaProxy();
     console.log("Claude auth configured: hypha-proxy (uses HYPHA_TOKEN live at each spawn).");
@@ -1404,7 +1404,7 @@ async function applyClaudeAuthFlags(argv) {
 }
 async function handleDaemonAuthCommand(argv) {
   const sub = (argv[0] || "status").toLowerCase();
-  const mod = await import('./run-wfhhtkl1.mjs').then(function (n) { return n.n; });
+  const mod = await import('./run-6umeTX-K.mjs').then(function (n) { return n.n; });
   if (sub === "--help" || sub === "-h" || sub === "help") {
     console.log(`
 svamp daemon auth \u2014 Configure how Claude subprocesses authenticate

package/dist/{commands-Cs5-T_lh.mjs → commands-BJR_98XX.mjs}

@@ -1,11 +1,11 @@
 import { writeFileSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { connectAndGetMachine } from './commands-B6zZtCuh.mjs';
+import { connectAndGetMachine } from './commands-JWrmpGcs.mjs';
 import 'node:fs';
 import 'node:child_process';
 import 'node:path';
 import 'node:os';
-import './run-wfhhtkl1.mjs';
+import './run-6umeTX-K.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';

package/dist/{commands-B6zZtCuh.mjs → commands-JWrmpGcs.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-wfhhtkl1.mjs';
+import { l as loadSecurityContextConfig, e as resolveSecurityContext, f as buildSecurityContextFromFlags, m as mergeSecurityContexts, c as connectToHypha } from './run-6umeTX-K.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{commands-DsCkxa3k.mjs → commands-TyAIFJx-.mjs}

@@ -97,7 +97,7 @@ async function serviceServe(args) {
 }
 async function serviceList(_args) {
   try {
-    const { connectAndGetMachine } = await import('./commands-B6zZtCuh.mjs');
+    const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
     const { server, machine } = await connectAndGetMachine();
     try {
       const tunnels = await machine.tunnelList({});
@@ -126,7 +126,7 @@ async function serviceDelete(args) {
     process.exit(1);
   }
   try {
-    const { connectAndGetMachine } = await import('./commands-B6zZtCuh.mjs');
+    const { connectAndGetMachine } = await import('./commands-JWrmpGcs.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-wfhhtkl1.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-6umeTX-K.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{package-CyXoMaC5.mjs → package-DVfaovNL.mjs}

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

package/dist/{run-wfhhtkl1.mjs → run-6umeTX-K.mjs}

@@ -1149,6 +1149,26 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const access = params.access || "owner";
         return sm.addMount(params.name, params.directory, params.sessionId, access, ownerEmail);
       },
+      /**
+       * Apply a mount declaratively. Replaces existing mount with same name.
+       * Supports static (directory) and managed-process (process) mounts.
+       * Used by `svamp serve apply <yaml>`.
+       */
+      serveApply: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        const sm = handlers.serveManager;
+        if (!sm) throw new Error("Serve manager not available");
+        const ownerEmail = params.ownerEmail || context?.user?.email || void 0;
+        const access = params.access ?? "owner";
+        return sm.applyMount({
+          name: params.name,
+          directory: params.directory,
+          process: params.process,
+          sessionId: params.sessionId,
+          access,
+          ownerEmail
+        });
+      },
       /** Remove a mount from the shared static file server. */
       serveRemove: async (params, context) => {
         authorizeRequest(context, currentMetadata.sharing, "interact");
@@ -1325,6 +1345,19 @@ function loadMessagesFromDiskReverse(messagesDir, beforeSeq, limit) {
     return { messages: [], hasMore: false };
   }
 }
+function countMessagesOnDisk(messagesDir, fallbackInMemory) {
+  const filePath = join$1(messagesDir, "messages.jsonl");
+  if (!existsSync(filePath)) return fallbackInMemory;
+  try {
+    const data = readFileSync(filePath, "utf-8");
+    let count = 0;
+    for (let i = 0; i < data.length; i++) if (data.charCodeAt(i) === 10) count++;
+    if (data.length > 0 && data[data.length - 1] !== "\n") count++;
+    return count;
+  } catch {
+    return fallbackInMemory;
+  }
+}
 function appendMessage(messagesDir, sessionId, msg) {
   try {
     const filePath = join$1(messagesDir, "messages.jsonl");
@@ -1464,6 +1497,12 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
         hasMore: filtered.length > lim
       };
     },
+    getMessageCount: async (context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      const latestSeq = nextSeq - 1;
+      const count = options?.messagesDir ? countMessagesOnDisk(options.messagesDir, messages.length) : messages.length;
+      return { count, latestSeq };
+    },
     getLatestMessages: async (beforeSeq, limit, context) => {
       authorizeRequest(context, metadata.sharing, "view");
       const lim = Math.min(limit ?? 100, 500);
@@ -6874,7 +6913,7 @@ async function startDaemon(options) {
   const supervisor = new ProcessSupervisor(join(SVAMP_HOME, "processes"));
   await supervisor.init();
   const tunnels = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-CUcu_V3q.mjs');
+  const { ServeManager } = await import('./serveManager-RvRL-weX.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });

package/dist/{run-yJ1mtT8S.mjs → run-DR7E3IZL.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, h as generateHookSettings } from './run-wfhhtkl1.mjs';
+import { c as connectToHypha, a as registerSessionService, h as generateHookSettings } from './run-6umeTX-K.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';

package/dist/{serveCommands-DhtNhaur.mjs → serveCommands-FUE8m232.mjs}

@@ -45,6 +45,8 @@ async function handleServeCommand() {
     await serveInfo(machineId);
   } else if (sub === "add") {
     await serveAdd(filteredArgs.slice(1), machineId);
+  } else if (sub === "apply") {
+    await serveApply(filteredArgs.slice(1), machineId);
   } else if (sub && !sub.startsWith("-")) {
     await serveAdd(filteredArgs, machineId);
   } else {
@@ -52,7 +54,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-B6zZtCuh.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -83,8 +85,93 @@ async function serveAdd(args, machineId) {
     });
   }
 }
+async function serveApply(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
+  const fs = await import('fs');
+  const yaml = await import('yaml');
+  const file = positionalArgs(args)[0];
+  if (!file) {
+    console.error("Usage: svamp serve apply <yaml-or-json-file> [--machine <id>]");
+    console.error("");
+    console.error("YAML format:");
+    console.error("  name: my-app");
+    console.error("  # Static mount:");
+    console.error("  directory: ./public");
+    console.error("  # OR managed-process mount:");
+    console.error("  process:");
+    console.error("    command: npm");
+    console.error("    args: [start]");
+    console.error("    port: 3000");
+    console.error("    workdir: .");
+    console.error("    warmup_path: /          # default '/'");
+    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]");
+    process.exit(1);
+  }
+  if (!fs.existsSync(file)) {
+    console.error(`Error: file not found: ${file}`);
+    process.exit(1);
+  }
+  const raw = fs.readFileSync(file, "utf-8");
+  let parsed;
+  try {
+    parsed = file.endsWith(".json") ? JSON.parse(raw) : yaml.parse(raw);
+  } catch (err) {
+    console.error(`Error: failed to parse ${file}: ${err.message}`);
+    process.exit(1);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    console.error("Error: top-level config must be an object");
+    process.exit(1);
+  }
+  if (!parsed.name) {
+    console.error("Error: name is required");
+    process.exit(1);
+  }
+  if (!parsed.directory && !parsed.process) {
+    console.error("Error: must specify either directory (static) or process (managed)");
+    process.exit(1);
+  }
+  const proc = parsed.process ? {
+    command: parsed.process.command,
+    args: parsed.process.args,
+    port: parsed.process.port,
+    workdir: parsed.process.workdir ? path.resolve(parsed.process.workdir) : void 0,
+    env: parsed.process.env,
+    warmupPath: parsed.process.warmupPath ?? parsed.process.warmup_path,
+    warmupTimeoutMs: parsed.process.warmupTimeoutMs ?? parsed.process.warmup_timeout_ms,
+    idleTimeoutSec: parsed.process.idleTimeoutSec ?? parsed.process.idle_timeout_sec,
+    wakeOnRequest: parsed.process.wakeOnRequest ?? parsed.process.wake_on_request
+  } : void 0;
+  const params = {
+    name: parsed.name,
+    directory: parsed.directory ? path.resolve(parsed.directory) : void 0,
+    process: proc,
+    sessionId: parsed.sessionId ?? parsed.session_id,
+    access: parsed.access ?? "owner",
+    ownerEmail: parsed.ownerEmail ?? parsed.owner_email
+  };
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const result = await machine.serveApply(params);
+    const kind = proc ? "managed" : "static";
+    const what = proc ? `${proc.command}${proc.args?.length ? " " + proc.args.join(" ") : ""} (port ${proc.port})` : params.directory;
+    console.log(`Mount applied (${kind}): ${params.name} \u2192 ${what}`);
+    if (proc?.wakeOnRequest) console.log("Wake-on-request: enabled (process starts on first incoming request)");
+    if (proc?.idleTimeoutSec) console.log(`Idle timeout: ${proc.idleTimeoutSec}s`);
+    console.log(`URL: ${result.url}`);
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-B6zZtCuh.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -104,7 +191,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-B6zZtCuh.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -137,7 +224,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-B6zZtCuh.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();
@@ -164,6 +251,9 @@ Multiple sessions can register different mount points without port conflicts.
 Usage:
   svamp serve <name> [directory]       Add a mount and print its URL (dir defaults to .)
   svamp serve add <name> [directory]   Same as above
+  svamp serve apply <yaml>             Apply a declarative mount config (idempotent).
+                                       Supports static and managed-process mounts
+                                       with wake-on-request and idle timeout.
   svamp serve remove <name>            Remove a mount
   svamp serve list [--all] [--json]    List mounts (default: current session only)
   svamp serve info                     Show server status and URL
@@ -183,8 +273,21 @@ 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
+
+Declarative apply (svamp serve apply <yaml>):
+  name: my-app
+  process:
+    command: npm
+    args: [start]
+    port: 3000
+    workdir: .
+    warmup_path: /
+    idle_timeout_sec: 600
+    wake_on_request: true
+  access: public
 `);
 }
 

package/dist/{serveManager-CUcu_V3q.mjs → serveManager-RvRL-weX.mjs}

@@ -1,3 +1,4 @@
+import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as http from 'http';
 import * as net from 'net';
@@ -281,6 +282,10 @@ class ServeManager {
   caddy = null;
   proxyServer = null;
   auth = null;
+  /** Live child processes for managed mounts. Keyed by mount name. */
+  managedProcs = /* @__PURE__ */ new Map();
+  /** Single timer that scans managed mounts every 30s for idle eviction. */
+  idleTimer = null;
   persistFile;
   log;
   hyphaServerUrl;
@@ -292,35 +297,72 @@ class ServeManager {
   }
   // ── Public API ───────────────────────────────────────────────────────
   /**
-   * Add a mount and start Caddy + frpc tunnel if not already running.
-   * Returns the public URL for this mount.
+   * Add a static mount (backward-compatible thin wrapper around applyMount).
+   * 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) {
-    validateMountName(name);
-    const resolvedDir = path.resolve(directory);
-    if (!fs.existsSync(resolvedDir)) {
-      throw new Error(`Path does not exist: ${resolvedDir}`);
-    }
     if (this.mounts.has(name)) {
       throw new Error(`Mount '${name}' already exists. Remove it first or choose a different name.`);
     }
+    return this.applyMount({ name, directory, sessionId, access, ownerEmail });
+  }
+  /**
+   * Apply a mount declaratively. Unifies static and managed-process mounts:
+   * pass `directory` for static, `process` for managed (or both — `process`
+   * takes precedence for routing). Replaces an existing mount with the same
+   * name (idempotent), so repeated `svamp serve apply` is safe.
+   *
+   * Backward-compatible: existing `addMount(name, directory, ...)` callers
+   * still work and produce the same result as `applyMount({name, directory, ...})`.
+   */
+  async applyMount(spec) {
+    validateMountName(spec.name);
+    if (!spec.directory && !spec.process) {
+      throw new Error(`Mount '${spec.name}': must specify either directory (static) or process (managed)`);
+    }
+    if (spec.process) {
+      if (!spec.process.command) {
+        throw new Error(`Mount '${spec.name}': process.command is required`);
+      }
+      if (!spec.process.port || spec.process.port <= 0) {
+        throw new Error(`Mount '${spec.name}': process.port must be a positive integer`);
+      }
+    }
+    const resolvedDir = spec.directory ? path.resolve(spec.directory) : void 0;
+    if (resolvedDir && !fs.existsSync(resolvedDir)) {
+      throw new Error(`Path does not exist: ${resolvedDir}`);
+    }
+    if (this.mounts.has(spec.name)) {
+      await this.removeMount(spec.name);
+    }
     const mount = {
-      name,
+      name: spec.name,
       directory: resolvedDir,
-      sessionId,
-      ownerEmail,
-      access,
+      process: spec.process,
+      sessionId: spec.sessionId,
+      ownerEmail: spec.ownerEmail,
+      access: spec.access ?? "owner",
       addedAt: Date.now()
     };
-    this.mounts.set(name, mount);
+    this.mounts.set(spec.name, mount);
     await this.ensureRunning();
-    if (this.caddy?.isRunning) {
-      await this.caddy.addMount(name, resolvedDir);
+    if (resolvedDir && this.caddy?.isRunning) {
+      await this.caddy.addMount(spec.name, resolvedDir);
     }
-    await this.startMountTunnel(name);
+    await this.startMountTunnel(spec.name);
+    if (spec.process && !spec.process.wakeOnRequest) {
+      try {
+        await this.ensureManagedRunning(spec.name);
+      } catch (err) {
+        this.log(`Mount '${spec.name}': initial process start failed: ${err.message}`);
+      }
+    }
+    this.ensureIdleTimer();
     this.persist();
-    const url = this.getMountUrl(name);
-    this.log(`Mount added: ${name} \u2192 ${resolvedDir} (${url ?? "tunnel pending"})`);
+    const url = this.getMountUrl(spec.name);
+    const what = spec.process ? `${spec.process.command}${spec.process.args?.length ? " " + spec.process.args.join(" ") : ""} (port ${spec.process.port})` : resolvedDir;
+    this.log(`Mount applied: ${spec.name} \u2192 ${what} (${url ?? "tunnel pending"})`);
     return { url: url || "", mount };
   }
   /**
@@ -331,6 +373,8 @@ class ServeManager {
       throw new Error(`Mount '${name}' not found`);
     }
     this.mounts.delete(name);
+    await this.stopManagedProcess(name).catch(() => {
+    });
     const tunnel = this.mountTunnels.get(name);
     if (tunnel) {
       try {
@@ -397,12 +441,16 @@ class ServeManager {
       if (!raw.mounts || raw.mounts.length === 0) return;
       let restoredCount = 0;
       for (const m of raw.mounts) {
-        if (fs.existsSync(m.directory)) {
-          this.mounts.set(m.name, m);
-          restoredCount++;
-        } else {
+        if (m.directory && !fs.existsSync(m.directory)) {
           this.log(`Skipping mount '${m.name}': directory no longer exists (${m.directory})`);
+          continue;
+        }
+        if (!m.directory && !m.process) {
+          this.log(`Skipping mount '${m.name}': neither directory nor process configured`);
+          continue;
         }
+        this.mounts.set(m.name, m);
+        restoredCount++;
       }
       if (restoredCount > 0) {
         this.log(`Restoring ${restoredCount} mount(s)...`);
@@ -413,7 +461,15 @@ class ServeManager {
           } catch (err) {
             this.log(`Failed to start tunnel for restored mount '${m.name}': ${err.message}`);
           }
+          if (m.process && !m.process.wakeOnRequest) {
+            try {
+              await this.ensureManagedRunning(m.name);
+            } catch (err) {
+              this.log(`Restored managed process '${m.name}' failed to start: ${err.message}`);
+            }
+          }
         }
+        this.ensureIdleTimer();
         this.persist();
       }
     } catch (err) {
@@ -421,9 +477,18 @@ class ServeManager {
     }
   }
   /**
-   * Shut down auth proxy + Caddy + all per-mount frpc tunnels.
+   * Shut down auth proxy + Caddy + all per-mount frpc tunnels + all
+   * managed processes.
    */
   async shutdown() {
+    for (const name of Array.from(this.managedProcs.keys())) {
+      await this.stopManagedProcess(name).catch(() => {
+      });
+    }
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
     for (const [name, tunnel] of this.mountTunnels.entries()) {
       try {
         tunnel.destroy();
@@ -444,6 +509,141 @@ class ServeManager {
     }
     this.auth?.destroy();
   }
+  // ── Managed-process lifecycle ─────────────────────────────────────────
+  /**
+   * Ensure the managed process for a mount is running and warm. If a warmup
+   * is already in flight, awaits the same promise (no duplicate spawns).
+   * Throws if warmup probe never returns 200/3xx within warmupTimeoutMs.
+   */
+  async ensureManagedRunning(name) {
+    const mount = this.mounts.get(name);
+    if (!mount?.process) return;
+    const handle = this.managedProcs.get(name);
+    if (handle && handle.warmupPromise) {
+      return handle.warmupPromise;
+    }
+    if (handle && handle.child.exitCode === null && !handle.child.killed) {
+      handle.lastRequestAt = Date.now();
+      return;
+    }
+    const cfg = mount.process;
+    const child = spawn(cfg.command, cfg.args ?? [], {
+      cwd: cfg.workdir ?? process.cwd(),
+      env: { ...process.env, ...cfg.env ?? {} },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    child.stdout?.on("data", (d) => {
+      const line = d.toString().trimEnd();
+      if (line) this.log(`[${name}] ${line}`);
+    });
+    child.stderr?.on("data", (d) => {
+      const line = d.toString().trimEnd();
+      if (line) this.log(`[${name}] ${line}`);
+    });
+    child.on("exit", (code, signal) => {
+      this.log(`Managed process '${name}' exited (code=${code}, signal=${signal})`);
+      const h = this.managedProcs.get(name);
+      if (h && h.child === child) this.managedProcs.delete(name);
+    });
+    const warmupPath = cfg.warmupPath ?? "/";
+    const warmupTimeoutMs = cfg.warmupTimeoutMs ?? 3e4;
+    const warmupPromise = this.warmupProbe(`http://127.0.0.1:${cfg.port}${warmupPath}`, warmupTimeoutMs).then(() => {
+      const h = this.managedProcs.get(name);
+      if (h) {
+        h.warmupPromise = null;
+        h.lastRequestAt = Date.now();
+      }
+      this.log(`Managed process '${name}' ready on 127.0.0.1:${cfg.port}`);
+    }).catch((err) => {
+      this.log(`Managed process '${name}' warmup failed: ${err.message}`);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      this.managedProcs.delete(name);
+      throw err;
+    });
+    const newHandle = {
+      child,
+      pid: child.pid ?? 0,
+      lastRequestAt: Date.now(),
+      warmupPromise
+    };
+    this.managedProcs.set(name, newHandle);
+    this.log(`Managed process '${name}' starting: ${cfg.command} ${(cfg.args ?? []).join(" ")} (port ${cfg.port})`);
+    return warmupPromise;
+  }
+  /** Poll a URL until it returns <500 or the deadline passes. */
+  async warmupProbe(url, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastErr;
+    while (Date.now() < deadline) {
+      try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), 2e3);
+        let resp;
+        try {
+          resp = await fetch(url, {
+            method: "GET",
+            signal: ctrl.signal,
+            redirect: "manual"
+          });
+        } finally {
+          clearTimeout(t);
+        }
+        if (resp.status < 500) return;
+        lastErr = new Error(`status ${resp.status}`);
+      } catch (err) {
+        lastErr = err;
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error(`warmup probe ${url} did not respond within ${timeoutMs}ms (${lastErr?.message || "no response"})`);
+  }
+  /** Stop a managed process (SIGTERM + SIGKILL after 5s). */
+  async stopManagedProcess(name) {
+    const h = this.managedProcs.get(name);
+    if (!h) return;
+    this.managedProcs.delete(name);
+    try {
+      h.child.kill("SIGTERM");
+    } catch {
+    }
+    const child = h.child;
+    await new Promise((resolve) => {
+      const t = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, 5e3);
+      child.once("exit", () => {
+        clearTimeout(t);
+        resolve();
+      });
+    });
+    this.log(`Managed process '${name}' stopped`);
+  }
+  /** Idle eviction loop — stops processes that have been idle longer than configured. */
+  ensureIdleTimer() {
+    if (this.idleTimer) return;
+    this.idleTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [name, mount] of this.mounts) {
+        const cfg = mount.process;
+        if (!cfg || !cfg.idleTimeoutSec || cfg.idleTimeoutSec <= 0) continue;
+        const h = this.managedProcs.get(name);
+        if (!h || h.warmupPromise) continue;
+        if (now - h.lastRequestAt >= cfg.idleTimeoutSec * 1e3) {
+          this.log(`Idle eviction: stopping '${name}' (idle ${Math.round((now - h.lastRequestAt) / 1e3)}s \u2265 ${cfg.idleTimeoutSec}s)`);
+          this.stopManagedProcess(name).catch(() => {
+          });
+        }
+      }
+    }, 3e4);
+  }
   // ── Internal ─────────────────────────────────────────────────────────
   /** Get the public URL for a mount (mount-specific subdomain). */
   getMountUrl(name) {
@@ -485,7 +685,9 @@ class ServeManager {
       log: (msg) => this.log(`[Caddy] ${msg}`)
     });
     for (const mount of this.mounts.values()) {
-      await this.caddy.addMount(mount.name, mount.directory);
+      if (mount.directory) {
+        await this.caddy.addMount(mount.name, mount.directory);
+      }
     }
     await this.caddy.start();
     this.log(`Caddy file server started on 127.0.0.1:${this.caddyPort}`);
@@ -548,7 +750,7 @@ class ServeManager {
             return;
           }
         }
-        if (req.method === "PUT" && mount) {
+        if (req.method === "PUT" && mount && mount.directory) {
           const filePath = path.join(mount.directory, basePath);
           fs.mkdirSync(path.dirname(filePath), { recursive: true });
           const ws = fs.createWriteStream(filePath);
@@ -563,7 +765,7 @@ class ServeManager {
           });
           return;
         }
-        if (req.method === "DELETE" && mount) {
+        if (req.method === "DELETE" && mount && mount.directory) {
           const filePath = path.join(mount.directory, basePath);
           try {
             fs.unlinkSync(filePath);
@@ -575,6 +777,39 @@ class ServeManager {
           }
           return;
         }
+        if (mount && mount.process) {
+          const cfg = mount.process;
+          if (cfg.wakeOnRequest || !this.managedProcs.has(mount.name)) {
+            try {
+              await this.ensureManagedRunning(mount.name);
+            } catch (err) {
+              res.writeHead(503, { "Content-Type": "text/plain" });
+              res.end(`Backend not ready: ${err?.message || err}`);
+              return;
+            }
+          }
+          const handle = this.managedProcs.get(mount.name);
+          if (handle) handle.lastRequestAt = Date.now();
+          const targetPath = mountResolvedByHost ? req.url || "/" : (basePath || "/") + (url.search || "");
+          const proxyReq2 = http.request({
+            hostname: "127.0.0.1",
+            port: cfg.port,
+            path: targetPath,
+            method: req.method,
+            headers: req.headers
+          }, (proxyRes) => {
+            res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+            proxyRes.pipe(res);
+          });
+          proxyReq2.on("error", (err) => {
+            if (!res.headersSent) {
+              res.writeHead(502);
+              res.end(`Backend error: ${err.message}`);
+            }
+          });
+          req.pipe(proxyReq2);
+          return;
+        }
         let proxyPath = req.url || "/";
         if (mountResolvedByHost && mountName) {
           const search = url.search || "";

package/package.json

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