glasspane-mcp 1.4.0 → 1.5.0

package/dist/dispatch.d.ts

@@ -26,7 +26,7 @@ export declare const MCP_PROTOCOL_VERSION: "2025-06-18";
 export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly string[];
 export declare const SERVER_INFO: {
     readonly name: "glasspane-mcp";
-    readonly version: "1.4.0";
+    readonly version: "1.5.0";
 };
 export declare const PARSE_ERROR = -32700;
 export declare const INVALID_REQUEST = -32600;

package/dist/http-gateway-cli.js

@@ -1300,6 +1300,10 @@ function sortKeys(value) {
   return value;
 }
 
+// src/update-state.ts
+var CA_ROOTS_STATUSES = ["ok", "probe-failed", "empty", "unavailable", "write-unverified"];
+var KNOWN_CA_ROOTS_STATUSES = new Set(CA_ROOTS_STATUSES);
+
 // src/project-registry.ts
 import fs2 from "node:fs";
 import os2 from "node:os";

package/dist/http-gateway.js

@@ -1290,6 +1290,10 @@ function sortKeys(value) {
   return value;
 }
 
+// src/update-state.ts
+var CA_ROOTS_STATUSES = ["ok", "probe-failed", "empty", "unavailable", "write-unverified"];
+var KNOWN_CA_ROOTS_STATUSES = new Set(CA_ROOTS_STATUSES);
+
 // src/project-registry.ts
 import fs2 from "node:fs";
 import os from "node:os";

package/dist/index.js

@@ -304,6 +304,69 @@ var KNOWN_STATUSES = /* @__PURE__ */ new Set([
   "disabled",
   "installer-pointer-stale"
 ]);
