@suveren/gateway 0.8.0 → 0.8.1

package/content/integrations/deploy-github.json

@@ -20,10 +20,19 @@
         "label": "GitHub token",
         "type": "password",
         "placeholder": "github_pat_..."
+      },
+      {
+        "key": "artifactPath",
+        "label": "Artifact directory (optional)",
+        "type": "text",
+        "optional": true,
+        "placeholder": "website/dist",
+        "description": "Repository-relative directory the host serves as-is, if the built artifact is committed. Lets get_deployment report a digest of the served bytes and derive the source commit from git, so a private staged build can still be released."
       }
     ],
     "envMapping": {
-      "GITHUB_TOKEN": "githubToken"
+      "GITHUB_TOKEN": "githubToken",
+      "HAP_DEPLOY_ARTIFACT_PATH": "artifactPath"
     }
   },
   "oauth": null,

package/dist/mcp-server/http.mjs

@@ -254,7 +254,10 @@ var SPClient = class {
         const message = first?.message ?? first?.code ?? respBody.error ?? `SP receipt request failed: ${res.status}`;
         throw new SPReceiptError(message, res.status, respBody);
       }
-      return { receipt: respBody.receipt };
+      return {
+        receipt: respBody.receipt,
+        idempotent: respBody.idempotent === true
+      };
     }
     throw lastError ?? new Error("postReceipt: retries exhausted");
   }
@@ -1136,6 +1139,93 @@ var ReceiptArchive = class {
   }
 };
 
