svamp-cli 0.2.7 → 0.2.9

package/dist/{run-1sh7lcBI.mjs → run-IDo93bqK.mjs}

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'url';
 import { spawn as spawn$1 } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
 import { existsSync, readFileSync, writeFileSync as writeFileSync$1, mkdirSync as mkdirSync$1, appendFileSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
+import { randomUUID, createHash } from 'node:crypto';
 import { join as join$1 } from 'node:path';
 import { spawn, execSync, execFile } from 'node:child_process';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
@@ -718,6 +718,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         if (newSharing.enabled && !newSharing.owner && context?.user?.email) {
           newSharing = { ...newSharing, owner: context.user.email };
         }
+        const oldSharing = currentMetadata.sharing;
         currentMetadata = { ...currentMetadata, sharing: newSharing };
         metadataVersion++;
         savePersistedMachineMetadata(metadata.svampHomeDir, {
@@ -730,6 +731,20 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           machineId,
           metadata: { value: currentMetadata, version: metadataVersion }
         });
+        handlers.sharingNotificationSync?.syncSharing(
+          `machine-${machineId}`,
+          oldSharing,
+          newSharing,
+          {
+            machineId,
+            machineServiceId: `${server.config.workspace}/${server.config.client_id}:default`,
+            ownerWorkspace: server.config.workspace,
+            ownerEmail: newSharing.owner || "",
+            label: currentMetadata.displayName || machineId,
+            shareType: "machine"
+          }
+        ).catch(() => {
+        });
         return { success: true, sharing: newSharing };
       },
       // Get security context config
@@ -1110,6 +1125,41 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           ...client.status
         }));
       },
+      // ── Shared static file server ────────────────────────────────────
+      /** Add a mount to the shared static file server. */
+      serveAdd: 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.addMount(params.name, params.directory, params.sessionId, access, ownerEmail);
+      },
+      /** Remove a mount from the shared static file server. */
+      serveRemove: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "interact");
+        const sm = handlers.serveManager;
+        if (!sm) throw new Error("Serve manager not available");
+        await sm.removeMount(params.name);
+        return { removed: true };
+      },
+      /** List mounts. Optionally filter by sessionId or return all. */
+      serveList: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        const sm = handlers.serveManager;
+        if (!sm) throw new Error("Serve manager not available");
+        if (params.all) {
+          return sm.listMounts();
+        }
+        return sm.listMounts(params.sessionId);
+      },
+      /** Get shared static file server info. */
+      serveInfo: async (context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        const sm = handlers.serveManager;
+        if (!sm) throw new Error("Serve manager not available");
+        return sm.getInfo();
+      },
       // WISE voice — create ephemeral token for OpenAI Realtime API
       wiseCreateEphemeralToken: async (params, context) => {
         authorizeRequest(context, currentMetadata.sharing, "interact");
@@ -1978,7 +2028,7 @@ async function registerDebugService(server, machineId, deps) {
   };
 }
 
