svamp-cli 0.2.255 → 0.2.257

package/dist/{run-DsAMQZUu.mjs → run-BtGnnEMI.mjs}

@@ -2985,7 +2985,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-C6yDezIg.mjs');
+        const { FrpcTunnel } = await import('./frpc-QESvQN-s.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3452,7 +3452,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
           }
           const deps = buildSessionDeps(rpc, { cwd, ownerEmail: owner });
           const sender = { name: context?.user?.email || context?.user?.id || "user", kind: "user", verified: true };
-          const { toolsForRole } = await import('./sideband-CQJ-0LbS.mjs');
+          const { toolsForRole } = await import('./sideband-C_ifGgde.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3551,7 +3551,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
     const callId = "call_" + Math.random().toString(16).slice(2, 12);
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-E4FV1Mrf.mjs');
+    const { queryCore } = await import('./commands-CE1PdEJJ.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -10239,21 +10239,37 @@ class ProcessSupervisor {
    *   a desired-stopped intent so a daemon restart does not resurrect it. `stopAll` (a daemon
    *   shutdown, not a user action) passes false so keepAlive processes auto-restore (#nightly).
    */
+  /**
+   * #0347: run `fn` in the entry's lifecycle critical section. Each call awaits the previous
+   * lifecycle op's SETTLEMENT before running, so stop/restart/apply/update/remove are strictly
+   * serialized per entry and can never interleave across an `await killChild` (which is what let
+   * two ops double-spawn an orphan, or resurrect a just-stopped process). The chain tail never
+   * rejects (a failed op must not wedge the queue); the caller still gets the real result/error.
+   */
+  runExclusive(entry, fn) {
+    const prev = entry.opLock ?? Promise.resolve();
+    const result = prev.then(fn, fn);
+    entry.opLock = result.then(() => void 0, () => void 0);
+    return result;
+  }
   async stop(idOrName, opts) {
     const entry = this.require(idOrName);
     entry.stopping = true;
     this.clearTimers(entry);
-    if (entry.child) {
-      await this.killChild(entry.child);
-      entry.child = void 0;
-    }
-    entry.state.status = "stopped";
-    entry.state.stoppedAt = Date.now();
-    entry.state.pid = void 0;
-    if (opts?.markDesiredStopped !== false && !entry.deleted && !entry.spec.desiredStopped) {
-      entry.spec.desiredStopped = true;
-      await this.persistSpec(entry.spec);
-    }
+    return this.runExclusive(entry, async () => {
+      entry.stopping = true;
+      if (entry.child) {
+        await this.killChild(entry.child);
+        entry.child = void 0;
+      }
+      entry.state.status = "stopped";
+      entry.state.stoppedAt = Date.now();
+      entry.state.pid = void 0;
+      if (opts?.markDesiredStopped !== false && !entry.deleted && !entry.spec.desiredStopped) {
+        entry.spec.desiredStopped = true;
+        await this.persistSpec(entry.spec);
+      }
+    });
   }
   /** Restart a process (stop if running, then start again). */
   async restart(idOrName) {
@@ -10261,25 +10277,27 @@ class ProcessSupervisor {
     if (entry.deleted) throw new Error(`Process '${idOrName}' has been removed`);
     if (entry.restarting) return;
     entry.restarting = true;
-    try {
-      if (entry.child) {
-        entry.stopping = true;
-        this.clearTimers(entry);
-        await this.killChild(entry.child);
-        entry.child = void 0;
-      }
-      if (entry.deleted) return;
-      entry.stopping = false;
-      this.resetFailureTracking(entry);
-      if (entry.spec.desiredStopped) {
-        entry.spec.desiredStopped = false;
-        await this.persistSpec(entry.spec);
+    return this.runExclusive(entry, async () => {
+      try {
+        if (entry.child) {
+          entry.stopping = true;
+          this.clearTimers(entry);
+          await this.killChild(entry.child);
+          entry.child = void 0;
+        }
+        if (entry.deleted) return;
+        entry.stopping = false;
+        this.resetFailureTracking(entry);
+        if (entry.spec.desiredStopped) {
+          entry.spec.desiredStopped = false;
+          await this.persistSpec(entry.spec);
+        }
+        entry.state.restartCount++;
+        await this.startEntry(entry, false);
+      } finally {
+        entry.restarting = false;
       }
-      entry.state.restartCount++;
-      await this.startEntry(entry, false);
-    } finally {
-      entry.restarting = false;
-    }
+    });
   }
   /** Stop the process and remove it from supervision (deletes persisted spec). */
   async remove(idOrName) {
@@ -10288,15 +10306,17 @@ class ProcessSupervisor {
     entry.deleted = true;
     entry.stopping = true;
     this.clearTimers(entry);
-    if (entry.child) {
-      await this.killChild(entry.child);
-      entry.child = void 0;
-    }
-    entry.state.status = "stopped";
-    entry.state.stoppedAt = Date.now();
-    entry.state.pid = void 0;
-    this.entries.delete(id);
-    await this.deleteSpec(id);
+    return this.runExclusive(entry, async () => {
+      if (entry.child) {
+        await this.killChild(entry.child);
+        entry.child = void 0;
+      }
+      entry.state.status = "stopped";
+      entry.state.stoppedAt = Date.now();
+      entry.state.pid = void 0;
+      this.entries.delete(id);
+      await this.deleteSpec(id);
+    });
   }
   /** List all supervised processes. */
   list() {
@@ -10330,26 +10350,28 @@ class ProcessSupervisor {
     if (this.specsEqual(existing.spec, spec)) {
       return { action: "no-change", info: this.toInfo(existing) };
     }
-    const updatedSpec = {
-      ...spec,
-      id: existing.spec.id,
-      createdAt: existing.spec.createdAt
-      // preserve original creation time
-    };
-    existing.spec = updatedSpec;
-    await this.persistSpec(updatedSpec);
-    existing.stopping = true;
-    this.clearTimers(existing);
-    if (existing.child) {
-      await this.killChild(existing.child);
-      existing.child = void 0;
-    }
-    if (existing.deleted) return { action: "updated", info: this.toInfo(existing) };
-    existing.stopping = false;
-    this.resetFailureTracking(existing);
-    existing.state.status = "starting";
-    this.spawnProcess(existing);
-    return { action: "updated", info: this.toInfo(existing) };
+    return this.runExclusive(existing, async () => {
+      const updatedSpec = {
+        ...spec,
+        id: existing.spec.id,
+        createdAt: existing.spec.createdAt
+        // preserve original creation time
+      };
+      existing.spec = updatedSpec;
+      await this.persistSpec(updatedSpec);
+      existing.stopping = true;
+      this.clearTimers(existing);
+      if (existing.child) {
+        await this.killChild(existing.child);
+        existing.child = void 0;
+      }
+      if (existing.deleted) return { action: "updated", info: this.toInfo(existing) };
+      existing.stopping = false;
+      this.resetFailureTracking(existing);
+      existing.state.status = "starting";
+      this.spawnProcess(existing);
+      return { action: "updated", info: this.toInfo(existing) };
+    });
   }
   /**
    * Update a running process's spec and restart it.
@@ -10358,21 +10380,23 @@ class ProcessSupervisor {
   async update(idOrName, partialSpec) {
     const entry = this.require(idOrName);
     if (entry.deleted) throw new Error(`Process '${idOrName}' has been removed`);
-    const updatedSpec = { ...entry.spec, ...partialSpec };
-    entry.spec = updatedSpec;
-    await this.persistSpec(updatedSpec);
-    entry.stopping = true;
-    this.clearTimers(entry);
-    if (entry.child) {
-      await this.killChild(entry.child);
-      entry.child = void 0;
-    }
-    if (entry.deleted) return this.toInfo(entry);
-    entry.stopping = false;
-    this.resetFailureTracking(entry);
-    entry.state.status = "starting";
-    this.spawnProcess(entry);
-    return this.toInfo(entry);
+    return this.runExclusive(entry, async () => {
+      const updatedSpec = { ...entry.spec, ...partialSpec };
+      entry.spec = updatedSpec;
+      await this.persistSpec(updatedSpec);
+      entry.stopping = true;
+      this.clearTimers(entry);
+      if (entry.child) {
+        await this.killChild(entry.child);
+        entry.child = void 0;
+      }
+      if (entry.deleted) return this.toInfo(entry);
+      entry.stopping = false;
+      this.resetFailureTracking(entry);
+      entry.state.status = "starting";
+      this.spawnProcess(entry);
+      return this.toInfo(entry);
+    });
   }
   // ── Spec equality ─────────────────────────────────────────────────────────
   /** Compare two specs for equality (ignoring id, createdAt, and runtime state). */
@@ -13534,7 +13558,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-Bd7sTL72.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-fCsOp7ko.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -13552,7 +13576,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-C6yDezIg.mjs');
+    const { FrpcTunnel } = await import('./frpc-QESvQN-s.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -13572,7 +13596,8 @@ async function startDaemon(options) {
     return tunnel;
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-C1-FPoEa.mjs');
+  const tunnelRecreateInFlight = /* @__PURE__ */ new Set();
+  const { ServeManager } = await import('./serveManager-BclzoPIb.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -15688,11 +15713,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D_d_zq8R.mjs');
+              const { issueRpc } = await import('./rpc-Bscxex4z.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BAhRday-.mjs');
+              const { workflowRpc } = await import('./rpc-DCeDG4c7.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16241,11 +16266,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D_d_zq8R.mjs');
+              const { issueRpc } = await import('./rpc-Bscxex4z.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BAhRday-.mjs');
+              const { workflowRpc } = await import('./rpc-DCeDG4c7.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16905,7 +16930,8 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
             return void 0;
           }
         });
-        channelHttpServer.listen(channelHttpPort, () => logger.log(`[channels] HTTP ingress on :${channelHttpPort} (POST /channel/<id>)`));
+        const channelHttpHost = process.env.SVAMP_CHANNEL_HTTP_HOST || "127.0.0.1";
+        channelHttpServer.listen(channelHttpPort, channelHttpHost, () => logger.log(`[channels] HTTP ingress on ${channelHttpHost}:${channelHttpPort} (POST /channel/<id>)`));
       } catch (e) {
         logger.error(`[channels] HTTP ingress failed to start: ${e.message}`);
       }
@@ -17209,7 +17235,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-BwZS9UWD.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-Dbqmnd_o.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();
@@ -17384,13 +17410,40 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
           } catch {
           }
           tunnels.delete(name);
+          tunnelRecreateInFlight.add(name);
           createExposedTunnel(spec).then((fresh) => {
             tunnels.set(name, fresh);
             logger.log(`frpc tunnel '${name}' recreated`);
           }).catch((err) => {
             logger.log(`frpc tunnel '${name}' recreate failed: ${err.message} (will retry)`);
+          }).finally(() => {
+            tunnelRecreateInFlight.delete(name);
           });
         }
+        try {
+          for (const spec of loadExposedTunnels()) {
+            if (tunnels.has(spec.name)) continue;
+            if (tunnelRecreateInFlight.has(spec.name)) continue;
+            const now = Date.now();
+            const st = tunnelRecreateState.get(spec.name) ?? { nextAttemptAt: 0, attempts: 0 };
+            if (now < st.nextAttemptAt) continue;
+            st.attempts++;
+            st.nextAttemptAt = now + Math.min(15e3 * Math.pow(2, st.attempts - 1), 5 * 6e4);
+            tunnelRecreateState.set(spec.name, st);
+            logger.log(`frpc tunnel '${spec.name}' missing from live set \u2014 rebuilding (attempt ${st.attempts})`);
+            tunnelRecreateInFlight.add(spec.name);
+            createExposedTunnel(spec).then((fresh) => {
+              tunnels.set(spec.name, fresh);
+              logger.log(`frpc tunnel '${spec.name}' rebuilt`);
+            }).catch((err) => {
+              logger.log(`frpc tunnel '${spec.name}' rebuild failed: ${err.message} (will retry)`);
+            }).finally(() => {
+              tunnelRecreateInFlight.delete(spec.name);
+            });
+          }
+        } catch (e) {
+          logger.log(`frpc tunnel reconcile pass error: ${e.message}`);
+        }
       } finally {
         heartbeatRunning = false;
       }

package/dist/{scheduler-BwZS9UWD.mjs → scheduler-Dbqmnd_o.mjs}

@@ -1,4 +1,4 @@
-import { n as resolveProjectRoot, H as listWorkflows, I as isWorkflowEnabled, J as workflowCrons, C as runWorkflow, K as cronMatches } from './run-DsAMQZUu.mjs';
+import { n as resolveProjectRoot, H as listWorkflows, I as isWorkflowEnabled, J as workflowCrons, C as runWorkflow, K as cronMatches } from './run-BtGnnEMI.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -42,6 +42,11 @@ class WorkflowScheduler {
   lastTickMs = null;
   // In-flight runs (fire-and-forget). `idle()` awaits them — used by tests; harmless in prod.
   pending = /* @__PURE__ */ new Set();
+  // #0329: per-workflow (root\0name) in-flight guard. A scheduled workflow whose steps outlast its
+  // cron period (a `session loop`, a test suite, a deploy) would otherwise be fired AGAIN on the next
+  // matching minute while the prior run is still executing — two concurrent runs of a destructive step
+  // can race. We skip a fire while the same workflow is already running.
+  running = /* @__PURE__ */ new Set();
   // Default cap on how many skipped minutes we look back over on a single tick. Deliberately small: it
   // rescues genuine short gaps (a >60s event-loop stall, a brief suspend) without resurrecting daily
   // crons hours late after a long sleep — multi-hour catch-up needs persisted last-fire state, out of
@@ -105,9 +110,19 @@ class WorkflowScheduler {
     }
     return fired;
   }
+  /** True if a scheduled run of this workflow is already executing (test/introspection helper). */
+  isRunning(root, name) {
+    return this.running.has(`${root}\0${name}`);
+  }
   fire(root, wf) {
     const owner = wf.session || null;
+    const key = `${root}\0${wf.name}`;
+    if (this.running.has(key)) {
+      this.deps.log?.(`[workflow] schedule skipped "${wf.name}" in ${root} \u2014 previous run still in progress`);
+      return;
+    }
     this.deps.log?.(`[workflow] schedule fired "${wf.name}" in ${root}${owner ? ` as ${owner}` : ""}`);
+    this.running.add(key);
     const p = runWorkflow(root, wf, {
       trigger: "schedule",
       actor: owner,
@@ -119,7 +134,10 @@ class WorkflowScheduler {
       return void 0;
     });
     this.pending.add(p);
-    p.finally(() => this.pending.delete(p));
+    p.finally(() => {
+      this.pending.delete(p);
+      this.running.delete(key);
+    });
   }
 }
 

package/dist/{serveCommands-sEZ7mQc4.mjs → serveCommands-DueTsJSe.mjs}

@@ -54,7 +54,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-E4FV1Mrf.mjs');
+  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -93,7 +93,7 @@ async function serveAdd(args, machineId) {
   }
 }
 async function serveApply(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-E4FV1Mrf.mjs');
+  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
   const fs = await import('fs');
   const yaml = await import('yaml');
   const file = positionalArgs(args)[0];
@@ -182,7 +182,7 @@ async function serveApply(args, machineId) {
   }
 }
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-E4FV1Mrf.mjs');
+  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -202,7 +202,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-E4FV1Mrf.mjs');
+  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -235,7 +235,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-E4FV1Mrf.mjs');
+  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();

