@suveren/gateway 0.2.0

package/dist/control-plane/index.mjs

@@ -0,0 +1,1927 @@
+import {
+  getAllPromptOverrides,
+  setPromptOverride
+} from "./chunk-3BNWN6VP.mjs";
+
+// src/index.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3, renameSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import express from "express";
+import { createProxyMiddleware } from "http-proxy-middleware";
+
+// src/lib/vault.ts
+import { createHash, pbkdf2Sync, randomBytes, createCipheriv, createDecipheriv, timingSafeEqual } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var Vault = class {
+  vaultKey = null;
+  apiKeyHash = null;
+  spSessionCookie = null;
+  dataDir;
+  constructor(dataDir) {
+    this.dataDir = dataDir ?? process.env.SUVEREN_DATA_DIR ?? join(homedir(), ".suveren");
+  }
+  // ─── Key management ─────────────────────────────────────────────────────
+  deriveAndSetKey(apiKey) {
+    const vaultData = this.readVaultFile();
+    let salt;
+    if (vaultData.salt) {
+      salt = vaultData.salt;
+    } else {
+      salt = randomBytes(32).toString("hex");
+      vaultData.salt = salt;
+      this.writeVaultFile(vaultData);
+    }
+    this.vaultKey = pbkdf2Sync(apiKey, Buffer.from(salt, "hex"), 1e5, 32, "sha256");
+    this.apiKeyHash = createHash("sha256").update(apiKey).digest("hex");
+  }
+  validateApiKey(apiKey) {
+    if (!this.apiKeyHash) return false;
+    const hash = createHash("sha256").update(apiKey).digest("hex");
+    const a = Buffer.from(hash, "hex");
+    const b = Buffer.from(this.apiKeyHash, "hex");
+    return a.length === b.length && timingSafeEqual(a, b);
+  }
+  clearKey() {
+    this.vaultKey = null;
+    this.apiKeyHash = null;
+    this.spSessionCookie = null;
+  }
+  /**
+   * Check if the vault was created by a different API key.
+   * Tries to decrypt the first credential — if it fails, keys don't match.
+   * Returns true if the vault belongs to a different user (or is empty).
+   */
+  isVaultFromDifferentKey() {
+    const data = this.readVaultFile();
+    const credKeys = Object.keys(data.credentials);
+    if (credKeys.length === 0) return false;
+    try {
+      this.decrypt(data.credentials[credKeys[0]]);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Wipe all vault data — credentials, services, and salt.
+   * Used when a different user logs in on the same gateway.
+   */
+  wipe() {
+    this.writeVaultFile({ version: 1, credentials: {} });
+    this.writeServicesFile({ version: 1, services: {} });
+    this.clearKey();
+  }
+  isUnlocked() {
+    return this.vaultKey !== null;
+  }
+  getVaultKeyHex() {
+    if (!this.vaultKey) throw new Error("Vault is locked");
+    return this.vaultKey.toString("hex");
+  }
+  // ─── SP session cookie (server-side only) ───────────────────────────────
+  setSpCookie(cookie) {
+    this.spSessionCookie = cookie;
+  }
+  getSpCookie() {
+    return this.spSessionCookie;
+  }
+  // ─── Encryption primitives ──────────────────────────────────────────────
+  encrypt(plaintext) {
+    if (!this.vaultKey) throw new Error("Vault is locked");
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", this.vaultKey, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+      iv: iv.toString("hex"),
+      ciphertext: encrypted.toString("hex"),
+      tag: tag.toString("hex")
+    };
+  }
+  decrypt(blob) {
+    if (!this.vaultKey) throw new Error("Vault is locked");
+    const decipher = createDecipheriv(
+      "aes-256-gcm",
+      this.vaultKey,
+      Buffer.from(blob.iv, "hex")
+    );
+    decipher.setAuthTag(Buffer.from(blob.tag, "hex"));
+    const decrypted = Buffer.concat([
+      decipher.update(Buffer.from(blob.ciphertext, "hex")),
+      decipher.final()
+    ]);
+    return decrypted.toString("utf8");
+  }
+  // ─── Credential CRUD (vault.enc.json) ───────────────────────────────────
+  setCredential(name, fields) {
+    const data = this.readVaultFile();
+    data.credentials[name] = this.encrypt(JSON.stringify(fields));
+    this.writeVaultFile(data);
+  }
+  getCredential(name) {
+    const data = this.readVaultFile();
+    const blob = data.credentials[name];
+    if (!blob) return null;
+    return JSON.parse(this.decrypt(blob));
+  }
+  deleteCredential(name) {
+    const data = this.readVaultFile();
+    delete data.credentials[name];
+    this.writeVaultFile(data);
+  }
+  listCredentials() {
+    const data = this.readVaultFile();
+    return Object.keys(data.credentials);
+  }
+  // ─── Service CRUD (services.enc.json) ───────────────────────────────────
+  setService(id, def) {
+    const data = this.readServicesFile();
+    data.services[id] = def;
+    this.writeServicesFile(data);
+  }
+  getService(id) {
+    const data = this.readServicesFile();
+    return data.services[id] ?? null;
+  }
+  listServices() {
+    const data = this.readServicesFile();
+    return Object.values(data.services);
+  }
+  deleteService(id) {
+    const data = this.readServicesFile();
+    delete data.services[id];
+    this.writeServicesFile(data);
+  }
+  // ─── File I/O helpers ───────────────────────────────────────────────────
+  get vaultFilePath() {
+    return join(this.dataDir, "vault.enc.json");
+  }
+  get servicesFilePath() {
+    return join(this.dataDir, "services.enc.json");
+  }
+  readVaultFile() {
+    if (!existsSync(this.vaultFilePath)) {
+      return { version: 1, credentials: {} };
+    }
+    try {
+      return JSON.parse(readFileSync(this.vaultFilePath, "utf-8"));
+    } catch {
+      return { version: 1, credentials: {} };
+    }
+  }
+  writeVaultFile(data) {
+    mkdirSync(dirname(this.vaultFilePath), { recursive: true, mode: 448 });
+    writeFileSync(this.vaultFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+  readServicesFile() {
+    if (!existsSync(this.servicesFilePath)) {
+      return { version: 1, services: {} };
+    }
+    try {
+      return JSON.parse(readFileSync(this.servicesFilePath, "utf-8"));
+    } catch {
+      return { version: 1, services: {} };
+    }
+  }
+  writeServicesFile(data) {
+    mkdirSync(dirname(this.servicesFilePath), { recursive: true, mode: 448 });
+    writeFileSync(this.servicesFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+};
+
+// src/routes/auth.ts
+import { Router } from "express";
+
+// src/lib/mcp-bridge.ts
+var MCP_BASE = process.env.HAP_MCP_INTERNAL_URL ?? "http://127.0.0.1:3430";
+var internalSecret = "";
+function setInternalSecret(secret) {
+  internalSecret = secret;
+}
+function internalHeaders() {
+  return {
+    "Content-Type": "application/json",
+    "X-Internal-Secret": internalSecret
+  };
+}
+async function configure(sessionCookie, vaultKeyHex) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 5e3);
+  try {
+    const res = await fetch(`${MCP_BASE}/internal/configure`, {
+      method: "POST",
+      headers: internalHeaders(),
+      body: JSON.stringify({ sessionCookie, vaultKeyHex }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(`MCP configure failed: ${err.error}`);
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function pushGateContent(data) {
+  const res = await fetch(`${MCP_BASE}/internal/gate-content`, {
+    method: "POST",
+    headers: internalHeaders(),
+    body: JSON.stringify(data)
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(`MCP pushGateContent failed: ${err.error}`);
+  }
+}
+async function pushServiceCredentials(serviceId, credentials) {
+  const res = await fetch(`${MCP_BASE}/internal/service-credentials`, {
+    method: "POST",
+    headers: internalHeaders(),
+    body: JSON.stringify({ serviceId, credentials })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(`MCP pushServiceCredentials failed: ${err.error}`);
+  }
+}
+async function startPendingIntegrations() {
+  const res = await fetch(`${MCP_BASE}/internal/start-pending-integrations`, {
+    method: "POST",
+    headers: internalHeaders()
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(`MCP startPendingIntegrations failed: ${err.error}`);
+  }
+  return res.json();
+}
+async function resyncGates() {
+  const res = await fetch(`${MCP_BASE}/internal/resync-gates`, {
+    method: "POST",
+    headers: internalHeaders()
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(`MCP resyncGates failed: ${err.error}`);
+  }
+  return res.json();
+}
+async function getIntegrations() {
+  const res = await fetch(`${MCP_BASE}/internal/integrations`, {
+    headers: internalHeaders()
+  });
+  if (!res.ok) throw new Error("Failed to fetch integrations");
+  return res.json();
+}
+async function addIntegration(config) {
+  const res = await fetch(`${MCP_BASE}/internal/add-integration`, {
+    method: "POST",
+    headers: internalHeaders(),
+    body: JSON.stringify(config)
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(err.error);
+  }
+  return res.json();
+}
+async function activateIntegration(manifest) {
+  const optionalKeys = new Set(
+    manifest.credentials.fields.filter((f) => f.optional).map((f) => f.key)
+  );
+  const envKeys = {};
+  const optionalEnvKeys = {};
+  for (const [envVar, credKey] of Object.entries(manifest.credentials.envMapping)) {
+    if (optionalKeys.has(credKey)) {
+      optionalEnvKeys[envVar] = `${manifest.id}.${credKey}`;
+    } else {
+      envKeys[envVar] = `${manifest.id}.${credKey}`;
+    }
+  }
+  return addIntegration({
+    id: manifest.id,
+    name: manifest.name,
+    command: manifest.mcp.command,
+    args: manifest.mcp.args,
+    env: manifest.mcp.env,
+    envKeys,
+    ...Object.keys(optionalEnvKeys).length > 0 ? { optionalEnvKeys } : {},
+    profile: manifest.profile,
+    toolGating: manifest.toolGating,
+    npmPackage: manifest.npmPackage,
+    enabled: true
+  });
+}
+async function stopAndRemoveAllIntegrations() {
+  const data = await getIntegrations();
+  if (!data?.integrations) return;
+  for (const integration of data.integrations) {
+    if (integration.running) {
+      try {
+        await removeIntegration(integration.id);
+        console.error(`[MCP Bridge] Removed integration: ${integration.id}`);
+      } catch (err) {
+        console.error(`[MCP Bridge] Failed to remove ${integration.id}:`, err);
+      }
+    }
+  }
+}
+async function getManifests() {
+  const res = await fetch(`${MCP_BASE}/internal/manifests`, {
+    headers: internalHeaders()
+  });
+  if (!res.ok) throw new Error("Failed to fetch manifests");
+  return res.json();
+}
+async function removeIntegration(id) {
+  const res = await fetch(`${MCP_BASE}/internal/remove-integration/${encodeURIComponent(id)}`, {
+    method: "DELETE",
+    headers: internalHeaders()
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(err.error);
+  }
+  return res.json();
+}
+async function getGateContent(path) {
+  const qs = path ? `?path=${encodeURIComponent(path)}` : "";
+  const res = await fetch(`${MCP_BASE}/internal/gate-content${qs}`, {
+    headers: internalHeaders()
+  });
+  if (!res.ok) throw new Error("Failed to fetch gate content");
+  return res.json();
+}
+async function getMcpHealth() {
+  const res = await fetch(`${MCP_BASE}/health`);
+  if (!res.ok) throw new Error("MCP server unreachable");
+  return res.json();
+}
+
+// src/lib/e2e-crypto.ts
+import {
+  CipherSuite,
+  DhkemX25519HkdfSha256,
+  HkdfSha256,
+  Aes256Gcm
+} from "@hpke/core";
+function getSuite() {
+  return new CipherSuite({
+    kem: new DhkemX25519HkdfSha256(),
+    kdf: new HkdfSha256(),
+    aead: new Aes256Gcm()
+  });
+}
+async function generateKeyPair() {
+  const suite = getSuite();
+  const ckp = await suite.kem.generateKeyPair();
+  const privBuf = await suite.kem.serializePrivateKey(ckp.privateKey);
+  const pubBuf = await suite.kem.serializePublicKey(ckp.publicKey);
+  return {
+    privateKey: new Uint8Array(privBuf),
+    publicKey: new Uint8Array(pubBuf)
+  };
+}
+async function encryptForRecipients(intent, recipients) {
+  if (recipients.length === 0) {
+    throw new Error("encryptForRecipients: recipients array must not be empty");
+  }
+  const suite = getSuite();
+  const cek = crypto.getRandomValues(new Uint8Array(32));
+  const aesKey = await crypto.subtle.importKey(
+    "raw",
+    cek,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt"]
+  );
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const plaintextBytes = new TextEncoder().encode(intent);
+  const cipherBuf = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    aesKey,
+    plaintextBytes
+  );
+  const intentCiphertext = new Uint8Array(12 + cipherBuf.byteLength);
+  intentCiphertext.set(iv, 0);
+  intentCiphertext.set(new Uint8Array(cipherBuf), 12);
+  const encryptedKeys = {};
+  for (const { userId, publicKey } of recipients) {
+    const recipientCryptoKey = await suite.kem.deserializePublicKey(publicKey);
+    const senderCtx = await suite.createSenderContext({
+      recipientPublicKey: recipientCryptoKey
+    });
+    const wrappedCek = await senderCtx.seal(cek);
+    encryptedKeys[userId] = {
+      ct: new Uint8Array(wrappedCek),
+      enc: new Uint8Array(senderCtx.enc)
+    };
+  }
+  return { intentCiphertext, encryptedKeys };
+}
+async function decryptIntent(encrypted, myUserId, myPrivateKey) {
+  const wrap = encrypted.encryptedKeys[myUserId];
+  if (!wrap) {
+    throw new Error(`decryptIntent: no key wrap found for userId "${myUserId}"`);
+  }
+  const suite = getSuite();
+  const recipientCryptoKey = await suite.kem.deserializePrivateKey(myPrivateKey);
+  const recipientCtx = await suite.createRecipientContext({
+    recipientKey: recipientCryptoKey,
+    enc: wrap.enc
+  });
+  const cekBuf = await recipientCtx.open(wrap.ct);
+  const cek = new Uint8Array(cekBuf);
+  if (encrypted.intentCiphertext.length < 13) {
+    throw new Error("decryptIntent: intentCiphertext is too short (missing IV)");
+  }
+  const iv = encrypted.intentCiphertext.slice(0, 12);
+  const ciphertext = encrypted.intentCiphertext.slice(12);
+  const aesKey = await crypto.subtle.importKey(
+    "raw",
+    cek,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["decrypt"]
+  );
+  const plainBuf = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv },
+    aesKey,
+    ciphertext
+  );
+  return new TextDecoder().decode(plainBuf);
+}
+
+// src/lib/e2e-key-manager.ts
+var VAULT_SLOT = "e2eKey";
+function toBase64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function fromBase64(s) {
+  return new Uint8Array(Buffer.from(s, "base64"));
+}
+async function loadOrGenerateKeyPair(vault2) {
+  const stored = vault2.getCredential(VAULT_SLOT);
+  if (stored?.privateKey && stored?.publicKey) {
+    return {
+      privateKey: fromBase64(stored.privateKey),
+      publicKey: fromBase64(stored.publicKey)
+    };
+  }
+  const kp = await generateKeyPair();
+  const toStore = {
+    privateKey: toBase64(kp.privateKey),
+    publicKey: toBase64(kp.publicKey)
+  };
+  vault2.setCredential(VAULT_SLOT, toStore);
+  return kp;
+}
+
+// src/routes/auth.ts
+var SP_URL = process.env.SUVEREN_AS_URL ?? "https://www.suveren.ai";
+function createAuthRouter(vault2, logoutAuth, loginRateLimit2) {
+  const router = Router();
+  router.post("/login", loginRateLimit2, async (req, res) => {
+    const apiKey = req.headers["x-api-key"] || req.body?.apiKey;
+    const confirmWipe = req.body?.confirmWipe === true;
+    if (!apiKey) {
+      res.status(400).json({ error: "Missing API key (X-API-Key header or body.apiKey)" });
+      return;
+    }
+    try {
+      const spRes = await fetch(`${SP_URL}/api/auth/session`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": apiKey
+        }
+      });
+      if (!spRes.ok) {
+        const err = await spRes.json().catch(() => ({ error: "Invalid API key" }));
+        res.status(spRes.status).json(err);
+        return;
+      }
+      const setCookieHeaders = spRes.headers.getSetCookie?.() ?? [];
+      const sessionCookie = setCookieHeaders.join("; ");
+      vault2.setSpCookie(sessionCookie);
+      vault2.deriveAndSetKey(apiKey);
+      if (vault2.isVaultFromDifferentKey()) {
+        if (!confirmWipe) {
+          const credentialIds = vault2.listCredentials();
+          const services = vault2.listServices();
+          vault2.clearKey();
+          res.status(409).json({
+            error: "different_account",
+            wouldWipe: true,
+            summary: {
+              credentialCount: credentialIds.length,
+              serviceCount: services.length,
+              credentialIds
+            }
+          });
+          return;
+        }
+        console.error("[Control Plane] Different user confirmed \u2014 wiping vault and removing previous integrations");
+        try {
+          await stopAndRemoveAllIntegrations();
+        } catch (err) {
+          console.error("[Control Plane] Failed to remove integrations:", err);
+        }
+        vault2.wipe();
+        vault2.deriveAndSetKey(apiKey);
+      }
+      if (sessionCookie) {
+        try {
+          await configure(sessionCookie, vault2.getVaultKeyHex());
+        } catch (err) {
+          console.error("[Control Plane] Failed to configure MCP:", err);
+        }
+      }
+      const data = await spRes.json();
+      res.json(data);
+      (async () => {
+        try {
+          const kp = await loadOrGenerateKeyPair(vault2);
+          const localPubkeyB64 = Buffer.from(kp.publicKey).toString("base64");
+          const spCookie = vault2.getSpCookie();
+          const meKeyRes = await fetch(`${SP_URL}/api/users/me/pubkey`, {
+            headers: spCookie ? { Cookie: spCookie } : {},
+            signal: AbortSignal.timeout(5e3)
+          });
+          let needsUpdate = false;
+          if (meKeyRes.status === 404) {
+            needsUpdate = true;
+          } else if (meKeyRes.ok) {
+            const meKeyData = await meKeyRes.json();
+            needsUpdate = meKeyData.pubkey !== localPubkeyB64;
+          }
+          if (needsUpdate) {
+            const putRes = await fetch(`${SP_URL}/api/users/me/pubkey`, {
+              method: "PUT",
+              headers: {
+                "Content-Type": "application/json",
+                ...spCookie ? { Cookie: spCookie } : {}
+              },
+              body: JSON.stringify({ pubkey: localPubkeyB64 }),
+              signal: AbortSignal.timeout(5e3)
+            });
+            if (!putRes.ok) {
+              console.error(`[Control Plane] E2EE pubkey registration failed: ${putRes.status}`);
+            } else {
+              console.error("[Control Plane] E2EE pubkey registered with SP");
+            }
+          } else {
+            console.error("[Control Plane] E2EE pubkey already up to date");
+          }
+        } catch (err) {
+          console.error("[Control Plane] E2EE pubkey auto-register failed:", err);
+        }
+        for (const credId of vault2.listCredentials()) {
+          try {
+            const creds = vault2.getCredential(credId);
+            if (creds) {
+              await pushServiceCredentials(credId, creds);
+              console.error(`[Control Plane] Pushed ${credId} credentials to MCP`);
+            }
+          } catch (err) {
+            console.error(`[Control Plane] Failed to push ${credId} credentials:`, err);
+          }
+        }
+        try {
+          const { running } = await startPendingIntegrations();
+          console.error(`[Control Plane] Post-unlock sweep \u2014 running: ${running.join(", ") || "(none)"}`);
+        } catch (err) {
+          console.error("[Control Plane] Post-unlock sweep failed:", err);
+        }
+        try {
+          const { synced } = await resyncGates();
+          if (synced > 0) {
+            console.error(`[Control Plane] Re-synced ${synced} gate(s) with SP`);
+          }
+        } catch (err) {
+          console.error("[Control Plane] Failed to re-sync gates:", err);
+        }
+      })().catch(() => {
+      });
+    } catch (err) {
+      console.error("[Control Plane] Login error:", err);
+      res.status(500).json({ error: "Login failed" });
+    }
+  });
+  router.post("/logout", logoutAuth, async (_req, res) => {
+    vault2.clearKey();
+    res.json({ ok: true });
+  });
+  return router;
+}
+
+// src/routes/vault.ts
+import { Router as Router2 } from "express";
+function createVaultRouter(vault2) {
+  const router = Router2();
+  router.get("/status", (_req, res) => {
+    const credNames = vault2.listCredentials();
+    const services = vault2.listServices();
+    res.json({
+      initialized: vault2.isUnlocked(),
+      credentialNames: credNames,
+      serviceCount: services.length
+    });
+  });
+  router.get("/credentials/:name", (req, res) => {
+    const { name } = req.params;
+    const cred = vault2.getCredential(name);
+    if (!cred) {
+      res.json({ configured: false });
+      return;
+    }
+    res.json({ configured: true, fieldNames: Object.keys(cred), fields: cred });
+  });
+  router.put("/credentials/:name", async (req, res) => {
+    const { name } = req.params;
+    const fields = req.body;
+    vault2.setCredential(name, fields);
+    try {
+      await pushServiceCredentials(name, fields);
+    } catch (err) {
+      console.error(`[Vault] Failed to push credentials to MCP for ${name}:`, err);
+    }
+    res.json({ ok: true });
+  });
+  router.delete("/credentials/:name", (req, res) => {
+    const { name } = req.params;
+    vault2.deleteCredential(name);
+    res.json({ ok: true });
+  });
+  router.get("/services", (_req, res) => {
+    const services = vault2.listServices();
+    const credNames = vault2.listCredentials();
+    const result = services.map((svc) => ({
+      ...svc,
+      encryptedFields: void 0,
+      // strip encrypted data
+      status: credNames.includes(svc.id) ? "connected" : "missing"
+    }));
+    res.json({ services: result });
+  });
+  router.put("/services/:id", async (req, res) => {
+    const { id } = req.params;
+    const { credentials, ...serviceDef } = req.body;
+    vault2.setService(id, { ...serviceDef, id });
+    if (credentials && Object.keys(credentials).length > 0) {
+      vault2.setCredential(id, credentials);
+      try {
+        await pushServiceCredentials(id, credentials);
+      } catch (err) {
+        console.error(`[Vault] Failed to push service credentials to MCP for ${id}:`, err);
+      }
+    }
+    res.json({ ok: true });
+  });
+  router.delete("/services/:id", (req, res) => {
+    const { id } = req.params;
+    vault2.deleteService(id);
+    vault2.deleteCredential(id);
+    res.json({ ok: true });
+  });
+  router.post("/test/:name", async (req, res) => {
+    const { name } = req.params;
+    const cred = vault2.getCredential(name);
+    if (!cred) {
+      res.status(404).json({ error: "Credential not found" });
+      return;
+    }
+    try {
+      if (name === "github-pat" && cred.pat) {
+        const ghRes = await fetch("https://api.github.com/user", {
+          headers: { Authorization: `Bearer ${cred.pat}` },
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (!ghRes.ok) throw new Error(`GitHub API: ${ghRes.status}`);
+        const user = await ghRes.json();
+        res.json({ ok: true, message: `Authenticated as ${user.login}` });
+        return;
+      }
+      if (name === "ai-config" && cred.endpoint) {
+        const headers = {};
+        if (cred.apiKey) headers["Authorization"] = `Bearer ${cred.apiKey}`;
+        if (cred.provider === "ollama") {
+          const r = await fetch(`${cred.endpoint}/api/tags`, {
+            signal: AbortSignal.timeout(3e3)
+          });
+          if (!r.ok) throw new Error(`Ollama: ${r.status}`);
+        } else {
+          const r = await fetch(`${cred.endpoint}/models`, {
+            headers,
+            signal: AbortSignal.timeout(3e3)
+          });
+          if (!r.ok) throw new Error(`AI provider: ${r.status}`);
+        }
+        res.json({ ok: true, message: "AI provider is reachable" });
+        return;
+      }
+      res.json({ ok: true, message: `Credential "${name}" is configured with ${Object.keys(cred).length} field(s)` });
+    } catch (err) {
+      res.json({ ok: false, message: err instanceof Error ? err.message : "Connection test failed" });
+    }
+  });
+  return router;
+}
+
+// src/routes/ai.ts
+import { Router as Router3 } from "express";
+
+// src/lib/ai-client.ts
+var PROVIDER_PRESETS = {
+  ollama: {
+    provider: "ollama",
+    endpoint: "http://localhost:11434",
+    model: "gemma4:e4b"
+  },
+  openrouter: {
+    provider: "openai-compatible",
+    endpoint: "https://openrouter.ai/api/v1",
+    model: "google/gemma-4-31b-it"
+  },
+  openai: {
+    provider: "openai-compatible",
+    endpoint: "https://api.openai.com/v1",
+    model: "gpt-4o-mini"
+  },
+  groq: {
+    provider: "openai-compatible",
+    endpoint: "https://api.groq.com/openai/v1",
+    model: "llama-3.1-8b-instant"
+  },
+  together: {
+    provider: "openai-compatible",
+    endpoint: "https://api.together.xyz/v1",
+    model: "meta-llama/Llama-3-8b-chat-hf"
+  }
+};
+var SYSTEM_PROMPTS = {
+  intent: `You are a reviewing assistant helping a human articulate their intent for an AI agent authorization.
+
+The user is granting an agent permission to act within defined bounds. They need to describe:
+- Why this authorization exists (the situation)
+- What the agent should try to achieve (the goal)
+- What the agent should avoid or be careful about (watch-outs)
+
+Your role:
+- Surface risks or edge cases the user may not have considered
+- Point out gaps \u2014 is anything important missing?
+- Help the user think through what the agent needs to know
+
+You must NOT:
+- Write the intent for the user
+- Make decisions about what the agent should do
+- Propose specific wording
+
+Keep responses to 2-3 short paragraphs. Be practical and specific to the context.`
+};
+async function getAIAssistance(config, request) {
+  const disclaimer = "AI surfaces reality. You supply intent.";
+  const systemPrompt = SYSTEM_PROMPTS[request.gate] ?? SYSTEM_PROMPTS.intent;
+  const contextParts = [];
+  if (request.context?.profileId) contextParts.push(`Profile: ${request.context.profileId}`);
+  if (request.context?.path) contextParts.push(`Path: ${request.context.path}`);
+  if (request.context?.bounds) contextParts.push(`Bounds: ${request.context.bounds}`);
+  if (request.context?.prTitle) contextParts.push(`PR Title: ${request.context.prTitle}`);
+  if (request.context?.prBody) contextParts.push(`PR Description: ${request.context.prBody}`);
+  if (request.context?.prBranch) contextParts.push(`Branch: ${request.context.prBranch}`);
+  if (request.context?.prFileSummary) contextParts.push(`Changed Files:
+${request.context.prFileSummary}`);
+  const userPrompt = [
+    contextParts.length > 0 ? `Context:
+${contextParts.join("\n")}` : "",
+    request.currentText ? `The reviewer has written:
+"${request.currentText}"` : "The reviewer has not yet written anything.",
+    `Help them think through the ${request.gate}.`
+  ].filter(Boolean).join("\n\n");
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+  try {
+    let suggestion;
+    if (config.provider === "ollama") {
+      const response = await fetch(`${config.endpoint}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: config.model,
+          messages,
+          stream: false,
+          options: { temperature: 0.1, num_predict: 300 }
+        }),
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!response.ok) throw new Error(`Ollama: ${response.status}`);
+      const data = await response.json();
+      suggestion = data.message?.content?.trim() || "No response generated.";
+    } else {
+      const headers = { "Content-Type": "application/json" };
+      if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+      const response = await fetch(`${config.endpoint}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: config.model,
+          messages,
+          temperature: 0.1,
+          max_tokens: 300
+        }),
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`AI provider: ${response.status} - ${errorText}`);
+      }
+      const data = await response.json();
+      suggestion = data.choices?.[0]?.message?.content?.trim() || "No response generated.";
+    }
+    return { success: true, suggestion, disclaimer };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      disclaimer
+    };
+  }
+}
+var CHAT_SYSTEM_PROMPTS = {
+  context: `You help a human author "context.md" \u2014 the standing-orders brief that is prepended to every AI agent session under the Human Agency Protocol (HAP).
+
+This text goes straight into the system prompt of downstream agents. Keep it operational, concrete, and short. Favor examples the user would recognize from their work.
+
+Your role is to:
+- Ask clarifying questions when the user's intent is unclear.
+- Flag gaps or ambiguities that would confuse an agent.
+- Propose concrete phrasings when the user asks for them.
+
+When you propose a complete draft (or a full-document rewrite) of the context, wrap the draft in a fenced block like this:
+
+\`\`\`markdown
+...
+\`\`\`
+
+Only use that fence for full-document drafts the user can click "Apply". For partial suggestions, comments, or questions, write prose without the fence.`,
+  intent: `You help a human write an "Intent" paragraph for an AI agent authorization under the Human Agency Protocol (HAP).
+
+The Intent is read by two audiences:
+1. The agent, on demand via list-authorizations(domain), when it's about to act in this domain.
+2. Human reviewers, when the agent proposes an action that needs approval.
+
+A good Intent can describe:
+- Why this authorization exists (the situation).
+- What the agent should try to achieve (the goal).
+- Soft rules or watch-outs the agent must honor even inside bounds (e.g. "never publish on weekends", "only reply in German").
+
+Your role is to coach: ask clarifying questions, reflect the user's words back, surface edge cases they haven't thought about. You may propose concrete phrasings on request.
+
+CRITICAL \u2014 ask before you draft.
+
+Before you produce ANY full-document draft (anything wrapped in a \`\`\`markdown fence), you MUST first ask the user which of the three things to cover:
+
+  \u2022 Why \u2014 the situation that made them set this up
+  \u2022 Goal \u2014 what the agent should try to achieve
+  \u2022 Watch out \u2014 what the agent should avoid
+
+Phrase the question briefly and let them pick any combination, "all three", or skip any they'd rather leave out. WAIT for their answer. Do not draft until they have answered. This rule is non-negotiable, even if the user's first message is "draft a full intent for X" \u2014 you still ask the clarifying question first, then draft on the next turn.
+
+Once they have answered, produce the draft inside a single fenced block:
+
+\`\`\`markdown
+...
+\`\`\`
+
+Only use the fence for full-document drafts the user can click "Apply". For partial suggestions, questions, comments, or reflections, write prose without the fence.`
+};
+async function getAIChatResponse(config, request) {
+  const { getPromptOverride } = await import("./ai-prompts-store-5JISFV4Z.mjs");
+  const override = await getPromptOverride(request.target.kind);
+  const systemPrompt = override ?? CHAT_SYSTEM_PROMPTS[request.target.kind];
+  const groundingParts = [];
+  if (request.target.kind === "intent") {
+    if (request.target.profileId) groundingParts.push(`Profile: ${request.target.profileId}`);
+    if (request.target.path) groundingParts.push(`Path: ${request.target.path}`);
+    if (request.target.bounds) groundingParts.push(`Bounds: ${request.target.bounds}`);
+  }
+  groundingParts.push(
+    request.currentText.trim() ? `Current draft:
+"""
+${request.currentText}
+"""` : "Current draft is empty."
+  );
+  const grounding = groundingParts.join("\n");
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: grounding },
+    ...request.messages.map((m) => ({ role: m.role, content: m.content }))
+  ];
+  try {
+    let reply;
+    if (config.provider === "ollama") {
+      const response = await fetch(`${config.endpoint}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: config.model,
+          messages,
+          stream: false,
+          options: { temperature: 0.3, num_predict: 600 }
+        }),
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!response.ok) throw new Error(`Ollama: ${response.status}`);
+      const data = await response.json();
+      reply = data.message?.content?.trim() || "No response generated.";
+    } else {
+      const headers = { "Content-Type": "application/json" };
+      if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+      const response = await fetch(`${config.endpoint}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: config.model,
+          messages,
+          temperature: 0.3,
+          max_tokens: 600
+        }),
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`AI provider: ${response.status} - ${errorText}`);
+      }
+      const data = await response.json();
+      reply = data.choices?.[0]?.message?.content?.trim() || "No response generated.";
+    }
+    return { success: true, reply };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function testAIConnectivity(config) {
+  try {
+    if (config.provider === "ollama") {
+      const res = await fetch(`${config.endpoint}/api/tags`, {
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (!res.ok) throw new Error(`Ollama: ${res.status}`);
+      return { ok: true, message: "Ollama is reachable" };
+    } else {
+      const headers = {};
+      if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+      const res = await fetch(`${config.endpoint}/models`, {
+        headers,
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (!res.ok) throw new Error(`AI provider: ${res.status}`);
+      return { ok: true, message: "AI provider is reachable" };
+    }
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : "Connection failed" };
+  }
+}
+
+// src/routes/ai.ts
+function createAIRouter(vault2) {
+  const router = Router3();
+  function loadAIConfig() {
+    const cred = vault2.getCredential("ai-config");
+    if (!cred) return null;
+    return {
+      provider: cred.provider || "ollama",
+      endpoint: cred.endpoint || "http://localhost:11434",
+      model: cred.model || "llama3.2",
+      apiKey: cred.apiKey || void 0
+    };
+  }
+  router.post("/assist", async (req, res) => {
+    const config = loadAIConfig();
+    if (!config) {
+      res.status(400).json({ error: "AI not configured. Save AI settings in Settings > General." });
+      return;
+    }
+    const request = req.body;
+    if (!request.gate) {
+      res.status(400).json({ error: "Missing gate field (intent)" });
+      return;
+    }
+    const result = await getAIAssistance(config, request);
+    res.json(result);
+  });
+  router.post("/chat", async (req, res) => {
+    const config = loadAIConfig();
+    if (!config) {
+      res.status(400).json({ error: "AI not configured. Save AI settings in Settings." });
+      return;
+    }
+    const request = req.body;
+    if (!request.target || !request.target.kind) {
+      res.status(400).json({ error: "Missing target.kind (context | intent)" });
+      return;
+    }
+    if (!Array.isArray(request.messages)) {
+      res.status(400).json({ error: "Missing messages array" });
+      return;
+    }
+    const result = await getAIChatResponse(config, request);
+    res.json(result);
+  });
+  router.post("/test", async (req, res) => {
+    const body = req.body;
+    let config;
+    if (body?.endpoint) {
+      config = {
+        provider: body.provider || "ollama",
+        endpoint: body.endpoint,
+        model: body.model || "",
+        apiKey: body.apiKey
+      };
+    } else {
+      const stored = loadAIConfig();
+      if (!stored) {
+        res.status(400).json({ ok: false, message: "No AI config stored" });
+        return;
+      }
+      config = stored;
+    }
+    const result = await testAIConnectivity(config);
+    res.json(result);
+  });
+  router.get("/presets", (_req, res) => {
+    res.json({ presets: PROVIDER_PRESETS });
+  });
+  return router;
+}
+
+// src/routes/ai-prompts.ts
+import { Router as Router4 } from "express";
+var KINDS = ["intent", "context"];
+function isPromptKind(s) {
+  return KINDS.includes(s);
+}
+function createAIPromptsRouter() {
+  const router = Router4();
+  router.get("/", async (_req, res) => {
+    const overrides = await getAllPromptOverrides();
+    const out = {
+      intent: {
+        current: overrides.intent && overrides.intent.trim() ? overrides.intent : CHAT_SYSTEM_PROMPTS.intent,
+        default: CHAT_SYSTEM_PROMPTS.intent,
+        overridden: !!(overrides.intent && overrides.intent.trim())
+      },
+      context: {
+        current: overrides.context && overrides.context.trim() ? overrides.context : CHAT_SYSTEM_PROMPTS.context,
+        default: CHAT_SYSTEM_PROMPTS.context,
+        overridden: !!(overrides.context && overrides.context.trim())
+      }
+    };
+    res.json(out);
+  });
+  router.put("/:kind", async (req, res) => {
+    const kind = String(req.params.kind ?? "");
+    if (!isPromptKind(kind)) {
+      res.status(400).json({ error: `Invalid prompt kind: ${kind}` });
+      return;
+    }
+    const value = req.body?.value;
+    if (typeof value !== "string") {
+      res.status(400).json({ error: "Body must be { value: string }" });
+      return;
+    }
+    await setPromptOverride(kind, value);
+    res.json({ ok: true });
+  });
+  return router;
+}
+
+// src/middleware/auth.ts
+function requireAuth(vault2) {
+  return (req, res, next) => {
+    const apiKey = req.headers["x-api-key"];
+    if (!apiKey || !vault2.isUnlocked() || !vault2.validateApiKey(apiKey)) {
+      res.status(401).json({ error: "Unauthorized" });
+      return;
+    }
+    next();
+  };
+}
+function requireAuthQueryOrHeader(vault2) {
+  return (req, res, next) => {
+    const headerKey = req.headers["x-api-key"];
+    const queryKey = typeof req.query.key === "string" ? req.query.key : void 0;
+    const apiKey = headerKey ?? queryKey;
+    if (!apiKey || !vault2.isUnlocked() || !vault2.validateApiKey(apiKey)) {
+      res.status(401).json({ error: "Unauthorized" });
+      return;
+    }
+    next();
+  };
+}
+
+// src/routes/mcp.ts
+import { Router as Router5 } from "express";
+
+// src/lib/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Subscribe to all bus events.
+   * Returns an unsubscribe function — callers MUST call it on disconnect / unmount
+   * to avoid listener leaks.
+   */
+  subscribe(handler) {
+    this.listeners.add(handler);
+    return () => {
+      this.listeners.delete(handler);
+    };
+  }
+  emit(type, payload) {
+    const event = { type, payload };
+    for (const handler of this.listeners) {
+      try {
+        handler(event);
+      } catch (err) {
+        console.error("[EventBus] subscriber threw:", err);
+      }
+    }
+  }
+  /** How many listeners are currently subscribed. Useful for tests and health checks. */
+  get listenerCount() {
+    return this.listeners.size;
+  }
+};
+var eventBus = new EventBus();
+
+// src/routes/mcp.ts
+function createMCPRouter() {
+  const router = Router5();
+  router.get("/health", async (_req, res) => {
+    try {
+      const data = await getMcpHealth();
+      res.json(data);
+    } catch {
+      res.status(502).json({ error: "MCP server unreachable" });
+    }
+  });
+  router.get("/integrations", async (_req, res) => {
+    try {
+      const data = await getIntegrations();
+      res.json(data);
+    } catch (err) {
+      res.status(502).json({ error: err instanceof Error ? err.message : "Failed to fetch integrations" });
+    }
+  });
+  router.post("/integrations", async (req, res) => {
+    try {
+      const data = await addIntegration(req.body);
+      eventBus.emit("integration-changed");
+      res.json(data);
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to add integration" });
+    }
+  });
+  router.get("/integrations/manifests", async (_req, res) => {
+    try {
+      const data = await getManifests();
+      res.json(data);
+    } catch (err) {
+      res.status(502).json({ error: err instanceof Error ? err.message : "Failed to fetch manifests" });
+    }
+  });
+  router.post("/integrations/:id/activate", async (req, res) => {
+    try {
+      const manifestsData = await getManifests();
+      const manifest = manifestsData.manifests.find((m) => m.id === req.params.id);
+      if (!manifest) {
+        res.status(404).json({ error: `No manifest found for integration "${req.params.id}"` });
+        return;
+      }
+      const data = await activateIntegration(manifest);
+      eventBus.emit("integration-changed");
+      res.json(data);
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to activate integration" });
+    }
+  });
+  router.delete("/integrations/:id", async (req, res) => {
+    try {
+      const data = await removeIntegration(req.params.id);
+      eventBus.emit("integration-changed");
+      res.json(data);
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to remove integration" });
+    }
+  });
+  return router;
+}
+
+// src/routes/encrypt-intent.ts
+import { Router as Router6 } from "express";
+function createEncryptIntentRouter() {
+  const router = Router6();
+  router.post("/", async (req, res) => {
+    const { intent, recipients } = req.body;
+    if (typeof intent !== "string" || intent.length === 0) {
+      res.status(400).json({ error: "Missing or invalid field: intent (string)" });
+      return;
+    }
+    if (!Array.isArray(recipients) || recipients.length === 0) {
+      res.status(400).json({ error: "Missing or invalid field: recipients (non-empty array)" });
+      return;
+    }
+    const parsed = [];
+    for (const r of recipients) {
+      if (typeof r !== "object" || r === null || typeof r.userId !== "string" || typeof r.publicKey !== "string") {
+        res.status(400).json({
+          error: "Each recipient must have { userId: string; publicKey: string (base64) }"
+        });
+        return;
+      }
+      const { userId, publicKey: pubB64 } = r;
+      let pubBytes;
+      try {
+        pubBytes = new Uint8Array(Buffer.from(pubB64, "base64"));
+      } catch {
+        res.status(400).json({ error: `Invalid base64 publicKey for userId "${userId}"` });
+        return;
+      }
+      if (pubBytes.length !== 32) {
+        res.status(400).json({
+          error: `publicKey for userId "${userId}" must be 32 bytes (X25519); got ${pubBytes.length}`
+        });
+        return;
+      }
+      parsed.push({ userId, publicKey: pubBytes });
+    }
+    try {
+      const encrypted = await encryptForRecipients(intent, parsed);
+      const encryptedKeys = {};
+      for (const [userId, wrap] of Object.entries(encrypted.encryptedKeys)) {
+        encryptedKeys[userId] = {
+          ct: Buffer.from(wrap.ct).toString("base64"),
+          enc: Buffer.from(wrap.enc).toString("base64")
+        };
+      }
+      res.json({
+        intentCiphertext: Buffer.from(encrypted.intentCiphertext).toString("base64"),
+        encryptedKeys,
+        approversFrozen: parsed.map((r) => r.userId)
+      });
+    } catch (err) {
+      console.error("[Control Plane] encrypt-intent error:", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "Encryption failed" });
+    }
+  });
+  return router;
+}
+
+// src/routes/decrypt-intent.ts
+import { Router as Router7 } from "express";
+function createDecryptIntentRouter(vault2) {
+  const router = Router7();
+  router.post("/", async (req, res) => {
+    const { intentCiphertext, encryptedKey, approverId } = req.body;
+    if (typeof intentCiphertext !== "string" || intentCiphertext.length === 0) {
+      res.status(400).json({ error: "Missing or invalid field: intentCiphertext (base64 string)" });
+      return;
+    }
+    if (typeof encryptedKey !== "object" || encryptedKey === null || typeof encryptedKey.ct !== "string" || typeof encryptedKey.enc !== "string") {
+      res.status(400).json({ error: "Missing or invalid field: encryptedKey ({ ct: string; enc: string })" });
+      return;
+    }
+    if (typeof approverId !== "string" || approverId.length === 0) {
+      res.status(400).json({ error: "Missing or invalid field: approverId (string)" });
+      return;
+    }
+    try {
+      const kp = await loadOrGenerateKeyPair(vault2);
+      const { ct, enc } = encryptedKey;
+      const encrypted = {
+        intentCiphertext: new Uint8Array(Buffer.from(intentCiphertext, "base64")),
+        encryptedKeys: {
+          [approverId]: {
+            ct: new Uint8Array(Buffer.from(ct, "base64")),
+            enc: new Uint8Array(Buffer.from(enc, "base64"))
+          }
+        }
+      };
+      const intent = await decryptIntent(encrypted, approverId, kp.privateKey);
+      res.json({ intent });
+    } catch (err) {
+      console.error("[Control Plane] decrypt-intent error:", err);
+      const msg = err instanceof Error ? err.message : "Decryption failed";
+      res.status(500).json({ error: msg });
+    }
+  });
+  return router;
+}
+
+// src/routes/approved-intents.ts
+import { Router as Router8 } from "express";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var SUVEREN_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join2(homedir2(), ".suveren");
+var FILE_PATH = join2(SUVEREN_DATA_DIR, "approved-intents.enc.json");
+function readFile() {
+  if (!existsSync2(FILE_PATH)) {
+    return { version: 1, entries: {} };
+  }
+  try {
+    return JSON.parse(readFileSync2(FILE_PATH, "utf-8"));
+  } catch {
+    return { version: 1, entries: {} };
+  }
+}
+function writeFile(data) {
+  mkdirSync2(SUVEREN_DATA_DIR, { recursive: true });
+  writeFileSync2(FILE_PATH, JSON.stringify(data, null, 2), "utf-8");
+}
+function createApprovedIntentsRouter(vault2) {
+  const router = Router8();
+  router.get("/", (req, res) => {
+    try {
+      const file = readFile();
+      const result = {};
+      for (const [authorityId, blob] of Object.entries(file.entries)) {
+        try {
+          result[authorityId] = vault2.decrypt(blob);
+        } catch {
+        }
+      }
+      res.json({ intents: result });
+    } catch (err) {
+      console.error("[Control Plane] approved-intents GET error:", err);
+      res.status(500).json({ error: "Failed to read approved intents" });
+    }
+  });
+  router.post("/", (req, res) => {
+    const { authorityId, intent } = req.body;
+    if (typeof authorityId !== "string" || authorityId.length === 0) {
+      res.status(400).json({ error: "Missing or invalid field: authorityId (string)" });
+      return;
+    }
+    if (typeof intent !== "string" || intent.length === 0) {
+      res.status(400).json({ error: "Missing or invalid field: intent (string)" });
+      return;
+    }
+    try {
+      const blob = vault2.encrypt(intent);
+      const file = readFile();
+      file.entries[authorityId] = blob;
+      writeFile(file);
+      res.json({ ok: true });
+    } catch (err) {
+      console.error("[Control Plane] approved-intents POST error:", err);
+      res.status(500).json({ error: "Failed to store approved intent" });
+    }
+  });
+  return router;
+}
+
+// src/lib/update-checker.ts
+var GHCR_IMAGE = "suverenai/suveren-gateway";
+var NPM_PACKAGE = "@suveren/gateway";
+var CHECK_INTERVAL = 60 * 60 * 1e3;
+var INITIAL_DELAY = 3e4;
+var updateAvailable = false;
+var lastCheckedAt = 0;
+var installMethod = "docker";
+var runningVersion = "dev";
+var latestVersion = null;
+function getUpdateStatus() {
+  return { updateAvailable, runningSha: runningVersion, latestVersion, lastCheckedAt };
+}
+async function forceCheck() {
+  try {
+    await check();
+  } catch {
+  }
+}
+async function ghcrToken() {
+  const res = await fetch(`https://ghcr.io/token?scope=repository:${GHCR_IMAGE}:pull`);
+  const data = await res.json();
+  return data.token;
+}
+async function ghcrDigest(tag, token) {
+  const res = await fetch(`https://ghcr.io/v2/${GHCR_IMAGE}/manifests/${tag}`, {
+    method: "HEAD",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.oci.image.index.v1+json"
+    }
+  });
+  if (!res.ok) return null;
+  return res.headers.get("docker-content-digest");
+}
+async function checkDocker() {
+  const token = await ghcrToken();
+  const latestDigest = await ghcrDigest("latest", token);
+  if (!latestDigest) return;
+  const runningDigest = await ghcrDigest(runningVersion.slice(0, 7), token);
+  updateAvailable = !runningDigest || runningDigest !== latestDigest;
+  latestVersion = latestDigest.slice(0, 19);
+  lastCheckedAt = Date.now();
+}
+async function checkNpm() {
+  const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE)}/latest`);
+  if (!res.ok) return;
+  const data = await res.json();
+  latestVersion = data.version;
+  updateAvailable = compareSemver(data.version, runningVersion) > 0;
+  lastCheckedAt = Date.now();
+}
+function compareSemver(a, b) {
+  const norm = (v) => v.split("-")[0].split(".").map((n) => parseInt(n, 10) || 0);
+  const aa = norm(a);
+  const bb = norm(b);
+  for (let i = 0; i < 3; i++) {
+    const av = aa[i] ?? 0;
+    const bv = bb[i] ?? 0;
+    if (av > bv) return 1;
+    if (av < bv) return -1;
+  }
+  return 0;
+}
+async function check() {
+  try {
+    if (installMethod === "dev") {
+      updateAvailable = true;
+      lastCheckedAt = Date.now();
+      return;
+    }
+    if (installMethod === "npm") {
+      await checkNpm();
+      return;
+    }
+    await checkDocker();
+  } catch {
+  }
+}
+function startUpdateChecker(method, version) {
+  installMethod = method;
+  runningVersion = version;
+  setTimeout(() => {
+    check().catch(() => {
+    });
+    setInterval(() => check().catch(() => {
+    }), CHECK_INTERVAL);
+  }, INITIAL_DELAY);
+}
+
+// src/routes/events.ts
+var KEEPALIVE_INTERVAL_MS = 25e3;
+function createEventsHandler() {
+  return function eventsHandler(_req, res) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    const unsubscribe = eventBus.subscribe((event) => {
+      const data = JSON.stringify(event.payload ?? null);
+      res.write(`event: ${event.type}
+data: ${data}
+
+`);
+    });
+    const keepalive = setInterval(() => {
+      res.write(":ka\n\n");
+    }, KEEPALIVE_INTERVAL_MS);
+    _req.on("close", () => {
+      clearInterval(keepalive);
+      unsubscribe();
+    });
+  };
+}
+
+// src/index.ts
+(function migrateDataDir() {
+  if (process.env.SUVEREN_DATA_DIR) return;
+  const oldDir = join3(homedir3(), ".hap");
+  const newDir = join3(homedir3(), ".suveren");
+  if (!existsSync3(newDir) && existsSync3(oldDir)) {
+    try {
+      renameSync(oldDir, newDir);
+      console.error(`[Control Plane] Migrated data directory: ${oldDir} \u2192 ${newDir}`);
+    } catch (err) {
+      console.error(`[Control Plane] FATAL: could not migrate data directory ${oldDir} \u2192 ${newDir}:`, err);
+      process.exit(1);
+    }
+  }
+})();
+var SP_URL2 = process.env.SUVEREN_AS_URL ?? "https://www.suveren.ai";
+var port = parseInt(process.env.SUVEREN_CP_PORT ?? "3402", 10);
+var HAP_MODE = process.env.HAP_MODE ?? "personal";
+var UI_DIST = process.env.HAP_UI_DIST ?? join3(import.meta.dirname ?? __dirname, "../../ui/dist");
+var vault = new Vault();
+var internalSecret2 = process.env.SUVEREN_INTERNAL_SECRET ?? randomBytes2(32).toString("hex");
+setInternalSecret(internalSecret2);
+var app = express();
+var jsonParser = express.json();
+var loginAttempts = /* @__PURE__ */ new Map();
+var LOGIN_WINDOW_MS = 6e4;
+var LOGIN_MAX_ATTEMPTS = 10;
+function loginRateLimit(req, res, next) {
+  const ip = req.ip ?? req.socket.remoteAddress ?? "unknown";
+  const now = Date.now();
+  const entry = loginAttempts.get(ip);
+  if (entry && now < entry.resetAt) {
+    if (entry.count >= LOGIN_MAX_ATTEMPTS) {
+      res.status(429).json({ error: "Too many login attempts. Try again later." });
+      return;
+    }
+    entry.count++;
+  } else {
+    loginAttempts.set(ip, { count: 1, resetAt: now + LOGIN_WINDOW_MS });
+  }
+  next();
+}
+app.use("/auth", jsonParser, createAuthRouter(vault, requireAuth(vault), loginRateLimit));
+function resolveOrigin(req) {
+  const fwdHost = req.get("x-forwarded-host");
+  if (fwdHost) return `${req.protocol}://${fwdHost}`;
+  const referer = req.get("referer");
+  if (referer) {
+    try {
+      return new URL(referer).origin;
+    } catch {
+    }
+  }
+  return `${req.protocol}://${req.get("host")}`;
+}
+var oauthRedirectUris = /* @__PURE__ */ new Map();
+var manifestCache = null;
+async function getOAuthManifest(integrationId) {
+  if (!manifestCache) {
+    try {
+      const data = await getManifests();
+      manifestCache = data.manifests;
+    } catch {
+      return null;
+    }
+  }
+  return manifestCache?.find((m) => m.id === integrationId && m.oauth) ?? null;
+}
+app.get("/auth/oauth/:integrationId/start", async (req, res) => {
+  const { integrationId } = req.params;
+  const manifest = await getOAuthManifest(integrationId);
+  if (!manifest?.oauth) {
+    res.status(404).json({ error: `No OAuth config found for integration "${integrationId}"` });
+    return;
+  }
+  const creds = vault.getCredential(integrationId);
+  const oauth = manifest.oauth;
+  const clientIdKey = oauth.credentialKeys.clientId ?? "clientId";
+  const clientSecretKey = oauth.credentialKeys.clientSecret ?? "clientSecret";
+  if (!creds?.[clientIdKey] || !creds?.[clientSecretKey]) {
+    res.status(400).json({ error: `${integrationId} OAuth credentials must be configured first` });
+    return;
+  }
+  const redirectUri = `${resolveOrigin(req)}/auth/oauth/${integrationId}/callback`;
+  oauthRedirectUris.set(integrationId, redirectUri);
+  const params = new URLSearchParams({
+    client_id: creds[clientIdKey],
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: oauth.scopes.join(" "),
+    ...oauth.extraParams
+  });
+  res.redirect(`${oauth.authUrl}?${params.toString()}`);
+});
+app.get("/auth/oauth/:integrationId/callback", async (req, res) => {
+  const { integrationId } = req.params;
+  const { code, error } = req.query;
+  if (error || !code) {
+    res.status(400).send(`<html><body><h2>Authorization failed</h2><p>${String(error || "No authorization code received")}</p><script>setTimeout(()=>window.close(),3000)</script></body></html>`);
+    return;
+  }
+  const manifest = await getOAuthManifest(integrationId);
+  if (!manifest?.oauth) {
+    res.status(404).send("<html><body><h2>OAuth config not found</h2></body></html>");
+    return;
+  }
+  const creds = vault.getCredential(integrationId);
+  const oauth = manifest.oauth;
+  const clientIdKey = oauth.credentialKeys.clientId ?? "clientId";
+  const clientSecretKey = oauth.credentialKeys.clientSecret ?? "clientSecret";
+  if (!creds?.[clientIdKey] || !creds?.[clientSecretKey]) {
+    res.status(400).send("<html><body><h2>Credentials missing</h2></body></html>");
+    return;
+  }
+  const redirectUri = oauthRedirectUris.get(integrationId) ?? `${resolveOrigin(req)}/auth/oauth/${integrationId}/callback`;
+  oauthRedirectUris.delete(integrationId);
+  try {
+    const tokenRes = await fetch(oauth.tokenUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        code,
+        client_id: creds[clientIdKey],
+        client_secret: creds[clientSecretKey],
+        redirect_uri: redirectUri,
+        grant_type: "authorization_code"
+      })
+    });
+    const tokens = await tokenRes.json();
+    const tokenValue = tokens.refresh_token ?? tokens.access_token;
+    if (tokens.error || !tokenValue) {
+      res.status(400).send(`<html><body><h2>Token exchange failed</h2><p>${String(tokens.error || "No token received")}</p><script>setTimeout(()=>window.close(),3000)</script></body></html>`);
+      return;
+    }
+    const updatedCreds = { ...creds, [oauth.tokenStorage]: tokenValue };
+    vault.setCredential(integrationId, updatedCreds);
+    console.log(`[Control Plane] ${integrationId} OAuth tokens stored in vault`);
+    try {
+      await pushServiceCredentials(integrationId, updatedCreds);
+      console.log(`[Control Plane] ${integrationId} credentials pushed to MCP`);
+    } catch (err) {
+      console.error(`[Control Plane] Failed to push ${integrationId} credentials to MCP:`, err);
+    }
+    res.send(`<html><body><h2>${manifest.id} connected successfully</h2><p>You can close this window.</p><script>setTimeout(()=>window.close(),2000)</script></body></html>`);
+  } catch (err) {
+    console.error(`[Control Plane] ${integrationId} OAuth error:`, err);
+    res.status(500).send("<html><body><h2>OAuth error</h2><p>See server logs</p></body></html>");
+  }
+});
+app.get("/auth/gmail/start", (_req, res) => {
+  res.redirect("/auth/oauth/gmail/start");
+});
+app.get("/auth/gmail/callback", (req, res) => {
+  const qs = new URLSearchParams(req.query).toString();
+  res.redirect(`/auth/oauth/gmail/callback${qs ? "?" + qs : ""}`);
+});
+var authGuard = requireAuth(vault);
+app.get("/events", requireAuthQueryOrHeader(vault), createEventsHandler());
+app.use("/vault", jsonParser, authGuard, createVaultRouter(vault));
+app.use("/ai", jsonParser, authGuard, createAIRouter(vault));
+app.use("/ai-prompts", jsonParser, authGuard, createAIPromptsRouter());
+app.use("/mcp", jsonParser, authGuard, createMCPRouter());
+app.use("/api/encrypt-intent", jsonParser, authGuard, createEncryptIntentRouter());
+app.use("/api/decrypt-intent", jsonParser, authGuard, createDecryptIntentRouter(vault));
+app.use("/api/approved-intents", jsonParser, authGuard, createApprovedIntentsRouter(vault));
+app.get("/integrations/:id/discover/:field", authGuard, async (req, res) => {
+  const integrationId = req.params.id;
+  const fieldName = req.params.field;
+  try {
+    const manifestsResp = await getManifests();
+    const manifest = manifestsResp.manifests.find((m) => m.id === integrationId);
+    if (!manifest) {
+      res.status(404).json({ error: `Unknown integration "${integrationId}"` });
+      return;
+    }
+    const discovery = manifest.contextDiscovery?.[fieldName];
+    if (!discovery) {
+      res.status(404).json({ error: `No contextDiscovery declared for field "${fieldName}" on integration "${integrationId}"` });
+      return;
+    }
+    const creds = vault.getCredential(integrationId);
+    if (!creds) {
+      res.status(400).json({ error: `Integration "${integrationId}" has no credentials in the vault \u2014 complete OAuth first.` });
+      return;
+    }
+    const oauth = manifest.oauth;
+    const credField = discovery.credential ?? oauth?.tokenStorage;
+    const storedToken = credField ? creds[credField] : void 0;
+    if (!storedToken) {
+      res.status(400).json({ error: `Credential field "${credField}" not set on vault entry for "${integrationId}"` });
+      return;
+    }
+    let accessToken = storedToken;
+    if (oauth && credField === oauth.tokenStorage && oauth.tokenUrl) {
+      const clientIdKey = oauth.credentialKeys?.clientId ?? "clientId";
+      const clientSecretKey = oauth.credentialKeys?.clientSecret ?? "clientSecret";
+      const tokRes = await fetch(oauth.tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          client_id: creds[clientIdKey] ?? "",
+          client_secret: creds[clientSecretKey] ?? "",
+          refresh_token: storedToken,
+          grant_type: "refresh_token"
+        })
+      });
+      if (!tokRes.ok) {
+        const body = await tokRes.text();
+        res.status(502).json({ error: `OAuth refresh failed (${tokRes.status}): ${body}` });
+        return;
+      }
+      const data = await tokRes.json();
+      if (!data.access_token) {
+        res.status(502).json({ error: `OAuth refresh returned no access_token: ${data.error ?? "unknown"}` });
+        return;
+      }
+      accessToken = data.access_token;
+    }
+    const url = `${discovery.baseUrl.replace(/\/$/, "")}/${discovery.endpoint.replace(/^\//, "")}`;
+    const apiRes = await fetch(url, { headers: { Authorization: `Bearer ${accessToken}` } });
+    if (!apiRes.ok) {
+      const body = await apiRes.text();
+      res.status(502).json({ error: `Discovery call failed (${apiRes.status}): ${body.slice(0, 500)}` });
+      return;
+    }
+    const payload = await apiRes.json();
+    let list = payload;
+    for (const segment of discovery.responsePath.split(".").filter(Boolean)) {
+      if (list && typeof list === "object" && segment in list) {
+        list = list[segment];
+      } else {
+        list = void 0;
+        break;
+      }
+    }
+    if (!Array.isArray(list)) {
+      res.status(502).json({ error: `Discovery response did not contain an array at path "${discovery.responsePath}"` });
+      return;
+    }
+    const options = list.map((raw) => {
+      const item = raw;
+      const extras = {};
+      for (const [outKey, inKey] of Object.entries(discovery.extraFields ?? {})) {
+        extras[outKey] = item[inKey];
+      }
+      return {
+        value: item[discovery.valueField],
+        label: item[discovery.labelField],
+        ...Object.keys(extras).length > 0 ? { extras } : {}
+      };
+    });
+    res.json({ options });
+  } catch (err) {
+    console.error(`[Control Plane] discover ${integrationId}/${fieldName} failed:`, err);
+    res.status(500).json({ error: err instanceof Error ? err.message : "Discovery failed" });
+  }
+});
+app.get("/gate-content", authGuard, async (req, res) => {
+  try {
+    const path = req.query.path;
+    const data = await getGateContent(path);
+    res.json(data);
+  } catch (err) {
+    console.error("[Control Plane] Gate content retrieval error:", err);
+    res.status(500).json({ error: "Failed to fetch gate content from MCP server" });
+  }
+});
+app.post("/gate-content", jsonParser, authGuard, async (req, res) => {
+  try {
+    const { frameHash, boundsHash, contextHash, context, path, gateContent } = req.body;
+    await pushGateContent({ frameHash, boundsHash, contextHash, context, path, gateContent });
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("[Control Plane] Gate content forward error:", err);
+    res.status(500).json({ error: "Failed to forward gate content to MCP server" });
+  }
+});
+var AGENT_CONTEXT_MAX_BYTES = 16 * 1024;
+var SUVEREN_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join3(homedir3(), ".suveren");
+app.get("/agent-brief/context", authGuard, async (_req, res) => {
+  try {
+    const { readFileSync: readFileSync4, existsSync: fileExists } = await import("fs");
+    const filePath = join3(SUVEREN_DATA_DIR2, "context.md");
+    if (!fileExists(filePath)) {
+      res.json({ content: "" });
+      return;
+    }
+    const content = readFileSync4(filePath, "utf-8");
+    res.json({ content });
+  } catch (err) {
+    console.error("[Control Plane] agent-brief/context GET failed:", err);
+    res.status(500).json({ error: err instanceof Error ? err.message : "Failed to read context" });
+  }
+});
+app.put("/agent-brief/context", jsonParser, authGuard, async (req, res) => {
+  try {
+    const { content } = req.body;
+    if (typeof content !== "string") {
+      res.status(400).json({ error: 'Missing or invalid "content" string' });
+      return;
+    }
+    if (Buffer.byteLength(content, "utf-8") > AGENT_CONTEXT_MAX_BYTES) {
+      res.status(413).json({ error: `Context exceeds ${AGENT_CONTEXT_MAX_BYTES}-byte cap` });
+      return;
+    }
+    const { mkdirSync: mkdirSync3, writeFileSync: writeFileSync3, renameSync: renameSync2 } = await import("fs");
+    mkdirSync3(SUVEREN_DATA_DIR2, { recursive: true });
+    const filePath = join3(SUVEREN_DATA_DIR2, "context.md");
+    const tmpPath = `${filePath}.tmp`;
+    writeFileSync3(tmpPath, content, "utf-8");
+    renameSync2(tmpPath, filePath);
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("[Control Plane] agent-brief/context PUT failed:", err);
+    res.status(500).json({ error: err instanceof Error ? err.message : "Failed to write context" });
+  }
+});
+app.use("/api", authGuard);
+app.use(
+  createProxyMiddleware({
+    target: SP_URL2,
+    changeOrigin: true,
+    pathFilter: "/api",
+    on: {
+      proxyReq: (proxyReq) => {
+        const cookie = vault.getSpCookie();
+        if (cookie) {
+          proxyReq.setHeader("Cookie", cookie);
+        }
+      },
+      proxyRes: (proxyRes, req) => {
+        const status = proxyRes.statusCode ?? 0;
+        if (status < 200 || status >= 300) return;
+        const method = req.method?.toUpperCase();
+        const url = req.url ?? "";
+        if (method !== "POST" && method !== "DELETE") return;
+        const path = url.split("?")[0];
+        if (method === "POST" && path === "/api/as/attest") {
+          eventBus.emit("attestation-changed");
+        } else if (method === "POST" && /^\/api\/attestations\/[^/]+\/revoke$/.test(path)) {
+          eventBus.emit("attestation-changed");
+        } else if (method === "POST" && path === "/api/proposals") {
+          eventBus.emit("proposal-added");
+        } else if (method === "POST" && /^\/api\/proposals\/[^/]+\/resolve$/.test(path)) {
+          eventBus.emit("proposal-resolved");
+        } else if (method === "POST" && /^\/api\/proposals\/[^/]+\/approve$/.test(path)) {
+          eventBus.emit("proposal-approved");
+        } else if (method === "POST" && /^\/api\/proposals\/[^/]+\/reject$/.test(path)) {
+          eventBus.emit("proposal-rejected");
+        } else if (method === "POST" && (path === "/api/groups" || path === "/api/groups/join" || /^\/api\/groups\/[^/]+\/(leave|disable|reactivate|admin-transfer)$/.test(path))) {
+          eventBus.emit("team-membership-changed");
+        }
+      }
+    }
+  })
+);
+function detectInstallMethod() {
+  if (existsSync3("/.dockerenv")) return "docker";
+  const dir = import.meta.dirname ?? __dirname;
+  if (dir.includes("/node_modules/@suveren/gateway/")) return "npm";
+  return "dev";
+}
+var INSTALL_METHOD = detectInstallMethod();
+function detectRunningVersion() {
+  if (INSTALL_METHOD === "docker") {
+    return process.env.HAP_BUILD_SHA ?? "dev";
+  }
+  const dir = import.meta.dirname ?? __dirname;
+  const bundlePkg = join3(dir, "..", "..", "package.json");
+  if (existsSync3(bundlePkg)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(bundlePkg, "utf8"));
+      if (pkg.name === "@suveren/gateway" && typeof pkg.version === "string") {
+        return pkg.version;
+      }
+    } catch {
+    }
+  }
+  return process.env.HAP_BUILD_SHA ?? "dev";
+}
+var RUNNING_VERSION = detectRunningVersion();
+app.get("/health", async (req, res) => {
+  if (req.query.refresh === "1") {
+    await forceCheck();
+  }
+  const update = getUpdateStatus();
+  res.json({
+    status: "ok",
+    vaultUnlocked: vault.isUnlocked(),
+    version: RUNNING_VERSION,
+    latestVersion: update.latestVersion,
+    updateAvailable: update.updateAvailable,
+    installMethod: INSTALL_METHOD,
+    spUrl: SP_URL2,
+    security: {
+      note: "Gateway secures tool execution. Agent host isolation is the user's responsibility."
+    }
+  });
+});
+if (existsSync3(UI_DIST)) {
+  app.use(express.static(UI_DIST));
+  app.get("*", (_req, res) => {
+    res.sendFile(join3(UI_DIST, "index.html"));
+  });
+} else {
+  app.get("/", (_req, res) => {
+    res.json({
+      status: "control-plane running",
+      note: `UI not found at ${UI_DIST} \u2014 run 'pnpm build' first`
+    });
+  });
+}
+app.listen(port, "0.0.0.0", () => {
+  console.error(`[Control Plane] Listening on http://0.0.0.0:${port}`);
+  console.error(`[Control Plane]   SP proxy: ${SP_URL2}`);
+  console.error(`[Control Plane]   UI dist:  ${UI_DIST}`);
+  console.error(`[Control Plane]   Internal secret: configured`);
+  startUpdateChecker(INSTALL_METHOD, RUNNING_VERSION);
+});