-const COLLECTION_ALIAS = "svamp-agent-sessions";
+const COLLECTION_ALIAS$1 = "svamp-agent-sessions";
 class SessionArtifactSync {
   server;
   artifactManager = null;
@@ -2013,14 +2063,14 @@ class SessionArtifactSync {
   async ensureCollection() {
     try {
       const existing = await this.artifactManager.read({
-        artifact_id: COLLECTION_ALIAS,
+        artifact_id: COLLECTION_ALIAS$1,
         _rkwargs: true
       });
       this.collectionId = existing.id;
       this.log(`[ARTIFACT SYNC] Found existing collection: ${this.collectionId}`);
     } catch {
       const collection = await this.artifactManager.create({
-        alias: COLLECTION_ALIAS,
+        alias: COLLECTION_ALIAS$1,
         type: "collection",
         manifest: {
           name: "Svamp Agent Sessions",
@@ -2299,6 +2349,170 @@ class SessionArtifactSync {
   }
 }
 
+const COLLECTION_ALIAS = "svamp-shared-sessions";
+function emailHash(email) {
+  return createHash("sha256").update(email.toLowerCase()).digest("hex").slice(0, 12);
+}
+function notificationAlias(sessionId, recipientEmail) {
+  return `share-${sessionId.slice(0, 8)}-${emailHash(recipientEmail)}`;
+}
+class SharingNotificationSync {
+  server;
+  artifactManager = null;
+  collectionId = null;
+  initialized = false;
+  log;
+  constructor(server, log) {
+    this.server = server;
+    this.log = log;
+  }
+  async init() {
+    try {
+      this.artifactManager = await this.server.getService("public/artifact-manager");
+      if (!this.artifactManager) {
+        this.log("[SHARING NOTIFY] Artifact manager not available");
+        return;
+      }
+      await this.ensureCollection();
+      this.initialized = true;
+      this.log("[SHARING NOTIFY] Initialized");
+    } catch (err) {
+      this.log(`[SHARING NOTIFY] Init failed: ${err.message}`);
+    }
+  }
+  async ensureCollection() {
+    try {
+      const existing = await this.artifactManager.read({
+        artifact_id: COLLECTION_ALIAS,
+        _rkwargs: true
+      });
+      this.collectionId = existing.id;
+    } catch {
+      const collection = await this.artifactManager.create({
+        alias: COLLECTION_ALIAS,
+        type: "collection",
+        manifest: {
+          name: "Svamp Shared Sessions",
+          description: "Cross-workspace share notifications for session/machine bookmarks"
+        },
+        config: {
+          permissions: { "*": "r", "@": "rw+" }
+        },
+        _rkwargs: true
+      });
+      this.collectionId = collection.id;
+      await this.artifactManager.commit({
+        artifact_id: this.collectionId,
+        _rkwargs: true
+      });
+      this.log(`[SHARING NOTIFY] Created collection: ${this.collectionId}`);
+    }
+  }
+  /**
+   * Publish a share notification for a recipient.
+   * Idempotent — uses deterministic alias, so re-sharing updates the existing artifact.
+   */
+  async notifyShare(params) {
+    if (!this.initialized || !this.collectionId) return;
+    const alias = notificationAlias(params.sessionId, params.recipientEmail);
+    const manifest = {
+      recipientEmail: params.recipientEmail.toLowerCase(),
+      sessionId: params.sessionId,
+      machineId: params.machineId,
+      machineServiceId: params.machineServiceId,
+      ownerWorkspace: params.ownerWorkspace,
+      ownerEmail: params.ownerEmail,
+      label: params.label || "",
+      role: params.role,
+      sharedAt: Date.now(),
+      shareType: params.shareType || "session"
+    };
+    try {
+      const existing = await this.artifactManager.read({
+        artifact_id: alias,
+        parent_id: this.collectionId,
+        _rkwargs: true
+      });
+      await this.artifactManager.edit({
+        artifact_id: existing.id,
+        manifest,
+        _rkwargs: true
+      });
+      await this.artifactManager.commit({
+        artifact_id: existing.id,
+        _rkwargs: true
+      });
+    } catch {
+      try {
+        const artifact = await this.artifactManager.create({
+          alias,
+          parent_id: this.collectionId,
+          type: "share-notification",
+          manifest,
+          _rkwargs: true
+        });
+        await this.artifactManager.commit({
+          artifact_id: artifact.id,
+          _rkwargs: true
+        });
+      } catch (createErr) {
+        this.log(`[SHARING NOTIFY] Failed to create notification for ${params.recipientEmail}: ${createErr.message}`);
+        return;
+      }
+    }
+    this.log(`[SHARING NOTIFY] Notified ${params.recipientEmail} about ${params.shareType || "session"} ${params.sessionId.slice(0, 8)}`);
+  }
+  /**
+   * Remove a share notification when a user is unshared.
+   */
+  async removeNotification(sessionId, recipientEmail) {
+    if (!this.initialized || !this.collectionId) return;
+    const alias = notificationAlias(sessionId, recipientEmail);
+    try {
+      const existing = await this.artifactManager.read({
+        artifact_id: alias,
+        parent_id: this.collectionId,
+        _rkwargs: true
+      });
+      await this.artifactManager.delete({
+        artifact_id: existing.id,
+        _rkwargs: true
+      });
+      this.log(`[SHARING NOTIFY] Removed notification for ${recipientEmail} on ${sessionId.slice(0, 8)}`);
+    } catch {
+    }
+  }
+  /**
+   * Sync all sharing notifications for a session based on its current sharing config.
+   * Adds notifications for new users, removes for removed users.
+   */
+  async syncSharing(sessionId, oldSharing, newSharing, context) {
+    if (!this.initialized) return;
+    const oldEmails = new Set(
+      (oldSharing?.allowedUsers || []).map((u) => u.email.toLowerCase())
+    );
+    const newUsers = newSharing.allowedUsers || [];
+    const newEmails = new Set(newUsers.map((u) => u.email.toLowerCase()));
+    for (const user of newUsers) {
+      if (!oldEmails.has(user.email.toLowerCase())) {
+        this.notifyShare({
+          recipientEmail: user.email,
+          sessionId,
+          role: user.role,
+          ...context
+        }).catch(() => {
+        });
+      }
+    }
+    for (const email of oldEmails) {
+      if (!newEmails.has(email)) {
+        this.removeNotification(sessionId, email).catch(() => {
+        });
+      }
+    }
+  }
+}
+
 const DEFAULT_TIMEOUTS = {
   init: 6e4,
   toolCall: 12e4,
@@ -5933,6 +6147,8 @@ 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-BPyT20Q8.mjs');
+  const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
   preventMachineSleep(logger);
@@ -6131,6 +6347,7 @@ async function startDaemon(options) {
         const persisted = allPersisted.find((p) => p.sessionId === sessionId) || (resumeSessionId ? allPersisted.find((p) => p.claudeResumeId === resumeSessionId) : void 0);
         let claudeResumeId = persisted?.claudeResumeId || (resumeSessionId || void 0);
         let currentPermissionMode = options2.permissionMode || persisted?.permissionMode || "default";
+        const sessionCreatedAt = persisted?.createdAt || Date.now();
         let lastSpawnMeta = persisted?.spawnMeta || {};
         let sessionWasProcessing = !!options2.wasProcessing;
         let lastAssistantText = "";
@@ -6437,7 +6654,7 @@ async function startDaemon(options) {
                           permissionMode: currentPermissionMode,
                           spawnMeta: lastSpawnMeta,
                           metadata: sessionMetadata,
-                          createdAt: Date.now(),
+                          createdAt: sessionCreatedAt,
                           machineId,
                           wasProcessing: false
                         });
@@ -6468,7 +6685,7 @@ async function startDaemon(options) {
                         permissionMode: currentPermissionMode,
                         spawnMeta: lastSpawnMeta,
                         metadata: sessionMetadata,
-                        createdAt: Date.now(),
+                        createdAt: sessionCreatedAt,
                         machineId,
                         wasProcessing: false
                       });
@@ -6697,7 +6914,7 @@ The automated loop has finished. Review the progress above and let me know if yo
                         permissionMode: currentPermissionMode,
                         spawnMeta: lastSpawnMeta,
                         metadata: sessionMetadata,
-                        createdAt: Date.now(),
+                        createdAt: sessionCreatedAt,
                         machineId,
                         wasProcessing: sessionWasProcessing
                       });
@@ -6806,7 +7023,7 @@ The automated loop has finished. Review the progress above and let me know if yo
                 permissionMode: currentPermissionMode,
                 spawnMeta: lastSpawnMeta,
                 metadata: sessionMetadata,
-                createdAt: Date.now(),
+                createdAt: sessionCreatedAt,
                 machineId,
                 wasProcessing: false
               });
@@ -7028,7 +7245,7 @@ The automated loop has finished. Review the progress above and let me know if yo
                     permissionMode: currentPermissionMode,
                     spawnMeta: lastSpawnMeta,
                     metadata: sessionMetadata,
-                    createdAt: Date.now(),
+                    createdAt: sessionCreatedAt,
                     machineId,
                     wasProcessing: sessionWasProcessing
                   });
