@suveren/gateway 0.29.1 → 0.31.0

package/dist/mcp-server/http.mjs

@@ -1071,6 +1071,25 @@ var SPClient = class {
     if (!res.ok) return null;
     return res.json();
   }
+  /**
+   * One proposal by id, whatever its status — `GET /api/proposals/:id`
+   * (the AS admits the creator, an approver, or the authorization's owner;
+   * this gateway only ever calls it for an id it itself submitted, via
+   * proposalSubmissions, so the creator case always applies). Used by the
+   * `/internal/my-pending-proposals` stand-in (bin/http.ts) — see that
+   * route's doc comment for why it exists at all: the AS has no endpoint
+   * to list "proposals I created" scoped by creator, only `?domain=`,
+   * `?status=committed/rejected`, and `?approver=me`, none of which ever
+   * match an above-cap proposal that has no pendingDomains unless the
+   * caller also happens to be a pendingApprover.
+   */
+  async getProposal(id) {
+    const res = await this.fetch(`/api/proposals/${encodeURIComponent(id)}`);
+    if (res.status === 404) return null;
+    if (!res.ok) throw new Error(`SP proposal request failed: ${res.status}`);
+    const data = await res.json();
+    return data.proposal;
+  }
   /**
    * Get proposals that have been fully committed and are ready for execution.
    */