+var CA_ROOTS_STATUSES = ["ok", "probe-failed", "empty", "unavailable", "write-unverified"];
+var KNOWN_CA_ROOTS_STATUSES = new Set(CA_ROOTS_STATUSES);
+function isCaRootsStatus(value) {
+  return KNOWN_CA_ROOTS_STATUSES.has(value);
+}
+var CA_BUNDLE_FILE_NAME = "ca-roots.pem";
+function decodeCaRoots(value, bundlePath) {
+  if (value === void 0 || value === null) {
+    return { ok: true, ca: { recorded: false, bundlePath } };
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return {
+      ok: false,
+      reason: `caRoots is ${Array.isArray(value) ? "an array" : typeof value} instead of the object the exporter writes`
+    };
+  }
+  const record = value;
+  const rawStatus = record.status;
+  if (typeof rawStatus !== "string" || !isCaRootsStatus(rawStatus)) {
+    return {
+      ok: false,
+      reason: `caRoots.status ${JSON.stringify(rawStatus ?? null)} is not one of ${CA_ROOTS_STATUSES.join(", ")}`
+    };
+  }
+  const rawCerts = record.certs;
+  let certs = null;
+  if (typeof rawCerts === "number") {
+    if (!Number.isInteger(rawCerts) || rawCerts < 0) {
+      return { ok: false, reason: `caRoots.certs ${JSON.stringify(rawCerts)} is not a certificate count` };
+    }
+    certs = rawCerts;
+  } else if (rawCerts !== void 0 && rawCerts !== null) {
+    return { ok: false, reason: `caRoots.certs is ${typeof rawCerts} instead of a count or null` };
+  }
+  if (rawStatus === "ok" && (certs === null || certs < 1)) {
+    return {
+      ok: false,
+      reason: `caRoots.status says ok but it records ${JSON.stringify(rawCerts ?? null)} certificates`
+    };
+  }
+  const rawPath = record.path;
+  let recordedPath = null;
+  if (typeof rawPath === "string") {
+    if (rawPath.trim() === "") {
+      return { ok: false, reason: "caRoots.path is blank, so the bundle it points at cannot be named" };
+    }
+    recordedPath = rawPath;
+  } else if (rawPath !== void 0 && rawPath !== null) {
+    return { ok: false, reason: `caRoots.path is ${typeof rawPath} instead of a path or null` };
+  }
+  return {
+    ok: true,
+    ca: {
+      recorded: true,
+      status: rawStatus,
+      certs,
+      exportedAt: typeof record.exportedAt === "string" ? record.exportedAt : null,
+      detail: typeof record.detail === "string" && record.detail.trim() !== "" ? record.detail : null,
+      bundlePath,
+      recordedPath
+    }
+  };
+}
 function readUpdateState(env = process.env, stateRootOverride) {
   const stateFile = updateStateFile(env, stateRootOverride);
   if (stateFile === null) {
@@ -348,6 +411,14 @@ function readUpdateState(env = process.env, stateRootOverride) {
       summary: `update state: ${stateFile} carries status ${JSON.stringify(parsed.status ?? null)}, which is not a status this shell knows; the updater and this shell disagree about the contract, so freshness is unknown`
     };
   }
+  const ca = decodeCaRoots(parsed.caRoots, path.join(path.dirname(stateFile), CA_BUNDLE_FILE_NAME));
+  if (!ca.ok) {
+    return {
+      kind: "unreadable",
+      stateFile,
+      summary: `update state: ${stateFile} carries a CA trust bundle record this shell cannot read (${ca.reason}); whether this install can reach the release endpoint at all is unknown, so nothing below it is trusted either \u2014 re-run the installer or \`node updater/cli.js enable\` to write the record again`
+    };
+  }
   const bits = [
     `status=${status}`,
     `current=${String(parsed.current ?? "unknown")}`,
@@ -363,7 +434,7 @@ function readUpdateState(env = process.env, stateRootOverride) {
   if (staged && typeof staged.version === "string") {
     bits.push(`staged=${staged.version}${staged.digest ? ` (${String(staged.digest).slice(0, 12)}\u2026)` : ""}`);
   }
-  return { kind: "read", stateFile, summary: `update state: ${bits.join("; ")}` };
+  return { kind: "read", stateFile, summary: `update state: ${bits.join("; ")}`, ca: ca.ca };
 }
 
 // src/io.ts
@@ -2838,7 +2909,12 @@ async function runValidatedTool(spec, value, engine, session, turn) {
     }
     const content = [{ type: "text", text: canonicalJson(raw) }];
     if (spec.name === "gp_diagnose") {
-      content.push({ type: "text", text: readUpdateState().summary });
+      const reading = readUpdateState();
+      content.push({
+        type: "text",
+        text: reading.kind === "read" ? `${reading.summary}
+${caBundleDiagnosis(reading.ca)}` : reading.summary
+      });
     }
     return {
       content,
@@ -2865,6 +2941,43 @@ async function runValidatedTool(spec, value, engine, session, turn) {
     };
   }
 }
+function caBundleDiagnosis(ca) {
+  const enableCmd = "`node updater/cli.js enable`";
+  if (!ca.recorded) {
+    return `ca trust bundle: this install has never recorded exporting the machine's trusted roots (the state file carries no caRoots), which is NOT the same as "the bundle is fine" \u2014 an install predating the export step looks exactly like this. node then verifies only against the CA list inside its own binary, so on a machine whose HTTPS is re-signed locally every auto-update run fails certificate verification and nothing on the surface says so. Remedy: re-run the GlassPane installer, or ${enableCmd}, either of which writes the roots to ${ca.bundlePath} and points the launchd agent and the panel at it. For a check run by hand in a terminal: export NODE_EXTRA_CA_CERTS=${ca.bundlePath} \u2014 but only once that file exists, and set before node starts, because a running process never picks the variable up.`;
+  }
+  const target = ca.recordedPath ?? ca.bundlePath;
+  const countClause = ca.certs === null ? "an unrecorded number of certificates" : `${ca.certs} certificates`;
+  let diagnosis;
+  switch (ca.status) {
+    case "ok":
+      diagnosis = `ca trust bundle: ok \u2014 node will use this exported root bundle (${countClause} at ${target}) for the updater's HTTPS, so a locally re-signed certificate chain on this machine does not stop a check. Nothing to do; the bundle is refreshed by the installer, by ${enableCmd}, and after every successful apply.`;
+      break;
+    case "probe-failed":
+      diagnosis = `ca trust bundle: probe-failed \u2014 ${countClause} were written to ${target}, and reaching the release endpoint through them still failed. This is the machine-still-intercepted case: the exported bundle does not contain the root that re-signs this network's TLS, so the scheduled updater is dead on every run exactly as it was before the bundle existed. Remedy: get that root into the System keychain (/Library/Keychains/System.keychain), then refresh the export with ${enableCmd} or a re-run of the installer. Pointing NODE_EXTRA_CA_CERTS at ${target} changes nothing while the signing root is missing.`;
+      break;
+    case "empty": {
+      const kept = ca.recordedPath !== null;
+      diagnosis = `ca trust bundle: empty \u2014 "security find-certificate" ran and produced ${countClause}, so this export published nothing new` + (kept ? `; the bundle already at ${target} was kept and is still what the agent and the panel hand to node, so a check can pass today while this machine's current roots go unrecorded.` : `; nothing is at ${target} either, so on a machine whose HTTPS is re-signed locally every check fails certificate verification from here.`) + ` Remedy: check that both keychains are readable (\`security dump-keychain\` lists them), then re-run the GlassPane installer or ${enableCmd} to export again.`;
+      break;
+    }
+    case "unavailable":
+      diagnosis = `ca trust bundle: unavailable \u2014 the \`security\` tool was not found on this host, so this machine's trusted roots could not be read and no bundle was written or refreshed at ${target}. Unless something else already put a bundle there, the updater carries only node's built-in list, so on a re-signing network it cannot reach a release at all. Remedy: place a root bundle you trust at a path of your choosing and give that same path to both consumers \u2014 \`export NODE_EXTRA_CA_CERTS=<that path>\` for runs from this terminal, the launchd environment for the scheduled one \u2014 then re-run the GlassPane installer so the agent and the panel record it.`;
+      break;
+    case "write-unverified":
+      diagnosis = `ca trust bundle: write-unverified \u2014 the bytes read back from ${target} were not the bytes the exporter wrote, and the export counted ${countClause}, so whatever sits at that path is not the bundle this install believes in. Verification can fail at any point, including after a partial write. Remedy: re-run the GlassPane installer or ${enableCmd}, which exports again and reads the file back; if it repeats, ${target} sits on a volume that will not hold a private regular file, and auto-update must stay off until that is fixed.`;
+      break;
+    default: {
+      const unhandled = ca.status;
+      diagnosis = `ca trust bundle: the state file records ${JSON.stringify(unhandled)}, a state this shell has no sentence for; treat the CA trust bundle as unverified and re-run the GlassPane installer`;
+    }
+  }
+  const provenance = [
+    ca.exportedAt === null ? null : `exported ${ca.exportedAt}`,
+    ca.detail === null ? null : `recorded reason: ${ca.detail}`
+  ].filter((part) => part !== null);
+  return provenance.length === 0 ? diagnosis : `${diagnosis} The record itself says: ${provenance.join("; ")}.`;
+}
 var EvidenceFrameShapeError = class extends Error {
   constructor(detail) {
     super(`engine returned a last_evidence frame without an evidencePack object: ${detail}`);
@@ -3325,7 +3438,7 @@ var SUPPORTED_PROTOCOL_VERSIONS = [
   "2025-03-26",
   MCP_PROTOCOL_VERSION
 ];
-var SERVER_INFO = { name: "glasspane-mcp", version: "1.4.0" };
+var SERVER_INFO = { name: "glasspane-mcp", version: "1.5.0" };
 var PARSE_ERROR = -32700;
 var INVALID_REQUEST = -32600;
 var METHOD_NOT_FOUND = -32601;

package/dist/update-state.d.ts

@@ -11,11 +11,46 @@ export declare const STATE_DIR_ENV = "GLASSPANE_STATE_DIR";
 export declare function recordHome(): string | null;
 /** Where `update-state.json` lives for this process, or null when it cannot be named. */
 export declare function updateStateFile(env?: NodeJS.ProcessEnv, stateRootOverride?: string): string | null;
-export interface UpdateStateReading {
-    kind: "read" | "absent" | "unreadable" | "unresolvable";
+export type UpdateStateReading = {
+    kind: "read";
+    stateFile: string;
+    summary: string;
+    /** Decoded `caRoots`, present exactly when the file was read and understood. */
+    ca: CaRootsReading;
+} | {
+    kind: "absent" | "unreadable" | "unresolvable";
     stateFile: string | null;
     summary: string;
-}
+};
+/**
+ * The five states the exporter can record for the machine's root bundle, as a closed
+ * set: `ok` (a non-empty bundle landed and a probe through it reached the release
+ * endpoint), `probe-failed` (bundle landed, endpoint still unreachable with it),
+ * `empty` (the keychain dump produced no certificates), `unavailable` (no keychain
+ * tool on this host), `write-unverified` (the file read back different from what was
+ * written). Only `ok` means usable; the other four each fail in their own way, so
+ * collapsing any of them into `ok` hands an agent a false all-clear.
+ */
+export declare const CA_ROOTS_STATUSES: readonly ["ok", "probe-failed", "empty", "unavailable", "write-unverified"];
+export type CaRootsStatus = (typeof CA_ROOTS_STATUSES)[number];
+/** Name the exporter gives the bundle inside the state root; used to name it when the record does not. */
+export declare const CA_BUNDLE_FILE_NAME = "ca-roots.pem";
+export type CaRootsReading = {
+    recorded: true;
+    status: CaRootsStatus;
+    /** Certificate count as recorded; `null` only for the non-`ok` states, which may not have one. */
+    certs: number | null;
+    exportedAt: string | null;
+    /** The exporter's own reason text, when it wrote one. */
+    detail: string | null;
+    /** Where this state root's bundle lives, resolved the same way the state file was. */
+    bundlePath: string;
+    /** The path the exporter recorded, when it recorded one. */
+    recordedPath: string | null;
+} | {
+    recorded: false;
+    bundlePath: string;
+};
 /**
  * Read and render. Never throws: `gp_diagnose` answers about an operation, and a
  * missing or broken update file is a fact about the machine, not a reason to fail

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glasspane-mcp",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "GlassPane MCP stdio shell: JSON-RPC 2.0 over stdio bridging an AI agent to the glasspane engine daemon",
   "type": "module",
   "main": "./dist/index.js",