@@ -7090,6 +7307,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onSharingUpdate: (newSharing) => {
               logger.log(`[Session ${sessionId}] Sharing config updated \u2014 persisting to disk`);
+              const oldSharing = sessionMetadata.sharing;
               sessionMetadata = { ...sessionMetadata, sharing: newSharing };
               if (!trackedSession.stopped) {
                 saveSession({
@@ -7099,11 +7317,22 @@ The automated loop has finished. Review the progress above and let me know if yo
                   permissionMode: currentPermissionMode,
                   spawnMeta: lastSpawnMeta,
                   metadata: sessionMetadata,
-                  createdAt: Date.now(),
+                  createdAt: sessionCreatedAt,
                   machineId,
                   wasProcessing: sessionWasProcessing
                 });
               }
+              const ownerWorkspace = server.config.workspace;
+              const machineServiceId = `${ownerWorkspace}/${server.config.client_id}:default`;
+              sharingNotificationSync.syncSharing(sessionId, oldSharing, newSharing, {
+                machineId,
+                machineServiceId,
+                ownerWorkspace,
+                ownerEmail: newSharing.owner || "",
+                label: sessionMetadata.summary?.text || "",
+                shareType: "session"
+              }).catch(() => {
+              });
             },
             onApplySystemPrompt: async (prompt) => {
               logger.log(`[Session ${sessionId}] System prompt update requested \u2014 restarting agent`);
@@ -8027,6 +8256,9 @@ The automated loop has finished. Review the progress above and let me know if yo
       pid: process.pid,
       startedAt: Date.now()
     };