@@ -1124,7 +1143,7 @@ var AsKeyMismatchError = class extends Error {
   }
 };
 function isCommitmentDowngrade(auth) {
-  const requiresReview = auth.signedCommitmentMode === "review" || auth.signedCommitmentMode === "review_above_cap";
+  const requiresReview = auth.signedCommitmentMode === "review";
   return requiresReview && (auth.deferredCommitmentDomains ?? []).length === 0;
 }
 var AttestationCache = class {
@@ -1171,23 +1190,37 @@ var AttestationCache = class {
    */
   activeWorkspaceGroupId = null;
   /**
-   * Re-resolve {@link activeWorkspaceGroupId} from the Authority Server.
-   * Called by the resync-gates flow (http.ts's `/internal/resync-gates`),
-   * never on the hot tool-call path — it makes up to two AS calls. Leaves
-   * the previous value in place on any failure (network error, unexpected
-   * shape): losing a known-good value on a transient blip would turn this
-   * defence-in-depth check into a false refusal of every cached mandate,
-   * which is worse than leaving it momentarily stale.
+   * TR7 (work-plan "Added 2026-10-14"): the account's own Personal group id
+   * — learned alongside {@link activeWorkspaceGroupId} so {@link isTeamGroup}
+   * can tell a TEAM-owned authorization apart from a Personal one without a
+   * live AS call on the hot read path. `null` = not yet known, same
+   * "skip rather than guess" posture as `activeWorkspaceGroupId`.
+   */
+  personalGroupId = null;
+  /**
+   * Re-resolve {@link activeWorkspaceGroupId} and {@link personalGroupId}
+   * from the Authority Server. Called by the resync-gates flow (http.ts's
+   * `/internal/resync-gates`), never on the hot tool-call path — it makes up
+   * to two AS calls (`getActiveTeamGroupId` + `getPersonalGroupId`, the
+   * second already needed for both values). Leaves the previous value(s) in
+   * place on any failure (network error, unexpected shape): losing a
+   * known-good value on a transient blip would turn this defence-in-depth
+   * check into a false refusal of every cached mandate, which is worse than
+   * leaving it momentarily stale.
    */
   async refreshActiveWorkspace() {
+    let activeTeam = null;
+    try {
+      activeTeam = await this.spClient.getActiveTeamGroupId();
+      if (activeTeam) this.activeWorkspaceGroupId = activeTeam;
+    } catch {
+    }
     try {
-      const activeTeam = await this.spClient.getActiveTeamGroupId();
-      if (activeTeam) {
-        this.activeWorkspaceGroupId = activeTeam;
-        return;
-      }
       const personalId = await this.spClient.getPersonalGroupId();
-      if (personalId) this.activeWorkspaceGroupId = personalId;
+      if (personalId) {
+        this.personalGroupId = personalId;
+        if (!activeTeam) this.activeWorkspaceGroupId = personalId;
+      }
     } catch {
     }
   }
@@ -1200,6 +1233,19 @@ var AttestationCache = class {
   isForeignWorkspace(groupId) {
     return groupId !== void 0 && this.activeWorkspaceGroupId !== null && groupId !== this.activeWorkspaceGroupId;
   }
+  /**
+   * TR7 — is `groupId` a TEAM group (not the account's own Personal
+   * workspace)? `undefined` ("don't know") when either `groupId` itself or
+   * the account's Personal group id hasn't been learned yet — callers MUST
+   * treat that the same as Personal (read enforcement has no Authority
+   * Server backstop to fail closed to, unlike {@link isForeignWorkspace}'s
+   * ticket-time safety net, so an unknown status must never be read as
+   * "team" — that would apply a ceiling nobody has actually confirmed).
+   */
+  isTeamGroup(groupId) {
+    if (groupId === void 0 || this.personalGroupId === null) return void 0;
+    return groupId !== this.personalGroupId;
+  }
   /**
    * Get the SP public key, fetching from SP if not cached or expired, then —
    * when a pin exists for this exact AS URL — verifying the live key still
@@ -1779,6 +1825,7 @@ var DenialLog = class {
     } catch (err) {
       console.error("[DenialLog] failed to record denial:", err);
     }
+    void notifyControlPlane("denial-recorded");
   }
   /** Recent denials, newest first. `sinceMs` and `limit` are optional filters. */
   getRecent(sinceMs, limit = MAX_RECORDS) {
@@ -2374,6 +2421,18 @@ var ProposalSubmissionStore = class {
   get(proposalId) {
     return this.load().entries.find((e) => e.proposalId === proposalId);
   }
+  /**
+   * Every submission still on record (newest-pruned by `MAX_AGE_SECONDS`
+   * — see `load`). "Awaiting others" stand-in (2026-10-15, real-gateway
+   * e2e): until the Authority Server has a creator-scoped proposal query,
+   * this (every id THIS gateway has ever submitted) is the only local
+   * source for "proposals I created" — bin/http.ts's
+   * `/internal/my-pending-proposals` resolves each id's CURRENT state from
+   * the AS and filters to `status: 'pending'`.
+   */
+  list() {
+    return this.load().entries;
+  }
   load() {
     if (!existsSync10(this.filePath)) return { version: 1, entries: [] };
     try {
@@ -3289,6 +3348,7 @@ var SharedState = class {
     } catch (err) {
       throw new ArchiveWriteError(`Receipt archive write failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    void notifyControlPlane("ticket-recorded");
   }
   setGateContent(path, authorizationId, profileId, content, opts) {
     this.gateStore.set(authorizationId, {
@@ -3961,10 +4021,44 @@ function invalidDisplayHintsReason(toolName, entry) {
   }
   return null;
 }
+var SUMMARY_FORMATS = ["money", "percent", "list", "short", "date"];
+function invalidSummaryReason(toolName, entry) {
+  if (entry === null || typeof entry !== "object") return null;
+  const summary = entry.summary;
+  if (summary === void 0) return null;
+  const at = `override "${toolName}".summary`;
+  if (typeof summary !== "string" || summary.trim().length === 0) return `${at} must be a non-empty string`;
+  if (summary.length > 200) return `${at} must be at most 200 characters`;
+  const balanced = (open, close) => {
+    let d = 0;
+    for (const ch of summary) {
+      if (ch === open) {
+        d += 1;
+        if (d > 1) return false;
+      }
+      if (ch === close) {
+        d -= 1;
+        if (d < 0) return false;
+      }
+    }
+    return d === 0;
+  };
+  if (!balanced("{", "}")) return `${at} has unbalanced or nested { }`;
+  if (!balanced("[", "]")) return `${at} has unbalanced or nested [ ]`;
+  for (const m of summary.matchAll(/\{([^{}]+)\}/g)) {
+    const [paths, fmt, extra] = m[1].split("|").map((x) => x.trim());
+    if (extra !== void 0) return `${at} {${m[1]}} has more than one format`;
+    if (!paths.split(",").every((p) => /^[A-Za-z_][\w-]*(\.[A-Za-z_][\w-]*)*$/.test(p.trim()))) {
+      return `${at} {${m[1]}} has an invalid field path`;
+    }
+    if (fmt !== void 0 && !SUMMARY_FORMATS.includes(fmt)) return `${at} {${m[1]}} has unknown format "${fmt}"`;
+  }
+  return null;
+}
 function invalidManifestPreviewReason(manifest) {
   const overrides = manifest.toolGating?.overrides ?? {};
   for (const [toolName, entry] of Object.entries(overrides)) {
-    const reason = invalidPreviewReason(toolName, entry) ?? invalidDisplayHintsReason(toolName, entry);
+    const reason = invalidPreviewReason(toolName, entry) ?? invalidDisplayHintsReason(toolName, entry) ?? invalidSummaryReason(toolName, entry);
     if (reason) return reason;
   }
   return null;
@@ -5523,10 +5617,12 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       let readMaxAge = null;
       if (hasAgeDimension) {
         const localAge = integrationManager2.getReadAgeDays(tool.integrationId);
-        readMaxAge = localAge ?? (ageBoundField ? maxReadAgeDays(
+        const signedAge = ageBoundField ? maxReadAgeDays(
           matchingAuths.map((a) => a.bounds ?? a.frame),
           ageBoundField
-        ) : null);
+        ) : null;
+        const isTeam = typeof state2.cache?.isTeamGroup === "function" ? state2.cache.isTeamGroup(matchingAuths[0]?.groupId) : void 0;
+        readMaxAge = isTeam === true && signedAge !== null ? localAge !== null ? Math.min(localAge, signedAge) : signedAge : localAge ?? signedAge;
         if (readMaxAge === null) {
           return denyRead(
             state2,
@@ -5976,29 +6072,33 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
           return attemptWithCandidates(remaining);
         }
         if (err instanceof SPReceiptError && err.statusCode === 409) {
-          const spBody = err.body;
-          let pendingApprovers = spBody.approvers ?? [];
-          if (pendingApprovers.length === 0) {
-            try {
-              const summary = await state2.spClient.getAuthorizationSummary(authzId);
-              if (summary?.approvers_frozen) {
-                pendingApprovers = summary.approvers_frozen;
+          const rawBody = err.body;
+          const spBody = rawBody?.errors?.[0] ?? rawBody;
+          let pendingApprovers = spBody?.approvers ?? [];
+          let summary;
+          const authSummary = async () => {
+            if (summary === void 0) {
+              try {
+                summary = await state2.spClient.getAuthorizationSummary(authzId);
+              } catch {
+                summary = null;
               }
-              if (summary?.created_by) {
-                pendingApprovers = [summary.created_by, ...pendingApprovers];
-              }
-            } catch {
-            }
-          } else {
-            try {
-              const summary = await state2.spClient.getAuthorizationSummary(authzId);
-              if (summary?.created_by) {
-                pendingApprovers = [summary.created_by, ...pendingApprovers];
-              }
-            } catch {
             }
+            return summary;
+          };
+          if (pendingApprovers.length === 0) {
+            const s = await authSummary();
+            if (s?.approvers_frozen) pendingApprovers = s.approvers_frozen;
+          }
+          const isTeam = typeof state2.cache?.isTeamGroup === "function" ? state2.cache.isTeamGroup(auth.groupId) : void 0;
+          const ownerId = (await authSummary())?.created_by;
+          if (isTeam === true) {
+            if (ownerId) pendingApprovers = pendingApprovers.filter((uid) => uid !== ownerId);
+          } else if (ownerId) {
+            pendingApprovers = [ownerId, ...pendingApprovers];
           }
           const uniqueApprovers = [...new Set(pendingApprovers)];
+          const recipientUserIds = ownerId ? [.../* @__PURE__ */ new Set([ownerId, ...uniqueApprovers])] : uniqueApprovers;
           try {
             const enrichedArgs = await attachImagePreview(args);
             const wireExecCtx = wireExecutionContext(auth.profileId, execution);
@@ -6011,7 +6111,8 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
               toolArgs: enrichedArgs,
               executionContext: wireExecCtx,
               pendingApprovers: uniqueApprovers,
-              recipientUserIds: uniqueApprovers
+              recipientUserIds,
+              ...ownerId ? { createdBy: ownerId } : {}
             });
             const previewHash = await computeSubmissionPreviewHash(
               integrationManager2,
@@ -10347,6 +10448,24 @@ app.get("/internal/skipped-commitments", internalOnly, async (_req, res) => {
     res.status(502).json({ error: err instanceof Error ? err.message : "Could not reach the Authority Server" });
   }
 });
+app.get("/internal/my-pending-proposals", internalOnly, async (_req, res) => {
+  try {
+    const submitted = state.proposalSubmissions.list();
+    const resolved = await Promise.all(
+      submitted.map(async (s) => {
+        try {
+          return await state.spClient.getProposal(s.proposalId);
+        } catch {
+          return null;
+        }
+      })
+    );
+    const pending = resolved.filter((p) => p !== null && p.status === "pending");
+    res.json({ proposals: pending });
+  } catch (err) {
+    res.status(502).json({ error: err instanceof Error ? err.message : "Could not reach the Authority Server" });
+  }
+});
 app.get("/internal/evidence", internalOnly, (_req, res) => {
   if (state.receiptArchive.isLocked()) {
     res.status(503).json({ error: "Vault locked \u2014 the evidence archive is encrypted until sign-in." });