package/dist/{serveManager-C1-FPoEa.mjs → serveManager-BclzoPIb.mjs}

@@ -4,7 +4,7 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as net from 'net';
 import * as path from 'path';
-import { l as getHyphaServerUrl, S as ServeAuth, m as hasCookieToken } from './run-DsAMQZUu.mjs';
+import { l as getHyphaServerUrl, S as ServeAuth, m as hasCookieToken } from './run-BtGnnEMI.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';
@@ -751,7 +751,7 @@ class ServeManager {
     const mount = this.mounts.get(mountName);
     const subdomainOverride = mount?.access === "link" && mount.linkToken ? /* @__PURE__ */ new Map([[this.port, buildLinkSubdomain(subdomainSafe, mount.linkToken)]]) : void 0;
     try {
-      const { FrpcTunnel } = await import('./frpc-C6yDezIg.mjs');
+      const { FrpcTunnel } = await import('./frpc-QESvQN-s.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,

package/dist/{sideband-CQJ-0LbS.mjs → sideband-C_ifGgde.mjs}

@@ -1,4 +1,4 @@
-import { R as READ_ONLY_TOOLS, N as loadMachineContext, O as buildMachineInstructions, P as machineToolsForRole, Q as buildMachineTools } from './run-DsAMQZUu.mjs';
+import { R as READ_ONLY_TOOLS, N as loadMachineContext, O as buildMachineInstructions, P as machineToolsForRole, Q as buildMachineTools } from './run-BtGnnEMI.mjs';
 import 'node:child_process';
 import 'os';
 import 'fs/promises';

package/package.json

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