+    const sharingNotificationSync = new SharingNotificationSync(server, logger.log);
+    sharingNotificationSync.init().catch(() => {
+    });
     const machineService = await registerMachineService(
       server,
       machineId,
@@ -8042,7 +8274,7 @@ The automated loop has finished. Review the progress above and let me know if yo
         getTrackedSessions: getCurrentChildren,
         getSessionRPCHandlers: (sessionId) => {
           for (const [, session] of pidToTrackedSession) {
-            if (session.svampSessionId === sessionId && session.sessionRPCHandlers) {
+            if (session.svampSessionId === sessionId && !session.stopped && session.sessionRPCHandlers) {
               return session.sessionRPCHandlers;
             }
           }
@@ -8058,7 +8290,9 @@ The automated loop has finished. Review the progress above and let me know if yo
           return ids;
         },
         supervisor,
-        tunnels
+        tunnels,
+        serveManager,
+        sharingNotificationSync
       }
     );
     logger.log(`Machine service registered: svamp-machine-${machineId}`);
@@ -8080,6 +8314,7 @@ The automated loop has finished. Review the progress above and let me know if yo
       // Legacy; debug service uses session index now
     });
     logger.log(`Debug service registered: svamp-debug-${machineId}`);
+    await serveManager.restore();
     const persistedSessions = loadPersistedSessions();
     const sessionsToAutoContinue = [];
     const sessionsToRalphResume = [];
@@ -8420,6 +8655,8 @@ The automated loop has finished. Review the progress above and let me know if yo
       }
       await supervisor.stopAll().catch(() => {
       });
