@suveren/gateway 0.3.16 → 0.4.0

package/dist/control-plane/index.mjs

@@ -5,8 +5,8 @@ import {
 
 // 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 { existsSync as existsSync5, readFileSync as readFileSync4, renameSync } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir3 } from "os";
 import express from "express";
 import { createProxyMiddleware } from "http-proxy-middleware";
@@ -16,28 +16,64 @@ import { createHash, pbkdf2Sync, randomBytes, createCipheriv, createDecipheriv,
 import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
+var KDF_ITERATIONS = 1e5;
+var KDF_KEY_BYTES = 32;
+var ApiKeyUnsealProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  id = "api-key";
+  deriveKey(salt) {
+    return pbkdf2Sync(this.apiKey, salt, KDF_ITERATIONS, KDF_KEY_BYTES, "sha256");
+  }
+};
 var Vault = class {
   vaultKey = null;
   apiKeyHash = null;
   spSessionCookie = null;
+  unsealedBy = null;
   dataDir;
   constructor(dataDir) {
     this.dataDir = dataDir ?? process.env.SUVEREN_DATA_DIR ?? join(homedir(), ".suveren");
   }
   // ─── Key management ─────────────────────────────────────────────────────
-  deriveAndSetKey(apiKey) {
+  /**
+   * The vault's PBKDF2 salt, created on first unseal and stable thereafter.
+   * Every provider derives against the same salt, so swapping providers on an
+   * existing vault produces a different key — which is correct: a vault sealed
+   * by one authority is not readable by another.
+   */
+  ensureSalt() {
     const vaultData = this.readVaultFile();
-    let salt;
-    if (vaultData.salt) {
-      salt = vaultData.salt;
-    } else {
-      salt = randomBytes(32).toString("hex");
-      vaultData.salt = salt;
+    if (!vaultData.salt) {
+      vaultData.salt = randomBytes(32).toString("hex");
       this.writeVaultFile(vaultData);
     }
-    this.vaultKey = pbkdf2Sync(apiKey, Buffer.from(salt, "hex"), 1e5, 32, "sha256");
+    return Buffer.from(vaultData.salt, "hex");
+  }
+  /**
+   * Unlock the vault using any UnsealProvider. Call sites should prefer this
+   * over the API-key-specific helper below; adding an unattended provider then
+   * requires no change here.
+   */
+  async unseal(provider) {
+    this.vaultKey = await provider.deriveKey(this.ensureSalt());
+    this.unsealedBy = provider.id;
+  }
+  /**
+   * Unlock from the user's API key. Also records the key's hash so subsequent
+   * requests can be validated (see validateApiKey) — that check is specific to
+   * a user-presented secret and has no meaning for a machine provider, which is
+   * why it lives here rather than on the interface.
+   */
+  async deriveAndSetKey(apiKey) {
+    await this.unseal(new ApiKeyUnsealProvider(apiKey));
     this.apiKeyHash = createHash("sha256").update(apiKey).digest("hex");
   }
+  /** Which provider unlocked this vault, for diagnostics. Null while locked. */
+  unsealedByProvider() {
+    return this.vaultKey ? this.unsealedBy : null;
+  }
   validateApiKey(apiKey) {
     if (!this.apiKeyHash) return false;
     const hash = createHash("sha256").update(apiKey).digest("hex");
@@ -49,6 +85,7 @@ var Vault = class {
     this.vaultKey = null;
     this.apiKeyHash = null;
     this.spSessionCookie = null;
+    this.unsealedBy = null;
   }
   /**
    * Check if the vault was created by a different API key.
@@ -522,7 +559,7 @@ function createAuthRouter(vault2, logoutAuth, loginRateLimit2) {
       const setCookieHeaders = spRes.headers.getSetCookie?.() ?? [];
       const sessionCookie = setCookieHeaders.join("; ");
       vault2.setSpCookie(sessionCookie);
-      vault2.deriveAndSetKey(apiKey);
+      await vault2.deriveAndSetKey(apiKey);
       if (vault2.isVaultFromDifferentKey()) {
         if (!confirmWipe) {
           const credentialIds = vault2.listCredentials();
@@ -546,7 +583,7 @@ function createAuthRouter(vault2, logoutAuth, loginRateLimit2) {
           console.error("[Control Plane] Failed to remove integrations:", err);
         }
         vault2.wipe();
-        vault2.deriveAndSetKey(apiKey);
+        await vault2.deriveAndSetKey(apiKey);
       }
       if (sessionCookie) {
         try {
@@ -657,7 +694,13 @@ function createVaultRouter(vault2) {
   });
   router.put("/credentials/:name", async (req, res) => {
     const { name } = req.params;
-    const fields = req.body;
+    const incoming = req.body;
+    let fields = incoming;
+    try {
+      const existing = vault2.getCredential(name);
+      if (existing) fields = { ...existing, ...incoming };
+    } catch {
+    }
     vault2.setCredential(name, fields);
     try {
       await pushServiceCredentials(name, fields);
@@ -1061,6 +1104,38 @@ async function getIntentReview(config, request) {
     };
   }
 }
+async function listAIModels(config) {
+  try {
+    if (config.provider === "ollama") {
+      const res2 = await fetch(`${config.endpoint}/api/tags`, {
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res2.ok) throw new Error(`Ollama: ${res2.status}`);
+      const data = await res2.json();
+      const models2 = (data.models ?? []).map((m) => m.name).filter((n) => !!n).sort();
+      return { ok: true, models: models2 };
+    }
+    const headers = {};
+    if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+    const res = await fetch(`${config.endpoint}/models`, {
+      headers,
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) {
+      if (res.status === 401 || res.status === 403) {
+        throw new Error("Enter this provider\u2019s API key, then Refresh");
+      }
+      const text = await res.text().catch(() => "");
+      throw new Error(`AI provider: ${res.status}${text ? ` - ${text}` : ""}`);
+    }
+    const raw = await res.json();
+    const list = Array.isArray(raw) ? raw : raw.data ?? [];
+    const models = list.map((m) => m.id).filter((n) => !!n).sort();
+    return { ok: true, models };
+  } catch (err) {
+    return { ok: false, models: [], message: err instanceof Error ? err.message : "Failed to list models" };
+  }
+}
 async function testAIConnectivity(config) {
   try {
     if (config.provider === "ollama") {
@@ -1175,16 +1250,19 @@ function createAIRouter(vault2) {
   });
   router.post("/test", async (req, res) => {
     const body = req.body;
+    const stored = loadAIConfig();
     let config;
     if (body?.endpoint) {
       config = {
-        provider: body.provider || "ollama",
+        provider: body.provider || "openai-compatible",
         endpoint: body.endpoint,
         model: body.model || "",
-        apiKey: body.apiKey
+        // Fall back to the stored key only when it belongs to the SAME
+        // endpoint — so testing a different provider without its key fails
+        // honestly instead of passing on an unrelated stored key.
+        apiKey: body.apiKey || (stored && stored.endpoint === body.endpoint ? stored.apiKey : void 0)
       };
     } else {
-      const stored = loadAIConfig();
       if (!stored) {
         res.status(400).json({ ok: false, message: "No AI config stored" });
         return;
@@ -1194,6 +1272,27 @@ function createAIRouter(vault2) {
     const result = await testAIConnectivity(config);
     res.json(result);
   });
+  router.post("/models", async (req, res) => {
+    const body = req.body;
+    const stored = loadAIConfig();
+    let config;
+    if (body?.endpoint) {
+      config = {
+        provider: body.provider || "openai-compatible",
+        endpoint: body.endpoint,
+        model: body.model || "",
+        apiKey: body.apiKey || (stored && stored.endpoint === body.endpoint ? stored.apiKey : void 0)
+      };
+    } else {
+      config = stored;
+    }
+    if (!config) {
+      res.status(400).json({ ok: false, models: [], message: "AI not configured. Pick a provider first." });
+      return;
+    }
+    const result = await listAIModels(config);
+    res.json(result);
+  });
   router.get("/presets", (_req, res) => {
     res.json({ presets: PROVIDER_PRESETS });
   });
@@ -1362,11 +1461,161 @@ function createMCPRouter() {
   return router;
 }
 
-// src/routes/encrypt-intent.ts
+// src/routes/autostart.ts
 import { Router as Router6 } from "express";
+import { execFile } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as pathDirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { promisify } from "util";
+var run = promisify(execFile);
+var SUPPORTED = /* @__PURE__ */ new Set(["darwin", "win32", "linux"]);
+var MODULE_DIR = pathDirname(fileURLToPath(import.meta.url));
+function findCli(dirname3 = MODULE_DIR) {
+  const candidates = [
+    // Bundled (the shipped layout): dist/control-plane → dist → root → bin
+    resolve(dirname3, "..", "..", "bin", "suveren-gateway.js"),
+    // Bundled, were the routes/ directory ever preserved.
+    resolve(dirname3, "..", "..", "..", "bin", "suveren-gateway.js"),
+    // Dev, running from source: the repo's own bundle directory.
+    resolve(dirname3, "..", "..", "..", "..", "bundle", "bin", "suveren-gateway.js"),
+    resolve(dirname3, "..", "..", "..", "..", "..", "bundle", "bin", "suveren-gateway.js")
+    // Deliberately NO process.cwd() fallback: it makes the result depend on
+    // where the process happened to be launched from, so the same install
+    // resolves differently between a shell and a login service — and it would
+    // mask a genuinely missing CLI whenever the cwd happened to be the repo.
+  ];
+  return candidates.find(existsSync2) ?? null;
+}
+async function cli(args) {
+  const bin = findCli();
+  if (!bin) return { ok: false, output: "CLI not found" };
+  try {
+    const { stdout, stderr } = await run(process.execPath, [bin, ...args], {
+      timeout: 6e4,
+      env: process.env
+    });
+    return { ok: true, output: `${stdout}${stderr}`.trim() };
+  } catch (err) {
+    const e = err;
+    return { ok: false, output: `${e.stdout ?? ""}${e.stderr ?? ""}`.trim() || e.message || "failed" };
+  }
+}
+function safe(handler) {
+  return (req, res) => {
+    handler(req, res).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error("[Autostart] handler failed:", message);
+      if (!res.headersSent) res.status(500).json({ error: "autostart_failed", message });
+    });
+  };
+}
+function createAutostartRouter() {
+  const router = Router6();
+  router.get("/", safe(async (_req, res) => {
+    const platform = process.platform;
+    const supported = SUPPORTED.has(platform);
+    const bin = findCli();
+    if (!supported || !bin) {
+      res.json({
+        supported: false,
+        installed: false,
+        platform,
+        // Be specific about WHICH of the two reasons applies — "unavailable"
+        // with no cause is the kind of dead end that generates support mail.
+        reason: !supported ? `Autostart is not available on ${platform}.` : "Autostart needs the packaged gateway; it is unavailable when running from source."
+      });
+      return;
+    }
+    const { output } = await cli(["service", "status"]);
+    res.json({
+      supported: true,
+      installed: /Login service:\s*installed/i.test(output),
+      platform,
+      detail: output
+    });
+  }));
+  router.post("/", safe(async (_req, res) => {
+    if (!SUPPORTED.has(process.platform) || !findCli()) {
+      res.status(400).json({ error: "unsupported", message: "Autostart is not available here." });
+      return;
+    }
+    const { ok, output } = await cli(["service", "install"]);
+    if (!ok) {
+      res.status(500).json({ error: "install_failed", message: output });
+      return;
+    }
+    res.json({ ok: true, installed: true, detail: output });
+  }));
+  router.delete("/", safe(async (_req, res) => {
+    if (!SUPPORTED.has(process.platform) || !findCli()) {
+      res.status(400).json({ error: "unsupported", message: "Autostart is not available here." });
+      return;
+    }
+    const { ok, output } = await cli(["service", "uninstall"]);
+    if (!ok) {
+      res.status(500).json({ error: "uninstall_failed", message: output });
+      return;
+    }
+    res.json({ ok: true, installed: false, detail: output });
+  }));
+  return router;
+}
+
+// src/lib/desktop-notify.ts
+import { spawn } from "child_process";
+function osaQuote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function psQuote(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function buildNotifyCommand(platform, title, message) {
+  switch (platform) {
+    case "darwin":
+      return {
+        cmd: "osascript",
+        args: ["-e", `display notification ${osaQuote(message)} with title ${osaQuote(title)}`]
+      };
+    case "win32":
+      return {
+        cmd: "powershell",
+        args: [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `Add-Type -AssemblyName System.Windows.Forms; $n = New-Object System.Windows.Forms.NotifyIcon; $n.Icon = [System.Drawing.SystemIcons]::Information; $n.BalloonTipTitle = ${psQuote(title)}; $n.BalloonTipText = ${psQuote(message)}; $n.Visible = $true; $n.ShowBalloonTip(15000); Start-Sleep -Seconds 16; $n.Dispose()`
+        ]
+      };
+    case "linux":
+      return { cmd: "notify-send", args: ["--app-name=Suveren", title, message] };
+    default:
+      return null;
+  }
+}
+function lockedNotification(port2) {
+  return {
+    title: "Suveren is running but locked",
+    message: `Your agent has no authority until you unlock it. Open http://localhost:${port2} and enter your API key.`
+  };
+}
+function notify(title, message, platform = process.platform) {
+  const command = buildNotifyCommand(platform, title, message);
+  if (!command) return;
+  try {
+    const child = spawn(command.cmd, command.args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/routes/encrypt-intent.ts
+import { Router as Router7 } from "express";
 import { computeIntentDisclosureHash } from "@hap/core";
 function createEncryptIntentRouter() {
-  const router = Router6();
+  const router = Router7();
   router.post("/", async (req, res) => {
     const { intent, recipients } = req.body;
     if (typeof intent !== "string" || intent.length === 0) {
@@ -1428,9 +1677,9 @@ function createEncryptIntentRouter() {
 }
 
 // src/routes/decrypt-intent.ts
-import { Router as Router7 } from "express";
+import { Router as Router8 } from "express";
 function createDecryptIntentRouter(vault2) {
-  const router = Router7();
+  const router = Router8();
   router.post("/", async (req, res) => {
     const { intentCiphertext, encryptedKey, approverId } = req.body;
     if (typeof intentCiphertext !== "string" || intentCiphertext.length === 0) {
@@ -1469,14 +1718,14 @@ function createDecryptIntentRouter(vault2) {
 }
 
 // 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 { Router as Router9 } from "express";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, 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)) {
+  if (!existsSync3(FILE_PATH)) {
     return { version: 1, entries: {} };
   }
   try {
@@ -1490,7 +1739,7 @@ function writeFile(data) {
   writeFileSync2(FILE_PATH, JSON.stringify(data, null, 2), "utf-8");
 }
 function createApprovedIntentsRouter(vault2) {
-  const router = Router8();
+  const router = Router9();
   router.get("/", (req, res) => {
     try {
       const file = readFile();
@@ -1534,7 +1783,7 @@ function createApprovedIntentsRouter(vault2) {
 // src/lib/update-checker.ts
 import { execSync } from "child_process";
 import { dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var GHCR_IMAGE = "suverenai/suveren-gateway";
 var NPM_PACKAGE = "@suveren/gateway";
 var CHECK_INTERVAL = 60 * 60 * 1e3;
@@ -1599,7 +1848,7 @@ function compareSemver(a, b) {
   return 0;
 }
 function checkDev() {
-  const cwd = dirname2(fileURLToPath(import.meta.url));
+  const cwd = dirname2(fileURLToPath2(import.meta.url));
   try {
     execSync("git fetch origin --quiet", { cwd, stdio: "ignore", timeout: 15e3 });
     const out = execSync("git rev-list HEAD..origin/main --count", {
@@ -1667,12 +1916,35 @@ data: ${data}
   };
 }
 
+// src/lib/denials-reader.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+function loadDenials(dataDir, decrypt) {
+  const encPath = join3(dataDir, "denials.enc.json");
+  const plainPath = join3(dataDir, "denials.json");
+  if (existsSync4(encPath)) {
+    const { blob } = JSON.parse(readFileSync3(encPath, "utf-8"));
+    return JSON.parse(decrypt(blob)).records ?? [];
+  }
+  if (existsSync4(plainPath)) {
+    return JSON.parse(readFileSync3(plainPath, "utf-8")).records ?? [];
+  }
+  return [];
+}
+function selectDenials(records, opts = {}) {
+  let out = [...records].sort((a, b) => b.ts - a.ts);
+  if (opts.since !== void 0 && Number.isFinite(opts.since)) out = out.filter((r) => r.ts >= opts.since);
+  const count = out.length;
+  if (opts.limit !== void 0 && Number.isFinite(opts.limit) && opts.limit > 0) out = out.slice(0, opts.limit);
+  return { count, records: out };
+}
+
 // 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)) {
+  const oldDir = join4(homedir3(), ".hap");
+  const newDir = join4(homedir3(), ".suveren");
+  if (!existsSync5(newDir) && existsSync5(oldDir)) {
     try {
       renameSync(oldDir, newDir);
       console.error(`[Control Plane] Migrated data directory: ${oldDir} \u2192 ${newDir}`);
@@ -1685,7 +1957,7 @@ data: ${data}
 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 UI_DIST = process.env.HAP_UI_DIST ?? join4(import.meta.dirname ?? __dirname, "../../ui/dist");
 var vault = new Vault();
 var internalSecret2 = process.env.SUVEREN_INTERNAL_SECRET ?? randomBytes2(32).toString("hex");
 setInternalSecret(internalSecret2);
@@ -1919,6 +2191,7 @@ 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("/autostart", jsonParser, authGuard, createAutostartRouter());
 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));
@@ -2033,6 +2306,21 @@ app.get("/active-authorizations", authGuard, async (_req, res) => {
     res.status(500).json({ error: "Failed to fetch authorizations from MCP server" });
   }
 });
+app.get("/denials", authGuard, (req, res) => {
+  try {
+    const dataDir = process.env.SUVEREN_DATA_DIR ?? join4(homedir3(), ".suveren");
+    const all = loadDenials(dataDir, (blob) => vault.decrypt(blob));
+    const since = Number(req.query.since);
+    const limit = Number(req.query.limit);
+    res.json(selectDenials(all, {
+      since: Number.isFinite(since) ? since : void 0,
+      limit: Number.isFinite(limit) ? limit : void 0
+    }));
+  } catch (err) {
+    console.error("[Control Plane] Denial log read error:", err);
+    res.status(500).json({ error: "Could not read the denial log" });
+  }
+});
 app.post("/gate-content", jsonParser, authGuard, async (req, res) => {
   try {
     const { authorizationId, boundsHash, contextHash, context, contextLabels, path, gateContent } = req.body;
@@ -2053,16 +2341,16 @@ app.post("/resync-gates", authGuard, async (_req, res) => {
   }
 });
 var AGENT_CONTEXT_MAX_BYTES = 16 * 1024;
-var SUVEREN_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join3(homedir3(), ".suveren");
+var SUVEREN_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join4(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");
+    const { readFileSync: readFileSync5, existsSync: fileExists } = await import("fs");
+    const filePath = join4(SUVEREN_DATA_DIR2, "context.md");
     if (!fileExists(filePath)) {
       res.json({ content: "" });
       return;
     }
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     res.json({ content });
   } catch (err) {
     console.error("[Control Plane] agent-brief/context GET failed:", err);
@@ -2082,7 +2370,7 @@ app.put("/agent-brief/context", jsonParser, authGuard, async (req, res) => {
     }
     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 filePath = join4(SUVEREN_DATA_DIR2, "context.md");
     const tmpPath = `${filePath}.tmp`;
     writeFileSync3(tmpPath, content, "utf-8");
     renameSync2(tmpPath, filePath);
@@ -2134,7 +2422,7 @@ app.use(
   })
 );
 function detectInstallMethod() {
-  if (existsSync3("/.dockerenv")) return "docker";
+  if (existsSync5("/.dockerenv")) return "docker";
   const dir = import.meta.dirname ?? __dirname;
   if (dir.includes("/node_modules/@suveren/gateway/")) return "npm";
   return "dev";
@@ -2145,10 +2433,10 @@ function detectRunningVersion() {
     return process.env.HAP_BUILD_SHA ?? "dev";
   }
   const dir = import.meta.dirname ?? __dirname;
-  const bundlePkg = join3(dir, "..", "..", "package.json");
-  if (existsSync3(bundlePkg)) {
+  const bundlePkg = join4(dir, "..", "..", "package.json");
+  if (existsSync5(bundlePkg)) {
     try {
-      const pkg = JSON.parse(readFileSync3(bundlePkg, "utf8"));
+      const pkg = JSON.parse(readFileSync4(bundlePkg, "utf8"));
       if (pkg.name === "@suveren/gateway" && typeof pkg.version === "string") {
         return pkg.version;
       }
@@ -2176,7 +2464,7 @@ app.get("/health", async (req, res) => {
     }
   });
 });
-if (existsSync3(UI_DIST)) {
+if (existsSync5(UI_DIST)) {
   app.use(express.static(UI_DIST, {
     setHeaders: (res, filePath) => {
       if (filePath.endsWith("index.html")) {
@@ -2186,7 +2474,7 @@ if (existsSync3(UI_DIST)) {
   }));
   app.get("*", (_req, res) => {
     res.setHeader("Cache-Control", "no-store, must-revalidate");
-    res.sendFile(join3(UI_DIST, "index.html"));
+    res.sendFile(join4(UI_DIST, "index.html"));
   });
 } else {
   app.get("/", (_req, res) => {
@@ -2198,6 +2486,10 @@ if (existsSync3(UI_DIST)) {
 }
 app.listen(port, "0.0.0.0", () => {
   console.error(`[Control Plane] Listening on http://0.0.0.0:${port}`);
+  if (process.env.SUVEREN_AUTOSTART === "1" && !vault.isUnlocked()) {
+    const { title, message } = lockedNotification(port);
+    notify(title, message);
+  }
   console.error(`[Control Plane]   SP proxy: ${SP_URL2}`);
   console.error(`[Control Plane]   UI dist:  ${UI_DIST}`);
   console.error(`[Control Plane]   Internal secret: configured`);