@suveren/gateway 0.10.0 → 0.11.0

package/dist/control-plane/index.mjs

@@ -831,9 +831,22 @@ function buildPinnedHttpsAgent(getPinning) {
     ca: effectiveCa()
   });
 }
+var DEFAULT_AS_FETCH_TIMEOUT_MS = 15e3;
+function withBoundedSignal(init) {
+  const timeout = AbortSignal.timeout(DEFAULT_AS_FETCH_TIMEOUT_MS);
+  const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+  return { ...init, signal };
+}
+function closeAfter(dispatcher, pending) {
+  pending.catch(() => {
+  }).finally(() => {
+    void dispatcher.close().catch(() => {
+    });
+  });
+}
 async function fetchAs(url, init, pinning) {
   if (!pinning.enforce && !pinning.capture) {
-    const res2 = await fetch(url, init);
+    const res2 = await fetch(url, withBoundedSignal(init));
     return { res: res2 };
   }
   if (pinning.enforce && !pinning.capture && !pinning.pinnedSpkiHex) {
@@ -843,8 +856,10 @@ async function fetchAs(url, init, pinning) {
   }
   if (pinning.pinnedSpkiHex && (pinning.enforce || !pinning.capture)) {
     const dispatcher2 = buildPinnedDispatcher(pinning.pinnedSpkiHex);
+    const pending2 = undiciFetch(url, { ...withBoundedSignal(init), dispatcher: dispatcher2 });
+    closeAfter(dispatcher2, pending2);
     try {
-      const res2 = await undiciFetch(url, { ...init, dispatcher: dispatcher2 });
+      const res2 = await pending2;
       return { res: res2 };
     } catch (err) {
       if (!isPinCheckError(err)) throw err;
@@ -854,9 +869,11 @@ async function fetchAs(url, init, pinning) {
     }
   }
   const { dispatcher, getCapturedCert } = buildCapturingDispatcher();
+  const pending = undiciFetch(url, { ...withBoundedSignal(init), dispatcher });
+  closeAfter(dispatcher, pending);
   let res;
   try {
-    res = await undiciFetch(url, { ...init, dispatcher });
+    res = await pending;
   } catch (err) {
     if (!isPinCheckError(err)) throw err;
     throw new AsTlsMismatchError(
@@ -1208,7 +1225,12 @@ function createAuthRouter(vault2, logoutAuth, loginRateLimit2, onSessionEstablis
               // identifies itself this way; without it, a 24-hour browser
               // session (see doc at the top of this file).
               ...clientVersionHeaders()
-            }
+            },
+            // Belt-and-suspenders on top of fetchAs's own default bound
+            // (as-tls-pin.ts): this is the exact call that hung in
+            // production (2026-10-02) with NO timeout at all — a dead
+            // keep-alive socket left the whole login request stuck forever.
+            signal: AbortSignal.timeout(1e4)
           },
           sessionPinning
         );
@@ -1218,7 +1240,11 @@ function createAuthRouter(vault2, logoutAuth, loginRateLimit2, onSessionEstablis
           res.status(409).json({ error: "as_tls_mismatch", message: err.message });
           return;
         }
-        throw err;
+        res.status(502).json({
+          error: "as_unreachable",
+          message: `Could not reach the Authority Server at ${SP_URL2} to sign in \u2014 ${err instanceof Error ? err.message : String(err)}. Refusing to sign in.`
+        });
+        return;
       }
       if (!spRes.ok) {
         const err = await spRes.json().catch(() => ({ error: "Invalid API key" }));
@@ -1366,7 +1392,16 @@ function createAuthRouter(vault2, logoutAuth, loginRateLimit2, onSessionEstablis
       unconfigureSession(),
       cookie ? fetchAs(
         `${SP_URL2}/api/auth/logout`,
-        { method: "POST", headers: { cookie, ...clientVersionHeaders() }, redirect: "manual" },
+        {
+          method: "POST",
+          headers: { cookie, ...clientVersionHeaders() },
+          redirect: "manual",
+          // Same reasoning as the session call above — this sat with no
+          // timeout of its own before, which would have hung the
+          // `Promise.allSettled` below (and this handler's response)
+          // forever on a dead connection.
+          signal: AbortSignal.timeout(1e4)
+        },
         logoutPinning
       ).catch((err) => {
         if (err instanceof AsTlsMismatchError) {
@@ -3510,6 +3545,11 @@ function selectDenials(records, opts = {}) {
   return { count, records: out };
 }
 
+// src/lib/simulation-mode.ts
+function isSimulationMode() {
+  return process.env.SUVEREN_SIMULATION === "1";
+}
+
 // src/index.ts
 (function migrateDataDir() {
   if (process.env.SUVEREN_DATA_DIR) return;
@@ -4124,6 +4164,9 @@ app.get("/health", async (req, res) => {
     updateAvailable: update.updateAvailable,
     installMethod: INSTALL_METHOD,
     spUrl: SP_URL,
+    // Purely local — the Authority Server never learns this. UI reads it to
+    // show a gateway-wide banner ("real systems are blocked").
+    simulation: isSimulationMode(),
     session: buildSessionHealth(vault),
     security: {
       note: "Gateway secures tool execution. Agent host isolation is the user's responsibility."

package/dist/mcp-server/http.mjs

@@ -324,9 +324,22 @@ function buildCapturingDispatcher() {
   });
   return { dispatcher, getCapturedCert: () => captured };
 }
+var DEFAULT_AS_FETCH_TIMEOUT_MS = 15e3;
+function withBoundedSignal(init) {
+  const timeout = AbortSignal.timeout(DEFAULT_AS_FETCH_TIMEOUT_MS);
+  const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+  return { ...init, signal };
+}
+function closeAfter(dispatcher, pending) {
+  pending.catch(() => {
+  }).finally(() => {
+    void dispatcher.close().catch(() => {
+    });
+  });
+}
 async function fetchAs(url, init, pinning) {
   if (!pinning.enforce && !pinning.capture) {
-    const res2 = await fetch(url, init);
+    const res2 = await fetch(url, withBoundedSignal(init));
     return { res: res2 };
   }
   if (pinning.enforce && !pinning.capture && !pinning.pinnedSpkiHex) {
@@ -336,8 +349,10 @@ async function fetchAs(url, init, pinning) {
   }
   if (pinning.pinnedSpkiHex && (pinning.enforce || !pinning.capture)) {
     const dispatcher2 = buildPinnedDispatcher(pinning.pinnedSpkiHex);
+    const pending2 = undiciFetch(url, { ...withBoundedSignal(init), dispatcher: dispatcher2 });
+    closeAfter(dispatcher2, pending2);
     try {
-      const res2 = await undiciFetch(url, { ...init, dispatcher: dispatcher2 });
+      const res2 = await pending2;
       return { res: res2 };
     } catch (err) {
       if (!isPinCheckError(err)) throw err;
@@ -347,9 +362,11 @@ async function fetchAs(url, init, pinning) {
     }
   }
   const { dispatcher, getCapturedCert } = buildCapturingDispatcher();
+  const pending = undiciFetch(url, { ...withBoundedSignal(init), dispatcher });
+  closeAfter(dispatcher, pending);
   let res;
   try {
-    res = await undiciFetch(url, { ...init, dispatcher });
+    res = await pending;
   } catch (err) {
     if (!isPinCheckError(err)) throw err;
     throw new AsTlsMismatchError(
@@ -2582,10 +2599,62 @@ function clampAgeFloor(requested, maxAgeDays, nowMs, format = "iso") {
 }
 
 // src/lib/tool-proxy.ts
-import { getProfile as getProfile3, ContentBindingError } from "@hap/core";
+import { getProfile as getProfile3, ContentBindingError, boundActionTypes as boundActionTypes2 } from "@hap/core";
 import { readFile } from "fs/promises";
 import { extname } from "path";
 import { randomUUID } from "crypto";
+
+// src/lib/manifest-loader.ts
+import { readFileSync as readFileSync12, existsSync as existsSync11 } from "fs";
+import { join as join11, resolve } from "path";
+var manifests = /* @__PURE__ */ new Map();
+function loadManifests(integrationsDir) {
+  const dir = resolve(
+    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join11(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
+  );
+  const indexPath = join11(dir, "index.json");
+  if (!existsSync11(indexPath)) {
+    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
+    return 0;
+  }
+  let index;
+  try {
+    index = JSON.parse(readFileSync12(indexPath, "utf-8"));
+  } catch (err) {
+    console.error(`[ManifestLoader] Failed to parse ${indexPath}:`, err);
+    return 0;
+  }
+  let loaded = 0;
+  for (const [id, relativePath] of Object.entries(index.integrations)) {
+    const manifestPath = join11(dir, relativePath);
+    try {
+      const manifest = JSON.parse(readFileSync12(manifestPath, "utf-8"));
+      manifests.set(id, manifest);
+      loaded++;
+    } catch (err) {
+      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
+    }
+  }
+  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
+  return loaded;
+}
+function getManifest(id) {
+  return manifests.get(id);
+}
+function getAllManifests() {
+  return Array.from(manifests.values());
+}
+
+// src/lib/simulation-mode.ts
+function isSimulationMode() {
+  return process.env.SUVEREN_SIMULATION === "1";
+}
+function manifestIsSimulated(manifest) {
+  return Boolean(manifest?.simulation);
+}
+var SIMULATION_BLOCK_REASON = "blocked: simulation mode \u2014 real systems are off";
+
+// src/lib/tool-proxy.ts
 var IMAGE_MIME = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -2645,6 +2714,38 @@ function applyMapping(m, value, execution) {
 function profileMatches(profileId, shortName) {
   return profileId === shortName || profileId.includes("/" + shortName + "@") || profileId.endsWith("/" + shortName);
 }
+function countBoundsFor(profileId, actionType) {
+  const fields = getProfile3(profileId)?.boundsSchema?.fields;
+  if (!fields) return null;
+  return Object.entries(fields).filter(([, def]) => def.boundType?.kind === "cumulative_count").filter(([name, def]) => {
+    const applies = boundActionTypes2(name, def);
+    return applies === void 0 || applies.includes(actionType);
+  }).map(([name]) => name);
+}
+function zeroCappedBound(profileId, bounds, actionType) {
+  if (typeof actionType !== "string") return null;
+  const names = countBoundsFor(profileId, actionType);
+  if (!names) return null;
+  for (const n of names) {
+    const v = bounds?.[n];
+    if (v !== void 0 && v !== "" && Number(v) <= 0) return n;
+  }
+  return null;
+}
+function toolIsAuthorizedForDisplay(tool, matchingAuths) {
+  if (!tool.gating?.hideUnlessAuthorized) return true;
+  if (matchingAuths.length === 0) return false;
+  const profileId = tool.gating.profile;
+  const actionType = tool.gating.staticExecution?.action_type;
+  if (!profileId || typeof actionType !== "string") return false;
+  const requiredFields = countBoundsFor(profileId, actionType);
+  if (!requiredFields) return false;
+  if (requiredFields.length === 0) return true;
+  return matchingAuths.some((a) => {
+    const bounds = a.bounds ?? a.frame;
+    return requiredFields.every((f) => Number(bounds?.[f] ?? 0) > 0);
+  });
+}
 function parseFirstJson(result) {
   const text = result.content?.find((c) => c.type === "text")?.text;
   if (typeof text !== "string") return void 0;
@@ -2670,6 +2771,15 @@ function denyRead(state2, tool, reason, detail, target) {
   return { content: [{ type: "text", text: `Read blocked by Gatekeeper: ${detail}` }], isError: true };
 }
 function createGatedToolHandler(tool, integrationManager2, state2) {
+  if (isSimulationMode() && !manifestIsSimulated(getManifest(tool.integrationId))) {
+    return async () => ({
+      content: [{
+        type: "text",
+        text: `Refused: "${tool.namespacedName}" talks to a real system, but this gateway is running in simulation mode (real systems are off). No ticket was requested.`
+      }],
+      isError: true
+    });
+  }
   const gated = createGatedToolHandlerInner(tool, integrationManager2, state2);
   const inner = async (args) => gated(normalizeIncomingArgs(tool, args));
   const blocked = tool.gating?.blockedArgs ?? [];
@@ -2945,7 +3055,10 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
         bounds: candidate.bounds,
         context: candidate.context
       });
-      if (result.approved) {
+      const capped = result.approved ? zeroCappedBound(candidate.profileId, candidate.bounds ?? candidate.frame, typeof execution.action_type === "string" ? execution.action_type : void 0) : null;
+      if (result.approved && capped) {
+        errors.push(`${candidate.path}: ${capped} is 0 \u2014 this mandate does not allow "${execution.action_type}"`);
+      } else if (result.approved) {
         passers.push(candidate);
       } else {
         const reasons = result.errors.map((e) => {
@@ -3981,9 +4094,10 @@ function createMcpServer(state2, integrationManager2) {
       const description = buildProxiedToolDescription(tool, state2);
       registered.update({ description });
       if (tool.gating?.profile) {
-        const hasAuth = auths.some(
+        const matchingAuths = auths.filter(
           (a) => a.complete && profileMatches(a.profileId, tool.gating.profile)
         );
+        const hasAuth = matchingAuths.length > 0 && toolIsAuthorizedForDisplay(tool, matchingAuths);
         if (hasAuth) registered.enable();
         else registered.disable();
       } else {
@@ -4024,16 +4138,16 @@ function verifyGateContentHashes(content, auth) {
 }
 
 // src/lib/integration-registry.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync11 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync12 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname9, join as join11 } from "path";
-var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join11(homedir8(), ".suveren");
+import { dirname as dirname9, join as join12 } from "path";
+var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join12(homedir8(), ".suveren");
 var IntegrationRegistry = class {
   integrations = /* @__PURE__ */ new Map();
   filePath;
   constructor(dataDir2) {
     const dir = dataDir2 ?? DEFAULT_DATA_DIR;
-    this.filePath = join11(dir, "integrations.json");
+    this.filePath = join12(dir, "integrations.json");
     this.load();
   }
   // ─── CRUD ───────────────────────────────────────────────────────────────
@@ -4064,12 +4178,12 @@ var IntegrationRegistry = class {
   }
   // ─── Load / Save ────────────────────────────────────────────────────────
   load() {
-    if (!existsSync11(this.filePath)) {
+    if (!existsSync12(this.filePath)) {
       mkdirSync9(dirname9(this.filePath), { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync12(this.filePath, "utf-8");
+      const raw = readFileSync13(this.filePath, "utf-8");
       const data = JSON.parse(raw);
       const migrated = data.integrations.map((i) => {
         if ("toolGating" in i && !("profile" in i)) {
@@ -4112,47 +4226,6 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { getProfile as getProfile5 } from "@hap/core";
 
-// src/lib/manifest-loader.ts
-import { readFileSync as readFileSync13, existsSync as existsSync12 } from "fs";
-import { join as join12, resolve } from "path";
-var manifests = /* @__PURE__ */ new Map();
-function loadManifests(integrationsDir) {
-  const dir = resolve(
-    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join12(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
-  );
-  const indexPath = join12(dir, "index.json");
-  if (!existsSync12(indexPath)) {
-    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
-    return 0;
-  }
-  let index;
-  try {
-    index = JSON.parse(readFileSync13(indexPath, "utf-8"));
-  } catch (err) {
-    console.error(`[ManifestLoader] Failed to parse ${indexPath}:`, err);
-    return 0;
-  }
-  let loaded = 0;
-  for (const [id, relativePath] of Object.entries(index.integrations)) {
-    const manifestPath = join12(dir, relativePath);
-    try {
-      const manifest = JSON.parse(readFileSync13(manifestPath, "utf-8"));
-      manifests.set(id, manifest);
-      loaded++;
-    } catch (err) {
-      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
-    }
-  }
-  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
-  return loaded;
-}
-function getManifest(id) {
-  return manifests.get(id);
-}
-function getAllManifests() {
-  return Array.from(manifests.values());
-}
-
 // src/lib/remote-auth-preflight.ts
 var AUTH_HEADER_RE = /^authorization:\s*(.+)$/i;
 function remotePreflightTarget(command, args) {
@@ -4460,10 +4533,21 @@ var IntegrationManager = class {
       if (opts.skipIfRunning) return existing.tools;
       await this.stopIntegrationLocked(config.id);
     }
+    if (isSimulationMode() && !manifestIsSimulated(getManifest(config.id))) {
+      throw new Error(`${config.id}: ${SIMULATION_BLOCK_REASON}`);
+    }
     if (config.npmPackage) {
       await this.ensureInstalled(config.npmPackage);
     }
     const env = this.resolveEnvKeys(config);
+    if (isSimulationMode()) {
+      const manifest = getManifest(config.id);
+      const simDecl = manifest?.simulation;
+      if (simDecl) {
+        const envVar = Object.entries(manifest.credentials.envMapping).find(([, credKey]) => credKey === simDecl.field)?.[0];
+        if (envVar) env[envVar] = "simulation";
+      }
+    }
     const interpolate = (s) => s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => env[name] ?? process.env[name] ?? "");
     const args = config.args.map(interpolate);
     const remote = remotePreflightTarget(config.command, args);
@@ -4638,7 +4722,15 @@ var IntegrationManager = class {
             name: config.name,
             running: false,
             toolCount: 0,
-            readAgeDays: readAgeOf(config)
+            readAgeDays: readAgeOf(config),
+            // Computed fresh, not cached: true whenever simulation mode is on
+            // AND this connector has no manifest `simulation` marker, which is
+            // exactly the condition startIntegrationLocked refuses under — so
+            // the UI always reflects why a real connector never started,
+            // without needing a separate error-tracking path for this one
+            // reason. Unrelated start failures still surface via the
+            // `warning` string returned by /internal/add-integration.
+            error: isSimulationMode() && !manifestIsSimulated(getManifest(config.id)) ? SIMULATION_BLOCK_REASON : void 0
           });
         }
       }
@@ -4732,7 +4824,8 @@ var IntegrationManager = class {
           read: ext.read,
           readGovernance: ext.readGovernance,
           readGovernanceReason: ext.readGovernanceReason,
-          blockedArgs: ext.blockedArgs
+          blockedArgs: ext.blockedArgs,
+          hideUnlessAuthorized: ext.hideUnlessAuthorized
         };
       }
       return {
@@ -4746,7 +4839,8 @@ var IntegrationManager = class {
         contentField: ext.contentField,
         blockedArgs: ext.blockedArgs,
         argEncoding: ext.argEncoding,
-        argNormalization: ext.argNormalization
+        argNormalization: ext.argNormalization,
+        hideUnlessAuthorized: ext.hideUnlessAuthorized
       };
     }
     return {