@sanctuary-framework/mcp-server 1.1.4 → 1.1.6

package/dist/cli.cjs

@@ -28139,6 +28139,13 @@ var init_hub_service = __esm({
       nowIso() {
         return this.now().toISOString();
       }
+      refreshPersistedLocalAgents() {
+        const readPersistedLocalAgents2 = this.deps.readPersistedLocalAgents;
+        if (!readPersistedLocalAgents2) return;
+        for (const record of readPersistedLocalAgents2()) {
+          this.deps.agentRegistry.put(record);
+        }
+      }
       // ── Inbox ───────────────────────────────────────────────────────────
       listInbox() {
         const items = aggregateInbox(this.deps.inboxSources, this.inboxStore);
@@ -28150,6 +28157,7 @@ var init_hub_service = __esm({
       }
       // ── Agents ──────────────────────────────────────────────────────────
       listAgents(filter) {
+        this.refreshPersistedLocalAgents();
         const safeFilter = {
           ...filter ?? {},
           identity_id: this.deps.identityId
@@ -28583,12 +28591,76 @@ var init_hub = __esm({
     init_api_router();
   }
 });
+function localAgentsFilePath(storagePath) {
+  return path.join(storagePath, "state", "_hub", "local-agents.json");
+}
+function readPersistedLocalAgents(storagePath) {
+  const filePath = localAgentsFilePath(storagePath);
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.agents)) return [];
+    return parsed.agents;
+  } catch {
+    return [];
+  }
+}
+function writePersistedLocalAgents(storagePath, agents) {
+  const filePath = localAgentsFilePath(storagePath);
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  const payload = {
+    version: PERSISTED_VERSION,
+    agents
+  };
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}
+`, {
+    mode: 384
+  });
+  fs.renameSync(tmpPath, filePath);
+  fs.chmodSync(filePath, 384);
+}
+function upsertPersistedLocalAgent(storagePath, record) {
+  const existing = readPersistedLocalAgents(storagePath);
+  const idx = existing.findIndex((r) => r.agent_id === record.agent_id);
+  let next;
+  if (idx >= 0) {
+    const prior = existing[idx];
+    if (prior === void 0) {
+      next = [...existing, record];
+    } else {
+      const updated = {
+        ...record,
+        wrapped_at: prior.wrapped_at,
+        last_activity_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      next = [...existing];
+      next[idx] = updated;
+    }
+  } else {
+    next = [...existing, record];
+  }
+  writePersistedLocalAgents(storagePath, next);
+  return next;
+}
+var PERSISTED_VERSION;
+var init_agent_registry_persistence = __esm({
+  "src/hub/agent-registry-persistence.ts"() {
+    PERSISTED_VERSION = "1.1";
+  }
+});
 function buildV11Bindings(inputs) {
-  const registry = new InMemoryLocalAgentRegistry([]);
+  const seed = inputs.storagePath !== void 0 ? readPersistedLocalAgents(inputs.storagePath) : [];
+  const registry = new InMemoryLocalAgentRegistry(seed);
+  const storagePath = inputs.storagePath;
+  const readPersisted = storagePath !== void 0 ? () => readPersistedLocalAgents(storagePath) : void 0;
   const hubService = new HubService({
     identityId: inputs.identityId,
     fortressId: inputs.fortressId,
     agentRegistry: registry,
+    ...readPersisted ? { readPersistedLocalAgents: readPersisted } : {},
     inboxSources: {
       listPendingApprovals: () => [],
       listRecentBlockedEgress: () => [],
@@ -28622,6 +28694,7 @@ var init_wiring = __esm({
   "src/dashboard/v1_1/wiring.ts"() {
     init_hub();
     init_errors4();
+    init_agent_registry_persistence();
     CapabilityErrorAgentController = class {
       fail(action) {
         throw new HubCapabilityError(
@@ -30654,7 +30727,12 @@ Refusing to start the cocoon while the reset-history marker is unreadable.`
       buildV11Bindings({
         identityId: embeddedHubIdentityId,
         fortressId: fortressIdFromStoragePath(config.storage_path),
-        auditLog
+        auditLog,
+        // v1.1.5 (Finding Z): rehydrate the hub agent registry from
+        // `<storagePath>/state/_hub/local-agents.json` so the embedded
+        // dashboard surfaces wraps performed by prior `sanctuary wrap`
+        // invocations against this same fortress.
+        storagePath: config.storage_path
       })
     );
     await dashboard.start();
@@ -31297,6 +31375,7 @@ __export(cli_exports, {
   PORT_FALLBACK_ATTEMPTS: () => PORT_FALLBACK_ATTEMPTS,
   formatMcpServerCount: () => formatMcpServerCount,
   formatWrapSuccess: () => formatWrapSuccess,
+  formatWrapSuccessNoDashboard: () => formatWrapSuccessNoDashboard,
   parseCocoonArgs: () => parseCocoonArgs,
   parseWrapArgs: () => parseWrapArgs,
   promoteFortressToStoragePath: () => promoteFortressToStoragePath,
@@ -31569,6 +31648,28 @@ async function runWrap(options, deps = {}) {
     backupPath
   );
   if (!verifyOk) process.exit(1);
+  try {
+    upsertPersistedLocalAgent(
+      storagePath,
+      buildLocalAgentRecord({
+        storagePath,
+        platform: agentConfig.platform
+      })
+    );
+  } catch (err) {
+    console.error(
+      `  Note: v1.1 hub agent record not persisted (${err.message}). Re-run \`sanctuary wrap\` to retry, or check storage permissions on ${storagePath}.`
+    );
+  }
+  if (options.noDashboard) {
+    const toolName2 = toolNameFor(agentConfig.platform, agentConfig.servers);
+    printWrapSuccessNoDashboard({
+      toolName: toolName2,
+      version: readPackageVersion(),
+      toolCount: countUpstreamTools(upstreamServers),
+      serverCount: upstreamServers.length});
+    return;
+  }
   const authToken = generateAuthToken();
   const startFn = deps.startDashboard ?? ((opts) => startDashboard({
     port: opts.port,
@@ -31608,7 +31709,12 @@ async function runWrap(options, deps = {}) {
         buildV11Bindings({
           identityId: `fortress:${storagePath}`,
           fortressId: fortressIdFromStoragePath(storagePath),
-          auditLog: wrapAuditLog
+          auditLog: wrapAuditLog,
+          // v1.1.5 (Finding Z): rehydrate from the file the upsert
+          // above just wrote, so the registry the wrap-auto dashboard
+          // serves contains this wrap plus any prior wraps against the
+          // same fortress.
+          storagePath
         })
       );
       dashboard.setV11LoopbackAutoAuth(true);
@@ -31748,6 +31854,32 @@ function formatWrapSuccess(info) {
 function printWrapSuccess(info) {
   console.error(formatWrapSuccess(info));
 }
+function formatWrapSuccessNoDashboard(info) {
+  const g = (s) => `\x1B[32m${s}\x1B[0m`;
+  const d = (s) => `\x1B[2m${s}\x1B[0m`;
+  const b = (s) => `\x1B[1m${s}\x1B[0m`;
+  const check = "\u2713";
+  const lines = [];
+  lines.push("");
+  lines.push(
+    `  ${g(check)} Wrapped ${b(info.toolName)} with Sanctuary v${info.version}`
+  );
+  lines.push(
+    `  ${g(check)} ${info.toolCount} tools registered across ${info.serverCount} upstream server${info.serverCount !== 1 ? "s" : ""}`
+  );
+  lines.push(
+    `  ${d("Dashboard spawn skipped per --no-dashboard. Run `sanctuary dashboard` separately for a persistent dashboard.")}`
+  );
+  lines.push("");
+  lines.push(
+    `  ${b("Your agent is protected.")} L1 Full / L2 Degraded (no TEE) / L3 Full / L4 Full.`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function printWrapSuccessNoDashboard(info) {
+  console.error(formatWrapSuccessNoDashboard(info));
+}
 async function verifyRewrittenConfig(configPath, backupPath) {
   try {
     const raw = await promises.readFile(configPath, "utf-8");
@@ -31864,6 +31996,57 @@ function toolNameFor(platform4, _servers) {
       return "your agent";
   }
 }
+function harnessKindForPlatform(platform4) {
+  switch (platform4) {
+    case "openclaw":
+      return "openclaw";
+    case "hermes":
+      return "hermes";
+    case "claude-code":
+      return "claude_code";
+    case "cursor":
+      return "cursor";
+    case "cline":
+      return "cline";
+    case "generic":
+      return "generic_mcp";
+    default: {
+      return "other";
+    }
+  }
+}
+function buildLocalAgentRecord(input) {
+  const harness = harnessKindForPlatform(input.platform);
+  const fortressId = fortressIdFromStoragePath(input.storagePath);
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.1",
+    agent_id: `agent:${harness}:${fortressId}`,
+    identity_id: `fortress:${input.storagePath}`,
+    harness,
+    model_provider: {
+      vendor: "unknown",
+      model_id: "unknown",
+      runs_locally: false
+    },
+    policy_id: "unbound",
+    status: "active",
+    budget_summary: {
+      last_refreshed_at: nowIso
+    },
+    last_activity_at: nowIso,
+    wrapped_at: nowIso,
+    capabilities: {
+      can_pause: false,
+      can_resume: false,
+      can_restart: false,
+      can_unwrap: true,
+      can_lockdown: false,
+      can_chat: false,
+      can_change_template: false
+    }
+  };
+}
 function countUpstreamTools(servers) {
   return servers.length === 0 ? 0 : servers.length;
 }
@@ -31924,6 +32107,9 @@ function parseWrapArgs(argv) {
       case "--no-open":
         options.noOpen = true;
         break;
+      case "--no-dashboard":
+        options.noDashboard = true;
+        break;
       case "--fortress":
         options.fortress = argv[++i];
         break;
@@ -31964,6 +32150,11 @@ function printWrapHelp() {
     --port <port>      Preferred dashboard port (default: 3501)
     --dry-run          Show what would happen without making changes
     --no-open          Do not auto-open the dashboard in a browser
+    --no-dashboard     Do not spawn a per-call dashboard server. Wrap still
+                       persists the agent record so a separately-running
+                       \`sanctuary dashboard\` (or a later wrap) sees the
+                       harness. Use this for the clean operator setup
+                       (one persistent dashboard + many wraps).
     --help, -h         Show this help
 
   What happens:
@@ -31981,6 +32172,7 @@ var init_cli2 = __esm({
     init_passphrase();
     init_dashboard2();
     init_wiring();
+    init_agent_registry_persistence();
     init_filesystem();
     init_key_derivation();
     init_encoding();
@@ -35618,7 +35810,12 @@ Refusing to start the dashboard while the reset-history marker is unreadable.`
     buildV11Bindings({
       identityId: hubIdentityId,
       fortressId: fortressIdFromStoragePath(config.storage_path),
-      auditLog
+      auditLog,
+      // v1.1.5 (Finding Z): rehydrate the hub agent registry from
+      // `<storagePath>/state/_hub/local-agents.json` so the standalone
+      // dashboard surfaces wraps performed by prior `sanctuary wrap`
+      // invocations against this same fortress.
+      storagePath: config.storage_path
     })
   );
   const hostIsLoopback = dashboardHost === "127.0.0.1" || dashboardHost === "::1" || dashboardHost === "localhost";
@@ -35648,6 +35845,10 @@ Refusing to start the dashboard while the reset-history marker is unreadable.`
   console.error(`Sanctuary Dashboard v${SANCTUARY_VERSION} (standalone mode)`);
   console.error(`Storage: ${config.storage_path}`);
   console.error(`Identities loaded: ${loadResult.loaded}`);
+  const persistedAgentsCount = readPersistedLocalAgents(
+    config.storage_path
+  ).length;
+  console.error(`Local agents loaded: ${persistedAgentsCount}`);
   console.error(`Listening: http://${dashboardHost}:${dashboardPort}`);
   if (loadResult.total > 0 && loadResult.loaded === 0) {
     const service = keychainServiceFor(config.storage_path, os.homedir());
@@ -35706,6 +35907,7 @@ var init_dashboard_standalone = __esm({
     init_recovery_key_disclosure();
     init_discovery();
     init_wiring();
+    init_agent_registry_persistence();
   }
 });