svamp-cli 0.2.341 → 0.2.346

package/dist/sharingNotificationSync-qGIQ-3yf.mjs

@@ -0,0 +1,359 @@
+import { randomUUID, createHash } from 'node:crypto';
+
+const SHARE_COLLECTION_ID = "public/svamp-shared-sessions";
+const EVENT_COLLECTION_ID = "public/svamp-user-events";
+const SYSTEM_COLLECTION_CONFIG = {
+  permissions: { "@": "lf+" },
+  private_children: true,
+  recipient_field: "recipientEmail",
+  recipient_can_delete: true
+};
+function computeCollectionConfigUpdate(existingConfig, extra) {
+  const cfg = existingConfig || {};
+  const changed = Object.entries(extra).some(([k, v]) => JSON.stringify(cfg[k]) !== JSON.stringify(v));
+  return { changed, merged: { ...cfg, ...extra } };
+}
+function emailHash(email) {
+  return createHash("sha256").update(email.toLowerCase()).digest("hex").slice(0, 12);
+}
+function sessionIdHash(sessionId) {
+  return createHash("sha256").update(sessionId).digest("hex").slice(0, 12);
+}
+function roleLabel(role) {
+  switch (role) {
+    case "admin":
+      return "full access";
+    case "interact":
+      return "can interact";
+    case "view":
+      return "view only";
+    default:
+      return String(role);
+  }
+}
+function shareAlias(sessionId, recipientEmail) {
+  return `share-${sessionIdHash(sessionId)}-${emailHash(recipientEmail)}`;
+}
+function eventAlias(eventId, recipientEmail) {
+  return `evt-${emailHash(recipientEmail)}-${eventId.slice(0, 8)}`;
+}
+class SharingNotificationSync {
+  server;
+  artifactManager = null;
+  amResolvedAt = 0;
+  shareCollectionId = null;
+  eventCollectionId = null;
+  initialized = false;
+  log;
+  // A resolved `public/artifact-manager` proxy is bound to a SPECIFIC backend client_id. When that
+  // backend pod is replaced (deploy/restart/idle-evict), the new instance registers under the same
+  // public alias but a fresh client_id — the cached proxy dangles and every call TIMES OUT (~30s).
+  // Before this fix that silently broke ALL zero-click share writes fleet-wide (empty
+  // svamp-shared-sessions → recipients never auto-discovered). So we re-resolve on a short TTL and,
+  // on any RPC error, force one fresh re-resolve + retry (a dead pod's proxy always fails first).
+  static AM_TTL_MS = 3e4;
+  constructor(server, log) {
+    this.server = server;
+    this.log = log;
+  }
+  /**
+   * Resolve `public/artifact-manager` on the daemon's live connection. hypha-rpc re-queries the
+   * server registry on each getService() call, so a fresh resolve yields the CURRENTLY-registered
+   * live instance (not the dangling cached one). Cached within a short TTL to avoid a lookup per
+   * write; `force` bypasses the cache after a failure.
+   */
+  async getAM(force = false) {
+    const now = Date.now();
+    if (!force && this.artifactManager && now - this.amResolvedAt < SharingNotificationSync.AM_TTL_MS) {
+      return this.artifactManager;
+    }
+    const am = await this.server.getService("public/artifact-manager");
+    this.artifactManager = am;
+    this.amResolvedAt = Date.now();
+    return am;
+  }
+  /**
+   * Run an artifact-manager operation with automatic recovery from a stale/dead proxy: try with the
+   * (possibly cached) instance; on ANY error, force a fresh re-resolve and retry ONCE. This is the
+   * heart of the stale-proxy fix — a replaced backend pod makes the first call time out, the retry
+   * re-binds to the live instance and succeeds. The caller still catches the final error.
+   */
+  async withAM(op) {
+    try {
+      return await op(await this.getAM(false));
+    } catch (err) {
+      this.log(`[SHARING NOTIFY] artifact-manager call failed (${err?.message}); re-resolving + retrying`);
+      return await op(await this.getAM(true));
+    }
+  }
+  async init() {
+    try {
+      const am = await this.getAM(true);
+      if (!am) {
+        this.log("[SHARING NOTIFY] Artifact manager not available");
+        return;
+      }
+      this.shareCollectionId = SHARE_COLLECTION_ID;
+      this.eventCollectionId = EVENT_COLLECTION_ID;
+      this.initialized = true;
+      this.log(`[SHARING NOTIFY] Initialized (${EVENT_COLLECTION_ID} + ${SHARE_COLLECTION_ID})`);
+    } catch (err) {
+      this.log(`[SHARING NOTIFY] Init failed: ${err.message}`);
+    }
+  }
+  // ── Share bookmark artifacts (svamp-shared-sessions) ──────────────
+  async notifyShare(params) {
+    if (!this.initialized || !this.shareCollectionId) return;
+    const alias = shareAlias(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 {
+      await this.withAM(async (am) => {
+        const artifact = await am.create({
+          alias,
+          parent_id: this.shareCollectionId,
+          type: "share-notification",
+          stage: true,
+          manifest,
+          _rkwargs: true
+        });
+        await am.commit({ artifact_id: artifact.id, _rkwargs: true }).catch(() => {
+        });
+      });
+    } catch (createErr) {
+      this.log(`[SHARING NOTIFY] share-notification attach skipped for ${params.recipientEmail}: ${createErr.message}`);
+    }
+    this.log(`[SHARING NOTIFY] Share notified ${params.recipientEmail} about ${params.shareType || "session"} ${params.sessionId.slice(0, 8)}`);
+    const shareType = params.shareType || "session";
+    const typeLabel = shareType === "machine" ? "Machine" : "Session";
+    await this.publishUserEvent({
+      id: randomUUID(),
+      recipientEmail: params.recipientEmail.toLowerCase(),
+      type: "sharing-invite",
+      source: {
+        service: "svamp-machine",
+        workspace: params.ownerWorkspace,
+        userEmail: params.ownerEmail
+      },
+      title: `${typeLabel} shared with you`,
+      // #0689: render the recipient's ACTUAL role (view/interact/admin) — authorize.ts genuinely
+      // enforces per-user roles, so the old hardcoded "(full access)" misstated a view/interact
+      // invitee's access.
+      body: `${params.ownerEmail} shared "${params.label || "Untitled"}" with you (${roleLabel(params.role)})`,
+      level: "info",
+      action: shareType === "session" ? {
+        type: "add-session-bookmark",
+        sessionId: params.sessionId,
+        workspace: params.ownerWorkspace,
+        machineServiceId: params.machineServiceId,
+        label: params.label || ""
+      } : {
+        type: "add-machine-bookmark",
+        machineId: params.machineId,
+        workspace: params.ownerWorkspace,
+        label: params.label || ""
+      },
+      createdAt: Date.now(),
+      expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1e3
+      // 30 days
+    });
+  }
+  async removeNotification(sessionId, recipientEmail) {
+    if (!this.initialized || !this.shareCollectionId) return;
+    const alias = shareAlias(sessionId, recipientEmail);
+    try {
+      await this.withAM(async (am) => {
+        const existing = await am.read({
+          artifact_id: alias,
+          parent_id: this.shareCollectionId,
+          _rkwargs: true
+        });
+        await am.delete({
+          artifact_id: existing.id,
+          _rkwargs: true
+        });
+      });
+      this.log(`[SHARING NOTIFY] Removed share notification for ${recipientEmail} on ${sessionId.slice(0, 8)}`);
+    } catch {
+    }
+    await this.publishUserEvent({
+      id: randomUUID(),
+      recipientEmail: recipientEmail.toLowerCase(),
+      type: "sharing-revoked",
+      source: {
+        service: "svamp-machine",
+        workspace: this.server.config?.workspace || "",
+        userEmail: ""
+      },
+      title: "Session access removed",
+      body: `Your access to a shared session has been revoked`,
+      level: "warning",
+      createdAt: Date.now(),
+      expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1e3
+      // 7 days
+    });
+  }
+  // ── General user event artifacts (svamp-user-events) ─────────────
+  /**
+   * Publish a general user event to the event inbox collection.
+   * Any service can call this to deliver an event to any user's bell icon.
+   */
+  async publishUserEvent(event) {
+    if (!this.initialized || !this.eventCollectionId) return;
+    const alias = eventAlias(event.id, event.recipientEmail);
+    try {
+      await this.withAM(async (am) => {
+        const artifact = await am.create({
+          alias,
+          parent_id: this.eventCollectionId,
+          type: "user-event",
+          stage: true,
+          manifest: event,
+          _rkwargs: true
+        });
+        await am.commit({
+          artifact_id: artifact.id,
+          _rkwargs: true
+        });
+      });
+      this.log(`[USER EVENT] Published ${event.type} to ${event.recipientEmail}`);
+      try {
+        this.server.emit?.({
+          type: "svamp:user-event",
+          data: event,
+          to: "*"
+        });
+      } catch {
+      }
+    } catch (err) {
+      this.log(`[USER EVENT] Failed to publish ${event.type} for ${event.recipientEmail}: ${err.message}`);
+    }
+  }
+  /**
+   * List ALL children of a collection, paginating past hypha's default page cap (`limit=100`,
+   * server hypha/artifact.py list_children). The svamp-user-events / svamp-shared-sessions
+   * collections are GLOBAL across every deployment user, so a single unpaginated list() would
+   * return only the newest ~100 rows across ALL recipients — silently hiding a given user's
+   * events past that page. We page offset+=100 until a short/empty/duplicate page.
+   */
+  async listAllChildren(parentId) {
+    const PAGE = 100;
+    const all = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let offset = 0; ; offset += PAGE) {
+      const page = await this.withAM((am) => am.list({ parent_id: parentId, offset, limit: PAGE, _rkwargs: true }));
+      if (!Array.isArray(page) || page.length === 0) break;
+      let fresh = 0;
+      for (const c of page) {
+        const k = String(c?.id ?? c?.manifest?.id ?? c?.alias ?? `${offset}:${fresh}`);
+        if (seen.has(k)) continue;
+        seen.add(k);
+        all.push(c);
+        fresh++;
+      }
+      if (page.length < PAGE || fresh === 0) break;
+    }
+    return all;
+  }
+  /**
+   * List user events addressed to `recipientEmail` (the bell inbox), newest first, excluding
+   * expired ones. Reuses the global svamp-user-events collection — cross-workspace by design.
+   * Mirrors the webapp's fetchUserEvents so the CLI reads the same source of truth. Paginated
+   * so a recipient's events past the first 100 global rows are not silently dropped; expired
+   * events the caller owns are best-effort pruned (a no-op until the collection's
+   * recipient_can_delete is active — swallowed on PermissionError).
+   */
+  async listUserEvents(recipientEmail) {
+    if (!this.initialized || !this.eventCollectionId) return [];
+    const normalized = recipientEmail.toLowerCase();
+    try {
+      const children = await this.listAllChildren(this.eventCollectionId);
+      if (!Array.isArray(children)) return [];
+      const now = Date.now();
+      const live = [];
+      const expiredOwnedIds = [];
+      for (const c of children) {
+        const m = c?.manifest;
+        if (!m || typeof m.recipientEmail !== "string" || m.recipientEmail.toLowerCase() !== normalized) continue;
+        if (m.expiresAt && m.expiresAt <= now) {
+          if (c?.id) expiredOwnedIds.push(c.id);
+          continue;
+        }
+        live.push(m);
+      }
+      for (const id of expiredOwnedIds) {
+        this.withAM((am) => am.delete({ artifact_id: id, _rkwargs: true })).catch(() => {
+        });
+      }
+      return live.sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));
+    } catch (err) {
+      this.log(`[USER EVENT] listUserEvents failed for ${recipientEmail}: ${err.message}`);
+      return [];
+    }
+  }
+  /**
+   * Acknowledge (dismiss) a user event by deleting its artifact. The alias is derived from the
+   * event id + recipient email, so only the recipient's own event is removed. Returns true if a
+   * matching event was deleted.
+   */
+  async ackUserEvent(eventId, recipientEmail) {
+    if (!this.initialized || !this.eventCollectionId) return false;
+    const normalized = recipientEmail.toLowerCase();
+    try {
+      const children = await this.listAllChildren(this.eventCollectionId);
+      if (!Array.isArray(children)) return false;
+      const short = eventId.slice(0, 8);
+      const match = children.find((c) => {
+        const m = c?.manifest;
+        return m && typeof m.id === "string" && (m.id === eventId || m.id.slice(0, 8) === short) && typeof m.recipientEmail === "string" && m.recipientEmail.toLowerCase() === normalized;
+      });
+      if (!match) return false;
+      await this.withAM((am) => am.delete({ artifact_id: match.id, _rkwargs: true }));
+      this.log(`[USER EVENT] Acked ${eventId.slice(0, 8)} for ${recipientEmail}`);
+      return true;
+    } catch (err) {
+      this.log(`[USER EVENT] ackUserEvent failed for ${recipientEmail}: ${err.message}`);
+      return false;
+    }
+  }
+  // ── Sharing config diff + sync ───────────────────────────────────
+  async syncSharing(sessionId, oldSharing, newSharing, context) {
+    if (!this.initialized) return;
+    const oldRoleByEmail = new Map(
+      (oldSharing?.allowedUsers || []).map((u) => [u.email.toLowerCase(), u.role])
+    );
+    const oldEmails = new Set(oldRoleByEmail.keys());
+    const newUsers = newSharing.allowedUsers || [];
+    const newEmails = new Set(newUsers.map((u) => u.email.toLowerCase()));
+    for (const user of newUsers) {
+      const prevRole = oldRoleByEmail.get(user.email.toLowerCase());
+      if (prevRole === void 0 || prevRole !== user.role) {
+        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(() => {
+        });
+      }
+    }
+  }
+}
+
+export { SharingNotificationSync as S, SYSTEM_COLLECTION_CONFIG as a, computeCollectionConfigUpdate as c };

package/dist/{sideband-B5n9fNxM.mjs → sideband-68HhGT0i.mjs}

@@ -1,25 +1,5 @@
-import { R as READ_ONLY_TOOLS, Q as loadMachineContext, T as buildMachineInstructions, U as machineToolsForRole, V as buildMachineTools } from './run-LHJh7jLy.mjs';
+import { R as READ_ONLY_TOOLS, l as loadMachineContext, b as buildMachineInstructions, m as machineToolsForRole, a as buildMachineTools } from './machineTools-DygM1jXW.mjs';
 import 'node:child_process';
-import 'os';
-import 'fs/promises';
-import 'fs';
-import 'path';
-import 'url';
-import 'child_process';
-import 'crypto';
-import 'node:fs';
-import 'node:path';
-import 'node:crypto';
-import 'util';
-import 'http';
-import 'net';
-import 'node:os';
-import 'node:events';
-import '@agentclientprotocol/sdk';
-import 'node:util';
-import 'node:readline';
-import 'node:fs/promises';
-import 'yaml';
 
 function toolsForRole(role) {
   if (role === "admin") return [...READ_ONLY_TOOLS, "run_bash", "send_to_session"];