+// src/lib/execution-journal.ts
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6, renameSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname5, join as join6 } from "path";
+import { createHash } from "crypto";
+var DEFAULT_DIR5 = process.env.SUVEREN_DATA_DIR ?? join6(homedir5(), ".suveren");
+var FILE_NAME = "execution-journal.json";
+var MAX_AGE_SECONDS2 = 90 * 24 * 60 * 60;
+function hashToolArgs(args) {
+  return "sha256:" + createHash("sha256").update(stableStringify(args)).digest("hex");
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value)) return "[" + value.map(stableStringify).join(",") + "]";
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+var ExecutionJournal = class {
+  filePath;
+  constructor(filePath) {
+    const baseDir = filePath && filePath.endsWith(".json") ? dirname5(filePath) : filePath ?? DEFAULT_DIR5;
+    this.filePath = join6(baseDir, FILE_NAME);
+  }
+  /** Look a ticket up. Always reads from disk — another process may have written. */
+  get(ticketId) {
+    return this.load().entries.find((e) => e.ticketId === ticketId);
+  }
+  /**
+   * Record intent to execute under `ticketId`. Refuses if any row for that
+   * ticket already exists, whatever its state — deciding what an existing row
+   * means is the caller's job, and it differs by state (see commitments.ts).
+   */
+  begin(entry) {
+    const file = this.load();
+    const existing = file.entries.find((e) => e.ticketId === entry.ticketId);
+    if (existing) return { ok: false, existing };
+    file.entries.push({
+      ...entry,
+      state: "intent",
+      startedAt: nowSec(),
+      pid: process.pid
+    });
+    this.persist(file);
+    return { ok: true };
+  }
+  /** Close an `intent` row. Missing row is a programming error, not a silent no-op. */
+  complete(ticketId, state2) {
+    const file = this.load();
+    const row = file.entries.find((e) => e.ticketId === ticketId);
+    if (!row) throw new Error(`execution journal: no row for ticket ${ticketId} to complete`);
+    row.state = state2;
+    row.finishedAt = nowSec();
+    this.persist(file);
+  }
+  /** All rows, newest last. Diagnostic. */
+  getAll() {
+    return [...this.load().entries];
+  }
+  // ─── Persistence ────────────────────────────────────────────────────────
+  load() {
+    if (!existsSync6(this.filePath)) return { version: 1, entries: [] };
+    try {
+      const parsed = JSON.parse(readFileSync6(this.filePath, "utf8"));
+      if (parsed?.version !== 1 || !Array.isArray(parsed.entries)) {
+        throw new Error("unexpected shape");
+      }
+      return parsed;
+    } catch (err) {
+      throw new Error(
+        `execution journal at ${this.filePath} is unreadable (${err instanceof Error ? err.message : String(err)}); refusing to execute until it is inspected`
+      );
+    }
+  }
+  persist(file) {
+    const cutoff = nowSec() - MAX_AGE_SECONDS2;
+    file.entries = file.entries.filter((e) => e.startedAt >= cutoff);
+    mkdirSync5(dirname5(this.filePath), { recursive: true, mode: 448 });
+    const tmp = this.filePath + ".tmp";
+    writeFileSync5(tmp, JSON.stringify(file, null, 2), { mode: 384 });
+    renameSync(tmp, this.filePath);
+  }
+};
+function nowSec() {
+  return Math.floor(Date.now() / 1e3);
+}
+
 // src/lib/gatekeeper.ts
 import { verify } from "@hap/core";
 var MCPGatekeeper = class {
@@ -1216,6 +1306,8 @@ var SharedState = class {
   executionLog;
   denialLog;
   receiptArchive;
+  /** Which tickets this Gatekeeper has executed — the "one execution per ticket" half of exactly-once. */
+  executionJournal;
   gatekeeper;
   constructor(spUrl2, gateStorePath) {
     this.spClient = new SPClient(spUrl2);
@@ -1224,6 +1316,7 @@ var SharedState = class {
     this.executionLog = new ExecutionLog(gateStorePath);
     this.denialLog = new DenialLog(gateStorePath);
     this.receiptArchive = new ReceiptArchive(gateStorePath);
+    this.executionJournal = new ExecutionJournal(gateStorePath);
     this.gatekeeper = new MCPGatekeeper(this.cache);
   }
   /**
@@ -1372,17 +1465,17 @@ function formatConsumptionFull(entries) {
 }
 
 // src/lib/context-loader.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
-var DEFAULT_DIR5 = process.env.SUVEREN_DATA_DIR ?? join6(homedir5(), ".suveren");
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+var DEFAULT_DIR6 = process.env.SUVEREN_DATA_DIR ?? join7(homedir6(), ".suveren");
 var BRIEF_MAX_CHARS = 16 * 1024;
 function readContextFile(dataDir) {
-  const dir = dataDir ?? DEFAULT_DIR5;
-  const filePath = join6(dir, "context.md");
-  if (!existsSync6(filePath)) return null;
+  const dir = dataDir ?? DEFAULT_DIR6;
+  const filePath = join7(dir, "context.md");
+  if (!existsSync7(filePath)) return null;
   try {
-    const content = readFileSync6(filePath, "utf-8").trim();
+    const content = readFileSync7(filePath, "utf-8").trim();
     return content || null;
   } catch {
     return null;
@@ -2458,6 +2551,30 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
       let outgoingArgs = shouldAttachFooter() && receiptId ? appendVerificationFooter(tool, args, receiptId, auth.subjects?.[0]) : args;
       if (receiptId) outgoingArgs = attachReceiptId(tool, outgoingArgs, receiptId);
       outgoingArgs = encodeOutgoingArgs(tool, outgoingArgs);
+      if (receiptId) {
+        const begun = state2.executionJournal.begin({
+          ticketId: receiptId,
+          tool: tool.namespacedName,
+          argsHash: hashToolArgs(args)
+        });
+        if (!begun.ok) {
+          return {
+            content: [{
+              type: "text",
+              text: `Blocked: ticket ${receiptId} was already used to execute ${tool.namespacedName} (state: ${begun.existing.state}). Not running it again.`
+            }],
+            isError: true
+          };
+        }
+        try {
+          const result = await integrationManager2.callTool(tool.integrationId, tool.originalName, outgoingArgs);
+          state2.executionJournal.complete(receiptId, "done");
+          return result;
+        } catch (err) {
+          state2.executionJournal.complete(receiptId, "failed");
+          throw err;
+        }
+      }
       return integrationManager2.callTool(tool.integrationId, tool.originalName, outgoingArgs);
     }
   });
@@ -2786,6 +2903,13 @@ function listIntegrationsHandler(state2, integrationManager2) {
 
 // src/tools/commitments.ts
 import { ContentBindingError as ContentBindingError2 } from "@hap/core";
+var installedExecutor = null;
+function installCommittedExecutor(executor) {
+  installedExecutor = executor;
+}
+function runCommitted(proposal, state2, integrationManager2) {
+  return installedExecutor ? installedExecutor.execute(proposal) : executeCommitted(proposal, state2, integrationManager2);
+}
 async function executeCommitted(proposal, state2, integrationManager2) {
   if (!integrationManager2) {
     return { text: `Proposal ${proposal.id} committed but integration manager unavailable for execution.`, isError: true };
@@ -2805,6 +2929,7 @@ async function executeCommitted(proposal, state2, integrationManager2) {
   }
   const cachedAuth = state2.cache.getAllAuthorizations().find((a) => a.authorizationId === proposal.authorizationId);
   let receiptId;
+  let replayed = false;
   try {
     const binding = computeContentBinding(
       proposal.profileId,
@@ -2812,7 +2937,7 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       proposal.toolArgs,
       proposalActionType
     );
-    const { receipt } = await state2.spClient.postReceipt({
+    const { receipt, idempotent } = await state2.spClient.postReceipt({
       authorizationId: proposal.authorizationId,
       // Optional cross-check — the AS fails closed on a mismatch. Parity
       // with the automatic path (tool-proxy.ts).
@@ -2837,6 +2962,7 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       ...binding ? { contentHash: binding.contentHash, contentBinding: binding.contentBinding } : {}
     });
     receiptId = typeof receipt?.id === "string" ? receipt.id : void 0;
+    replayed = idempotent;
     await state2.archiveReceipt(receipt, {
       authorizationId: proposal.authorizationId,
       profileId: proposal.profileId,
@@ -2874,6 +3000,36 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       isError: true
     };
   }
+  if (!receiptId) {
+    return {
+      text: `Proposal ${proposal.id}: the ticket carries no id \u2014 refusing to execute an action that could not be recorded.`,
+      isError: true
+    };
+  }
+  const begun = state2.executionJournal.begin({
+    ticketId: receiptId,
+    proposalId: proposal.id,
+    tool: proposal.tool,
+    argsHash: hashToolArgs(proposal.toolArgs)
+  });
+  if (!begun.ok) {
+    const prior = begun.existing;
+    const when = new Date(prior.startedAt * 1e3).toISOString();
+    if (prior.state === "done") {
+      return {
+        text: `Proposal ${proposal.id} was already executed under ticket ${receiptId} at ${when}. Not running it again.`
+      };
+    }
+    return {
+      text: `Proposal ${proposal.id}: an execution under ticket ${receiptId} started at ${when} (pid ${prior.pid}) and ${prior.state === "failed" ? "reported failure" : "never reported completion"}. Not re-running: the action may already have taken effect. Check the downstream system before deciding.`,
+      isError: true
+    };
+  }
+  if (replayed) {
+    console.error(
+      `[Suveren MCP] Proposal ${proposal.id}: ticket ${receiptId} was replayed by the AS with no local execution record \u2014 executing once (lost-response recovery).`
+    );
+  }
   try {
     let outgoingArgs = proposal.toolArgs;
     if (discovered && receiptId) {
@@ -2883,7 +3039,14 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       outgoingArgs = attachReceiptId(discovered, outgoingArgs, receiptId);
       outgoingArgs = encodeOutgoingArgs(discovered, outgoingArgs);
     }
-    const result = await integrationManager2.callTool(integrationId, toolName, outgoingArgs);
+    let result;
+    try {
+      result = await integrationManager2.callTool(integrationId, toolName, outgoingArgs);
+    } catch (err) {
+      state2.executionJournal.complete(receiptId, "failed");
+      throw err;
+    }
+    state2.executionJournal.complete(receiptId, "done");
     state2.executionLog.record({
       profileId: proposal.profileId,
       path: proposal.path,
@@ -2918,7 +3081,7 @@ function checkPendingCommitmentsHandler(state2, integrationManager2) {
           };
         }
         if (match.status === "committed") {
-          const { text, isError } = await executeCommitted(match, state2, integrationManager2);
+          const { text, isError } = await runCommitted(match, state2, integrationManager2);
           return {
             content: [{ type: "text", text }],
             ...isError ? { isError: true } : {}
@@ -3172,16 +3335,16 @@ function verifyGateContentHashes(content, auth) {
 }
 
 // src/lib/integration-registry.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname5, join as join7 } from "path";
-var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join7(homedir6(), ".suveren");
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname6, join as join8 } from "path";
+var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join8(homedir7(), ".suveren");
 var IntegrationRegistry = class {
   integrations = /* @__PURE__ */ new Map();
   filePath;
   constructor(dataDir) {
     const dir = dataDir ?? DEFAULT_DATA_DIR;
-    this.filePath = join7(dir, "integrations.json");
+    this.filePath = join8(dir, "integrations.json");
     this.load();
   }
   // ─── CRUD ───────────────────────────────────────────────────────────────
@@ -3212,12 +3375,12 @@ var IntegrationRegistry = class {
   }
   // ─── Load / Save ────────────────────────────────────────────────────────
   load() {
-    if (!existsSync7(this.filePath)) {
-      mkdirSync5(dirname5(this.filePath), { recursive: true });
+    if (!existsSync8(this.filePath)) {
+      mkdirSync6(dirname6(this.filePath), { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync7(this.filePath, "utf-8");
+      const raw = readFileSync8(this.filePath, "utf-8");
       const data = JSON.parse(raw);
       const migrated = data.integrations.map((i) => {
         if ("toolGating" in i && !("profile" in i)) {
@@ -3246,39 +3409,39 @@ var IntegrationRegistry = class {
       version: 1,
       integrations: Array.from(this.integrations.values())
     };
-    mkdirSync5(dirname5(this.filePath), { recursive: true });
-    writeFileSync5(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+    mkdirSync6(dirname6(this.filePath), { recursive: true });
+    writeFileSync6(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
   }
 };
 
 // src/lib/integration-manager.ts
-import { homedir as homedir7 } from "os";
-import { join as join8, delimiter } from "path";
-import { existsSync as existsSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync8, rmSync } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join9, delimiter } from "path";
+import { existsSync as existsSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync9, rmSync } from "fs";
 import { execFile } from "child_process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { getProfile as getProfile5 } from "@hap/core";
-var DEFAULT_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join8(homedir7(), ".suveren");
-var INTEGRATIONS_DIR = process.env.SUVEREN_INTEGRATIONS_DIR ?? join8(DEFAULT_DATA_DIR2, "integrations");
+var DEFAULT_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join9(homedir8(), ".suveren");
+var INTEGRATIONS_DIR = process.env.SUVEREN_INTEGRATIONS_DIR ?? join9(DEFAULT_DATA_DIR2, "integrations");
 var installLock = Promise.resolve();
 function withInstallLock(task) {
   const run = installLock.then(task, task);
   installLock = run.then(() => void 0, () => void 0);
   return run;
 }
-var INTEGRATIONS_BIN = join8(INTEGRATIONS_DIR, "node_modules", ".bin");
+var INTEGRATIONS_BIN = join9(INTEGRATIONS_DIR, "node_modules", ".bin");
 function buildPath() {
   const base = process.env.PATH ?? "";
   return [INTEGRATIONS_BIN, base].join(delimiter);
 }
 function ensureIntegrationsDir() {
-  if (!existsSync8(INTEGRATIONS_DIR)) {
-    mkdirSync6(INTEGRATIONS_DIR, { recursive: true });
+  if (!existsSync9(INTEGRATIONS_DIR)) {
+    mkdirSync7(INTEGRATIONS_DIR, { recursive: true });
   }
-  const pkgPath = join8(INTEGRATIONS_DIR, "package.json");
-  if (!existsSync8(pkgPath)) {
-    writeFileSync6(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
+  const pkgPath = join9(INTEGRATIONS_DIR, "package.json");
+  if (!existsSync9(pkgPath)) {
+    writeFileSync7(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
   }
 }
 function readAgeOf(config) {
@@ -3344,19 +3507,19 @@ var IntegrationManager = class {
    * exist, and treat anything else as not-installed (and reinstallable).
    */
   isUsableInstall(npmPackage) {
-    const pkgDir = join8(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
-    const pkgJson = join8(pkgDir, "package.json");
-    if (!existsSync8(pkgDir) || !existsSync8(pkgJson)) return false;
+    const pkgDir = join9(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
+    const pkgJson = join9(pkgDir, "package.json");
+    if (!existsSync9(pkgDir) || !existsSync9(pkgJson)) return false;
     try {
-      const pkg = JSON.parse(readFileSync8(pkgJson, "utf8"));
+      const pkg = JSON.parse(readFileSync9(pkgJson, "utf8"));
       const defaultBinName = (pkg.name ?? npmPackage).split("/").pop() ?? "";
       const binMap = typeof pkg.bin === "string" ? { [defaultBinName]: pkg.bin } : pkg.bin ?? {};
       const binEntries = Object.entries(binMap);
       for (const [binName, target] of binEntries) {
-        if (!existsSync8(join8(pkgDir, target))) return false;
+        if (!existsSync9(join9(pkgDir, target))) return false;
         if (!this.binShimExists(binName)) return false;
       }
-      if (binEntries.length === 0 && pkg.main && !existsSync8(join8(pkgDir, pkg.main))) return false;
+      if (binEntries.length === 0 && pkg.main && !existsSync9(join9(pkgDir, pkg.main))) return false;
       return true;
     } catch {
       return false;
@@ -3370,7 +3533,7 @@ var IntegrationManager = class {
   binShimExists(binName) {
     if (!binName) return false;
     const candidates = process.platform === "win32" ? [binName, `${binName}.cmd`, `${binName}.CMD`, `${binName}.ps1`] : [binName];
-    return candidates.some((c) => existsSync8(join8(INTEGRATIONS_BIN, c)));
+    return candidates.some((c) => existsSync9(join9(INTEGRATIONS_BIN, c)));
   }
   /**
    * Install an npm package into the managed integrations directory if not
@@ -3394,8 +3557,8 @@ var IntegrationManager = class {
   }
   /** The actual install. Callers MUST hold the install lock. */
   async installNow(npmPackage) {
-    const pkgDir = join8(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
-    if (existsSync8(pkgDir)) {
+    const pkgDir = join9(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
+    if (existsSync9(pkgDir)) {
       console.error(`[IntegrationManager] Removing unusable install of ${npmPackage}`);
       try {
         rmSync(pkgDir, { recursive: true, force: true });
@@ -3811,28 +3974,28 @@ var IntegrationManager = class {
 };
 
 // src/lib/profile-loader.ts
-import { readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
-import { join as join9, resolve } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
+import { join as join10, resolve } from "path";
 import { registerProfile } from "@hap/core";
 function loadProfiles(profilesDir) {
-  const dir = resolve(profilesDir ?? process.env.SUVEREN_PROFILES_DIR ?? join9(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "..", "hap-profiles"));
-  const indexPath = join9(dir, "index.json");
-  if (!existsSync9(indexPath)) {
+  const dir = resolve(profilesDir ?? process.env.SUVEREN_PROFILES_DIR ?? join10(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "..", "hap-profiles"));
+  const indexPath = join10(dir, "index.json");
+  if (!existsSync10(indexPath)) {
     warnNoProfiles(`No index.json at ${indexPath}`);
     return 0;
   }
   let index;
   try {
-    index = JSON.parse(readFileSync9(indexPath, "utf-8"));
+    index = JSON.parse(readFileSync10(indexPath, "utf-8"));
   } catch (err) {
     console.error(`[ProfileLoader] Failed to parse ${indexPath}:`, err);
     return 0;
   }
   let loaded = 0;
   for (const [profileId, relativePath] of Object.entries(index.profiles)) {
-    const profilePath = join9(dir, relativePath);
+    const profilePath = join10(dir, relativePath);
     try {
-      const profile = JSON.parse(readFileSync9(profilePath, "utf-8"));
+      const profile = JSON.parse(readFileSync10(profilePath, "utf-8"));
       registerProfile(profileId, profile);
       const shortName = profileId.split("/").pop()?.replace(/@.*$/, "");
       if (shortName && shortName !== profileId) {
@@ -3865,30 +4028,30 @@ function warnNoProfiles(reason) {
 }
 
 // src/lib/manifest-loader.ts
-import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
-import { join as join10, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync11 } from "fs";
+import { join as join11, resolve as resolve2 } from "path";
 var manifests = /* @__PURE__ */ new Map();
 function loadManifests(integrationsDir) {
   const dir = resolve2(
-    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join10(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
+    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join11(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
   );
-  const indexPath = join10(dir, "index.json");
-  if (!existsSync10(indexPath)) {
+  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(readFileSync10(indexPath, "utf-8"));
+    index = JSON.parse(readFileSync11(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 = join10(dir, relativePath);
+    const manifestPath = join11(dir, relativePath);
     try {
-      const manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
+      const manifest = JSON.parse(readFileSync11(manifestPath, "utf-8"));
       manifests.set(id, manifest);
       loaded++;
     } catch (err) {
@@ -3907,6 +4070,90 @@ function getAllManifests() {
 
 // bin/http.ts
 import { decodeAttestationBlob as decodeAttestationBlob3 } from "@hap/core";
+
+// src/lib/committed-executor.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync12, unlinkSync as unlinkSync5, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname7, join as join12 } from "path";
+var CommittedExecutor = class {
+  constructor(run) {
+    this.run = run;
+  }
+  inFlight = /* @__PURE__ */ new Map();
+  chain = Promise.resolve();
+  /** Execute `proposal` once, however many callers ask while it is running. */
+  execute(proposal) {
+    const existing = this.inFlight.get(proposal.id);
+    if (existing) return existing;
+    const p = this.chain.then(() => this.run(proposal)).finally(() => this.inFlight.delete(proposal.id));
+    this.chain = p.then(
+      () => void 0,
+      () => void 0
+    );
+    this.inFlight.set(proposal.id, p);
+    return p;
+  }
+  /** Proposal ids currently queued or running. Diagnostic. */
+  get pending() {
+    return [...this.inFlight.keys()];
+  }
+};
+var ExecutorLock = class {
+  path;
+  held = false;
+  constructor(dataDir) {
+    this.path = join12(dataDir, "executor.lock");
+  }
+  /** Try to take the lock. Returns the holder's pid when someone else has it. */
+  acquire() {
+    const current = this.read();
+    if (current && current.pid !== process.pid && isAlive(current.pid)) {
+      return { held: false, holderPid: current.pid };
+    }
+    mkdirSync8(dirname7(this.path), { recursive: true, mode: 448 });
+    const lock = { pid: process.pid, startedAt: Math.floor(Date.now() / 1e3) };
+    writeFileSync8(this.path, JSON.stringify(lock), { mode: 384 });
+    this.held = true;
+    return { held: true };
+  }
+  /** True if this process currently holds the lock (re-checks the file). */
+  isHeld() {
+    if (!this.held) return false;
+    const current = this.read();
+    return current?.pid === process.pid;
+  }
+  release() {
+    if (!this.held) return;
+    this.held = false;
+    const current = this.read();
+    if (current?.pid === process.pid) {
+      try {
+        unlinkSync5(this.path);
+      } catch {
+      }
+    }
+  }
+  read() {
+    if (!existsSync12(this.path)) return null;
+    try {
+      const parsed = JSON.parse(readFileSync12(this.path, "utf8"));
+      return typeof parsed?.pid === "number" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+};
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+
+// bin/http.ts
+import { homedir as homedir9 } from "os";
+import { join as join13 } from "path";
 var spUrl = process.env.SUVEREN_AS_URL ?? "https://www.suveren.ai";
 var port = parseInt(process.env.SUVEREN_MCP_PORT ?? "3430", 10);
 var state = new SharedState(spUrl);
@@ -4397,12 +4644,31 @@ app.listen(port, "0.0.0.0", () => {
     }
   });
   const PROPOSAL_POLL_INTERVAL = 5e3;
+  const committedExecutor = new CommittedExecutor(
+    (proposal) => executeCommitted(proposal, state, integrationManager)
+  );
+  installCommittedExecutor(committedExecutor);
+  const dataDir = process.env.SUVEREN_DATA_DIR ?? join13(homedir9(), ".suveren");
+  const executorLock = new ExecutorLock(dataDir);
+  const lock = executorLock.acquire();
+  if (!lock.held) {
+    console.error(
+      `[Suveren MCP] Committed-proposal execution is DISABLED in this process: pid ${lock.holderPid} holds ${dataDir}/executor.lock. Approved proposals will run there. Stop that gateway if this one should execute.`
+    );
+  }
+  for (const sig of ["SIGINT", "SIGTERM", "exit"]) {
+    process.once(sig, () => executorLock.release());
+  }
+  let draining = false;
   async function executeCommittedProposals() {
+    if (!executorLock.isHeld()) return;
+    if (draining) return;
+    draining = true;
     try {
       const committed = await state.spClient.getCommittedProposals();
       for (const proposal of committed) {
         try {
-          const { text, isError } = await executeCommitted(proposal, state, integrationManager);
+          const { text, isError } = await committedExecutor.execute(proposal);
           console.error(
             isError ? `[Suveren MCP] Auto-exec proposal ${proposal.id}: ${text}` : `[Suveren MCP] Auto-executed proposal ${proposal.id}: ${proposal.tool}`
           );
@@ -4411,6 +4677,8 @@ app.listen(port, "0.0.0.0", () => {
         }
       }
     } catch {
+    } finally {
+      draining = false;
     }
   }
   setInterval(executeCommittedProposals, PROPOSAL_POLL_INTERVAL);

package/node_modules/hono/dist/cjs/client/client.js

@@ -157,24 +157,24 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   const path = parts.join("/");
   const url = (0, import_utils.mergePath)(baseUrl, path);
   if (method === "url" || method === "path") {
-    let result = url;
+    let result = (0, import_utils.removeIndexString)(url);
     if (opts.args[0]) {
       if (opts.args[0].param) {
-        result = (0, import_utils.replaceUrlParam)(url, opts.args[0].param);
+        result = (0, import_utils.replaceUrlParam)(result, opts.args[0].param);
       }
       if (opts.args[0].query) {
         result = appendQueryParams(result, buildSearchParamsOption(opts.args[0].query));
       }
     }
-    result = (0, import_utils.removeIndexString)(result);
     if (method === "url") {
       return new URL(result);
     }
     return result.slice(baseUrl.replace(/\/+$/, "").length).replace(/^\/?/, "/");
   }
   if (method === "ws") {
+    const normalizedUrl = (0, import_utils.removeIndexString)(url);
     const webSocketUrl = (0, import_utils.replaceUrlProtocol)(
-      opts.args[0]?.param ? (0, import_utils.replaceUrlParam)(url, opts.args[0].param) : url,
+      opts.args[0]?.param ? (0, import_utils.replaceUrlParam)(normalizedUrl, opts.args[0].param) : normalizedUrl,
       "ws"
     );
     const targetUrl = new URL(webSocketUrl);