+      await serveManager.shutdown().catch(() => {
+      });
       for (const [name, client] of tunnels) {
         client.destroy();
         logger.log(`Tunnel '${name}' destroyed`);

package/dist/{run-CKmnXg7d.mjs → run-wHgMyNHQ.mjs}

@@ -2,7 +2,7 @@ import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(im
 import os from 'node:os';
 import { join, resolve } from 'node:path';
 import { mkdirSync, writeFileSync, existsSync, unlinkSync, readFileSync, watch } from 'node:fs';
-import { c as connectToHypha, a as registerSessionService } from './run-1sh7lcBI.mjs';
+import { c as connectToHypha, a as registerSessionService } from './run-IDo93bqK.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';

package/dist/serveCommands-BguUrQAM.mjs

@@ -0,0 +1,191 @@
+import * as path from 'path';
+
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+function hasFlag(args, ...flags) {
+  return flags.some((f) => args.includes(f));
+}
+function positionalArgs(args) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("-")) {
+      if (!args[i].startsWith("--no-") && i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        i++;
+      }
+      continue;
+    }
+    result.push(args[i]);
+  }
+  return result;
+}
+async function handleServeCommand() {
+  const args = process.argv.slice(3);
+  const sub = args[0];
+  let machineId;
+  const mIdx = args.findIndex((a) => a === "--machine" || a === "-m");
+  if (mIdx !== -1 && mIdx + 1 < args.length) {
+    machineId = args[mIdx + 1];
+  }
+  const filteredArgs = args.filter((_a, i) => {
+    if (args[i] === "--machine" || args[i] === "-m") return false;
+    if (i > 0 && (args[i - 1] === "--machine" || args[i - 1] === "-m")) return false;
+    return true;
+  });
+  if (sub === "--help" || sub === "-h") {
+    printServeHelp();
+    return;
+  }
+  if (sub === "remove" || sub === "rm") {
+    await serveRemove(filteredArgs.slice(1), machineId);
+  } else if (sub === "list" || sub === "ls") {
+    await serveList(filteredArgs.slice(1), machineId);
+  } else if (sub === "info") {
+    await serveInfo(machineId);
+  } else if (sub === "add") {
+    await serveAdd(filteredArgs.slice(1), machineId);
+  } else if (sub && !sub.startsWith("-")) {
+    await serveAdd(filteredArgs, machineId);
+  } else {
+    printServeHelp();
+  }
+}
+async function serveAdd(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-h1lFrJKK.mjs');
+  const pos = positionalArgs(args);
+  const name = pos[0];
+  if (!name) {
+    console.error("Usage: svamp serve [add] <name> [directory] [--public | --access email1,email2]");
+    process.exit(1);
+  }
+  const directory = path.resolve(pos[1] || ".");
+  let access = "owner";
+  if (hasFlag(args, "--public")) {
+    access = "public";
+  } else {
+    const accessFlag = getFlag(args, "--access");
+    if (accessFlag) {
+      access = accessFlag.split(",").map((e) => e.trim()).filter(Boolean);
+    }
+  }
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const result = await machine.serveAdd({ name, directory, access, _rkwargs: true });
+    console.log(`Mount added: ${name} \u2192 ${directory}`);
+    console.log(`Access: ${access === "public" ? "public" : access === "owner" ? "owner only" : access.join(", ")}`);
+    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-h1lFrJKK.mjs');
+  const pos = positionalArgs(args);
+  const name = pos[0];
+  if (!name) {
+    console.error("Usage: svamp serve remove <name>");
+    process.exit(1);
+  }
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    await machine.serveRemove({ name, _rkwargs: true });
+    console.log(`Mount '${name}' removed.`);
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+async function serveList(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-h1lFrJKK.mjs');
+  const all = hasFlag(args, "--all", "-a");
+  const json = hasFlag(args, "--json");
+  const sessionId = getFlag(args, "--session");
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const mounts = await machine.serveList({ sessionId, all, _rkwargs: true });
+    if (json) {
+      console.log(JSON.stringify(mounts, null, 2));
+    } else if (mounts.length === 0) {
+      console.log(all ? "No mounts registered." : "No mounts for this session. Use --all to see all mounts.");
+    } else {
+      const label = all ? "All mounts" : `Mounts${sessionId ? ` (session ${sessionId.slice(0, 8)})` : ""}`;
+      console.log(`${label}:
+`);
+      for (const m of mounts) {
+        const session = m.sessionId ? m.sessionId.slice(0, 8) : "-";
+        console.log(`  ${m.name}`);
+        console.log(`    Directory: ${m.directory}`);
+        console.log(`    Session:   ${session}`);
+        console.log(`    Added:     ${new Date(m.addedAt).toISOString().slice(0, 16).replace("T", " ")}`);
+        console.log("");
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+async function serveInfo(machineId) {
+  const { connectAndGetMachine } = await import('./commands-h1lFrJKK.mjs');
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const info = await machine.serveInfo({ _rkwargs: true });
+    console.log(`Static file server:`);
+    console.log(`  Status:  ${info.running ? "running" : "stopped"}`);
+    console.log(`  Port:    ${info.port || "-"}`);
+    console.log(`  URL:     ${info.url || "(not exposed)"}`);
+    console.log(`  Mounts:  ${info.mountCount}`);
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
+function printServeHelp() {
+  console.log(`
+svamp serve \u2014 Shared static file server
+
+Serve local directories via a single daemon-managed HTTP server with one public URL.
+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 remove <name>            Remove a mount
+  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
+
+Options:
+  -m, --machine <id>    Target a specific machine
+  --session <id>        Filter by session ID
+  --all, -a             Show mounts from all sessions
+  --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 list --all                       # Show all mounts
+  svamp serve remove my-report                 # Stop serving
+`);
+}
+
+export { handleServeCommand };