machine-bridge-mcp 2.0.0 → 3.0.0-beta.9

package/src/local/authority-context.mjs

@@ -0,0 +1,106 @@
+import { BridgeError } from "./errors.mjs";
+import { intersectPolicies, normalizePolicy, policyProfile } from "./policy.mjs";
+
+const ACCOUNT_ID = /^acct_[A-Za-z0-9_-]{20,96}$/;
+const CLIENT_ID = /^mcp_client_[A-Za-z0-9_-]{43}$/;
+const FAMILY_ID = /^mcp_family_[A-Za-z0-9_-]{43}$/;
+
+export function buildAuthorityContext({ authorization = {}, daemonPolicy, origin = "local" } = {}) {
+  if (origin !== "relay") {
+    const policy = normalizePolicy(daemonPolicy || {});
+    return Object.freeze({
+      origin: "local",
+      principal: Object.freeze({ kind: "local", role: "owner" }),
+      daemonPolicy: policy,
+      accountPolicy: policy,
+      effectivePolicy: policy,
+      owner: true,
+    });
+  }
+
+  const accountId = String(authorization.account_id || "");
+  const clientId = String(authorization.client_id || "");
+  const familyId = String(authorization.family_id || "");
+  const role = String(authorization.role || "").trim().toLowerCase();
+  const accountVersion = Number(authorization.account_version);
+  if (!ACCOUNT_ID.test(accountId) || !CLIENT_ID.test(clientId) || !FAMILY_ID.test(familyId) || !Number.isSafeInteger(accountVersion) || accountVersion <= 0) {
+    throw new BridgeError("authorization_denied", "relay operation is missing authenticated principal identity");
+  }
+  const accountPolicy = policyProfile(roleProfile(role), "explicit");
+  const normalizedDaemonPolicy = normalizePolicy(daemonPolicy || {});
+  const effectivePolicy = intersectPolicies(normalizedDaemonPolicy, accountPolicy, { origin: "effective" });
+  const principal = Object.freeze({
+    kind: "account",
+    accountId,
+    accountVersion,
+    clientId,
+    familyId,
+    role,
+  });
+  return Object.freeze({
+    origin: "relay",
+    principal,
+    daemonPolicy: normalizedDaemonPolicy,
+    accountPolicy,
+    effectivePolicy,
+    owner: role === "owner",
+  });
+}
+
+export function policyForContext(context, fallbackPolicy) {
+  return normalizePolicy(context?.authority?.effectivePolicy || fallbackPolicy || {});
+}
+
+export function principalForContext(context) {
+  const principal = context?.authority?.principal;
+  if (principal?.kind === "account") return principal;
+  return Object.freeze({ kind: "local", role: "owner" });
+}
+
+export function principalBinding(context) {
+  const principal = principalForContext(context);
+  if (principal.kind !== "account") return { owner_kind: "local" };
+  return {
+    owner_kind: "account",
+    owner_account_id: principal.accountId,
+    owner_account_version: principal.accountVersion,
+    owner_client_id: principal.clientId,
+    owner_family_id: principal.familyId,
+    owner_role: principal.role,
+  };
+}
+
+export function assertOwnedByContext(record, context, label = "object") {
+  const principal = principalForContext(context);
+  if (principal.kind !== "account" || principal.role === "owner") return;
+  if (
+    record?.owner_kind !== "account"
+    || record.owner_account_id !== principal.accountId
+    || record.owner_account_version !== principal.accountVersion
+    || record.owner_client_id !== principal.clientId
+    || record.owner_family_id !== principal.familyId
+  ) {
+    throw new BridgeError("authorization_denied", `${label} belongs to another account or an obsolete account session`);
+  }
+}
+
+export function visibleToContext(record, context) {
+  try {
+    assertOwnedByContext(record, context);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function roleProfile(role) {
+  const mapping = {
+    reviewer: "review",
+    editor: "edit",
+    operator: "agent",
+    owner: "full",
+  };
+  const profile = mapping[role];
+  if (!profile) throw new BridgeError("authorization_denied", `unknown account role: ${role}`);
+  return profile;
+}

package/src/local/browser-bridge-http.mjs

@@ -1,5 +1,6 @@
 import { EXPECTED_EXTENSION_VERSION } from "./browser-extension-protocol.mjs";
-import { isAllowedLoopbackHost, pairingHtml, securityHeaders, sendJson } from "./browser-pairing-store.mjs";
+import { EXPECTED_EXTENSION_ID } from "./browser-extension-identity.mjs";
+import { isAllowedLoopbackHost, pairingHtml, securityHeaders, sendJson } from "./browser-pairing-http.mjs";
 
 export function handleBrowserBridgeHttp(request, response, {
   port,
@@ -26,6 +27,8 @@ export function handleBrowserBridgeHttp(request, response, {
       connected: extensionConnected(),
       broker: "machine-bridge-browser",
       expected_extension_version: EXPECTED_EXTENSION_VERSION,
+      expected_extension_id: EXPECTED_EXTENSION_ID,
+      extension_id: extension?.extension_id || "",
       extension_protocol: extension?.protocol || null,
       extension_version: extension?.version || "",
       extension_capabilities: extension?.capabilities || [],

package/src/local/browser-bridge.mjs

@@ -13,6 +13,7 @@ import { BrowserRequestRegistry } from "./browser-request-registry.mjs";
 import { handleBrowserBridgeHttp } from "./browser-bridge-http.mjs";
 import { BrowserBrokerRoutes } from "./browser-broker-routes.mjs";
 import { startBrowserBrokerServer } from "./browser-broker-server.mjs";
+import { EXPECTED_EXTENSION_ID } from "./browser-extension-identity.mjs";
 
 const MAX_PORT_ATTEMPTS = 10;
 const MAX_PENDING = 32;
@@ -49,13 +50,11 @@ export class BrowserBridgeManager {
       extensionStatusInfo: () => this.extensionStatusInfo(),
       extensionReloadRequired: () => this.extensionReloadRequired(),
     });
-    // Public aliases remain for diagnostics and compatibility with existing behavioral tests.
-    this.runtimeClients = this.brokerRoutes.clients;
-    this.proxyRoutes = this.brokerRoutes.routes;
     this.startPromise = null;
     this.startGeneration = 0;
     this.port = 0;
-    this.token = "";
+    this.extensionToken = "";
+    this.runtimeToken = "";
     this.extensionPath = resolve(packageRoot, "browser-extension");
     this.operationService = new BrowserOperationService({
       authorizeTool: (tool) => this.authorizeTool(tool),
@@ -67,15 +66,19 @@ export class BrowserBridgeManager {
         extensionConnected: this.extensionConnected(),
         extensionInfo: this.extensionStatusInfo(),
         extensionReloadRequired: this.extensionReloadRequired(),
+        ...this.brokerRoutes.snapshot(),
       }),
       extensionPath: this.extensionPath,
       expectedExtensionVersion: EXPECTED_EXTENSION_VERSION,
+      expectedExtensionId: EXPECTED_EXTENSION_ID,
       runProcess: (...args) => this.runProcess(...args),
       readResourceText: (name) => this.readResourceText(name),
       readResourceBinary: (name) => this.readResourceBinary(name),
     });
   }
 
+  brokerDiagnostics() { return this.brokerRoutes.snapshot(); }
+
   status(context = {}) { return this.operationService.status(context); }
 
   pair(args = {}, context = {}) { return this.operationService.pair(args, context); }
@@ -133,14 +136,15 @@ export class BrowserBridgeManager {
     try {
       const pairing = await loadOrCreatePairing(this.stateRoot);
       this.assertStartCurrent(generation);
-      this.token = pairing.token;
+      this.extensionToken = pairing.extensionToken;
+      this.runtimeToken = pairing.runtimeToken;
       for (let offset = 0; offset < MAX_PORT_ATTEMPTS; offset += 1) {
         const port = pairing.port + offset;
         try {
           await this.listen(port);
           this.assertStartCurrent(generation);
           if (port !== pairing.port && this.stateRoot) {
-            await savePairing(this.stateRoot, { token: this.token, port });
+            await savePairing(this.stateRoot, { schemaVersion: pairing.schemaVersion, extensionToken: this.extensionToken, runtimeToken: this.runtimeToken, port });
             this.assertStartCurrent(generation);
           }
           return;
@@ -176,7 +180,8 @@ export class BrowserBridgeManager {
     this.port = port;
     const { server, wss } = await startBrowserBrokerServer({
       port,
-      token: this.token,
+      extensionToken: this.extensionToken,
+      runtimeToken: this.runtimeToken,
       maxPayload: MAX_BROWSER_MESSAGE_BYTES,
       onHttp: (request, response) => this.handleHttp(request, response),
       onSocket: (socket, role) => this.acceptSocket(socket, role),
@@ -189,7 +194,7 @@ export class BrowserBridgeManager {
     const url = `ws://127.0.0.1:${port}/runtime`;
     return new Promise((resolvePromise) => {
       let settled = false;
-      const ws = new WebSocket(url, [`mbm-runtime.${this.token}`], { maxPayload: MAX_BROWSER_MESSAGE_BYTES });
+      const ws = new WebSocket(url, [`mbm-runtime.${this.runtimeToken}`], { maxPayload: MAX_BROWSER_MESSAGE_BYTES });
       const timer = setTimeout(() => finish(false), 1500);
       timer.unref?.();
       const finish = (ok) => {
@@ -372,7 +377,7 @@ export class BrowserBridgeManager {
   handleHttp(request, response) {
     return handleBrowserBridgeHttp(request, response, {
       port: this.port,
-      token: this.token,
+      token: this.extensionToken,
       extensionConnected: () => this.extensionConnected(),
       extensionStatusInfo: () => this.extensionStatusInfo(),
       extensionReloadRequired: () => this.extensionReloadRequired(),

package/src/local/browser-broker-routes.mjs

@@ -13,6 +13,10 @@ export class BrowserBrokerRoutes {
     this.routes = new Map();
   }
 
+  snapshot() {
+    return Object.freeze({ runtime_clients: this.clients.size, routed_requests: this.routes.size });
+  }
+
   acceptClient(socket) {
     this.clients.add(socket);
     socket.on("message", (data) => this.handleClientMessage(socket, data));

package/src/local/browser-broker-server.mjs

@@ -1,8 +1,9 @@
 import { createServer } from "node:http";
 import { WebSocketServer } from "ws";
-import { isAllowedExtensionOrigin, isAllowedLoopbackHost } from "./browser-pairing-store.mjs";
+import { isAllowedExtensionOrigin, isAllowedLoopbackHost } from "./browser-pairing-http.mjs";
+import { EXPECTED_EXTENSION_ID } from "./browser-extension-identity.mjs";
 
-export async function startBrowserBrokerServer({ port, token, maxPayload, onHttp, onSocket }) {
+export async function startBrowserBrokerServer({ port, extensionToken, runtimeToken, maxPayload, onHttp, onSocket }) {
   const server = createServer(onHttp);
   const wss = new WebSocketServer({ noServer: true, maxPayload });
   server.on("upgrade", (request, socket, head) => {
@@ -16,8 +17,8 @@ export async function startBrowserBrokerServer({ port, token, maxPayload, onHttp
       const protocol = String(request.headers["sec-websocket-protocol"] || "");
       const origin = String(request.headers.origin || "");
       let role = "";
-      if (url.pathname === "/extension" && protocol === `mbm.${token}` && isAllowedExtensionOrigin(origin)) role = "extension";
-      if (url.pathname === "/runtime" && protocol === `mbm-runtime.${token}` && !origin) role = "runtime";
+      if (url.pathname === "/extension" && protocol === `mbm.${extensionToken}` && isAllowedExtensionOrigin(origin, EXPECTED_EXTENSION_ID)) role = "extension";
+      if (url.pathname === "/runtime" && protocol === `mbm-runtime.${runtimeToken}` && !origin) role = "runtime";
       if (!role) {
         rejectUpgrade(socket, "401 Unauthorized");
         return;

package/src/local/browser-extension-identity.mjs

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { packageRoot } from "./state.mjs";
+
+const EXTENSION_ID_PATTERN = /^[a-p]{32}$/;
+const PUBLIC_KEY_PATTERN = /^[A-Za-z0-9+/]+={0,2}$/;
+
+const manifest = readExtensionManifest();
+export const EXPECTED_EXTENSION_PUBLIC_KEY = normalizeManifestPublicKey(manifest.key);
+export const EXPECTED_EXTENSION_ID = extensionIdFromPublicKey(EXPECTED_EXTENSION_PUBLIC_KEY);
+
+export function extensionIdFromPublicKey(value) {
+  const publicKey = normalizeManifestPublicKey(value);
+  const bytes = Buffer.from(publicKey, "base64");
+  const hexadecimal = createHash("sha256").update(bytes).digest("hex").slice(0, 32);
+  const extensionId = [...hexadecimal]
+    .map((character) => String.fromCharCode(97 + Number.parseInt(character, 16)))
+    .join("");
+  if (!EXTENSION_ID_PATTERN.test(extensionId)) throw new Error("browser extension public key produced an invalid extension id");
+  return extensionId;
+}
+
+export function normalizeExtensionId(value) {
+  const extensionId = String(value || "").trim().toLowerCase();
+  return EXTENSION_ID_PATTERN.test(extensionId) ? extensionId : "";
+}
+
+function normalizeManifestPublicKey(value) {
+  const publicKey = String(value || "").trim();
+  if (!PUBLIC_KEY_PATTERN.test(publicKey) || publicKey.length < 128 || publicKey.length > 8192) {
+    throw new Error("browser extension manifest must contain a bounded base64 public key");
+  }
+  let bytes;
+  try { bytes = Buffer.from(publicKey, "base64"); }
+  catch { throw new Error("browser extension manifest public key is invalid base64"); }
+  if (bytes.length < 96 || bytes.length > 6144 || bytes.toString("base64") !== publicKey) {
+    throw new Error("browser extension manifest public key is not canonical DER base64");
+  }
+  return publicKey;
+}
+
+function readExtensionManifest() {
+  const path = resolve(packageRoot, "browser-extension", "manifest.json");
+  const manifestValue = JSON.parse(readFileSync(path, "utf8"));
+  if (!manifestValue || typeof manifestValue !== "object" || Array.isArray(manifestValue)) {
+    throw new Error("browser extension manifest is invalid");
+  }
+  return manifestValue;
+}

package/src/local/browser-extension-protocol.mjs

@@ -3,6 +3,7 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { packageRoot } from "./state.mjs";
+import { EXPECTED_EXTENSION_ID, normalizeExtensionId } from "./browser-extension-identity.mjs";
 
 export const BROWSER_EXTENSION_PROTOCOL = 3;
 export const EXPECTED_EXTENSION_VERSION = extensionVersion();
@@ -11,13 +12,13 @@ const REQUIRED_EXTENSION_CAPABILITIES = Object.freeze([
 ]);
 export const MAX_BROWSER_MESSAGE_BYTES = 8 * 1024 * 1024;
 
-/** @typedef {{protocol: number, version: string, capabilities: string[]}} ExtensionInfo */
+/** @typedef {{protocol: number, version: string, extension_id: string, capabilities: string[]}} ExtensionInfo */
 /** @typedef {{readyState: number, close: (code?: number, reason?: string) => unknown, send: (value: string) => unknown}} ProtocolSocket */
 
 /** @param {unknown} value @returns {ExtensionInfo | null} */
 export function normalizeCompatibleExtensionInfo(value) {
   const info = normalizeExtensionInfo(value);
-  if (!info || info.protocol !== BROWSER_EXTENSION_PROTOCOL || info.version !== EXPECTED_EXTENSION_VERSION) return null;
+  if (!info || info.protocol !== BROWSER_EXTENSION_PROTOCOL || info.version !== EXPECTED_EXTENSION_VERSION || info.extension_id !== EXPECTED_EXTENSION_ID) return null;
   if (REQUIRED_EXTENSION_CAPABILITIES.some((capability) => !info.capabilities.includes(capability))) return null;
   return info;
 }
@@ -32,6 +33,9 @@ export function parseExtensionHello(message) {
   if (info.version !== EXPECTED_EXTENSION_VERSION) {
     throw new Error(`extension version mismatch; expected ${EXPECTED_EXTENSION_VERSION}; reload the extension`);
   }
+  if (info.extension_id !== EXPECTED_EXTENSION_ID) {
+    throw new Error(`extension identity mismatch; expected ${EXPECTED_EXTENSION_ID}; reload the packaged extension`);
+  }
   const missing = REQUIRED_EXTENSION_CAPABILITIES.filter((capability) => !info.capabilities.includes(capability));
   if (missing.length) throw new Error(`extension capability mismatch; reload the extension (${missing.join(",")})`);
   return info;
@@ -77,11 +81,12 @@ function normalizeExtensionInfo(value) {
   const record = /** @type {Record<string, unknown>} */ (value);
   const protocol = Number(record.protocol);
   const version = typeof record.version === "string" && record.version.length <= 100 ? record.version : "";
+  const extension_id = normalizeExtensionId(record.extension_id);
   const capabilities = Array.isArray(record.capabilities)
     ? [...new Set(record.capabilities.filter((entry) => typeof entry === "string" && /^[a-z][a-z0-9_]{0,63}$/.test(entry)))].slice(0, 32)
     : [];
-  if (!Number.isInteger(protocol) || protocol < 1 || !version) return null;
-  return { protocol, version, capabilities };
+  if (!Number.isInteger(protocol) || protocol < 1 || !version || !extension_id) return null;
+  return { protocol, version, extension_id, capabilities };
 }
 
 function extensionVersion() {

package/src/local/browser-operation-service.mjs

@@ -18,6 +18,7 @@ export class BrowserOperationService {
     bridgeStatus,
     extensionPath,
     expectedExtensionVersion,
+    expectedExtensionId,
     runProcess,
     readResourceText,
     readResourceBinary,
@@ -28,6 +29,7 @@ export class BrowserOperationService {
     this.bridgeStatus = bridgeStatus;
     this.extensionPath = extensionPath;
     this.expectedExtensionVersion = expectedExtensionVersion;
+    this.expectedExtensionId = expectedExtensionId;
     this.runProcess = runProcess;
     this.readResourceText = readResourceText;
     this.readResourceBinary = readResourceBinary;
@@ -42,10 +44,14 @@ export class BrowserOperationService {
       available: true,
       connected: bridge.extensionConnected,
       broker_role: bridge.brokerRole,
+      runtime_clients: Number(bridge.runtime_clients) || 0,
+      routed_requests: Number(bridge.routed_requests) || 0,
       endpoint: `ws://127.0.0.1:${bridge.port}/extension`,
       pairing_url: `http://127.0.0.1:${bridge.port}/pair`,
       extension_path: this.extensionPath,
       expected_extension_version: this.expectedExtensionVersion,
+      expected_extension_id: this.expectedExtensionId,
+      extension_id: extension?.extension_id || "",
       extension_protocol: extension?.protocol || null,
       extension_version: extension?.version || "",
       extension_capabilities: extension?.capabilities || [],
@@ -70,6 +76,7 @@ export class BrowserOperationService {
       security: {
         loopback_only: true,
         bearer_pairing_token: true,
+        pinned_extension_identity: true,
         arbitrary_extension_code_from_mcp: false,
         resource_values_returned_to_model: false,
       },

package/src/local/browser-pairing-http.mjs

@@ -0,0 +1,36 @@
+import { EXPECTED_EXTENSION_ID, normalizeExtensionId } from "./browser-extension-identity.mjs";
+import { EXPECTED_EXTENSION_VERSION } from "./browser-extension-protocol.mjs";
+
+export function pairingHtml(port, extensionToken) {
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="machine-bridge-browser-pair" content="1"><meta name="machine-bridge-browser-port" content="${port}"><meta name="machine-bridge-browser-token" content="${extensionToken}"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Machine Bridge browser pairing</title></head><body><h1>Machine Bridge browser pairing</h1><p>Expected extension build: <strong>${EXPECTED_EXTENSION_VERSION}</strong>.</p><p>Expected extension ID: <code>${EXPECTED_EXTENSION_ID}</code>.</p><p>Reload the unpacked extension after every Machine Bridge upgrade.</p><p>The installed extension reads pairing material from this loopback-only page and stores it in browser-local extension storage. It is not sent to any website.</p><p id="status">Waiting for the Machine Bridge extension.</p></body></html>`;
+}
+
+export function isAllowedExtensionOrigin(origin, expectedExtensionId = EXPECTED_EXTENSION_ID) {
+  const expected = normalizeExtensionId(expectedExtensionId);
+  if (!expected) return false;
+  let parsed;
+  try { parsed = new URL(String(origin || "")); } catch { return false; }
+  return parsed.protocol === "chrome-extension:" && parsed.hostname === expected
+    && !parsed.username && !parsed.password && !parsed.port
+    && (parsed.pathname === "" || parsed.pathname === "/") && !parsed.search && !parsed.hash;
+}
+
+export function isAllowedLoopbackHost(host, port) {
+  const normalized = String(host || "").toLowerCase();
+  return normalized === `127.0.0.1:${port}` || normalized === `localhost:${port}` || normalized === `[::1]:${port}`;
+}
+
+export function securityHeaders(contentType) {
+  return {
+    "content-type": contentType,
+    "cache-control": "no-store",
+    "content-security-policy": "default-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'",
+    "x-content-type-options": "nosniff",
+    "referrer-policy": "no-referrer",
+  };
+}
+
+export function sendJson(response, value) {
+  response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
+  response.end(`${JSON.stringify(value)}\n`);
+}

package/src/local/browser-pairing-store.mjs

@@ -3,80 +3,89 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { createExclusiveFileSync, replaceFileAtomicallySync } from "./exclusive-file.mjs";
 import { readBoundedRegularFileSync } from "./secure-file.mjs";
-import { assertStateMaintenanceAvailable, ensureOwnerOnlyDir, ownerOnlyFile } from "./state.mjs";
-import { EXPECTED_EXTENSION_VERSION } from "./browser-extension-protocol.mjs";
+import { acquireMaintenanceLock, assertStateMaintenanceAvailable, ensureOwnerOnlyDir, ownerOnlyFile } from "./state.mjs";
+import { createMonotonicDeadline } from "./monotonic-deadline.mjs";
 
 const DEFAULT_BROWSER_PORT = 39393;
 const PAIRING_FILE = "browser-bridge.json";
+const PAIRING_SCHEMA_VERSION = 2;
+const TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,100}$/;
 
 export async function loadOrCreatePairing(stateRoot) {
-  if (!stateRoot) return { token: randomBytes(32).toString("base64url"), port: DEFAULT_BROWSER_PORT };
-  assertStateMaintenanceAvailable(stateRoot);
+  if (!stateRoot) return newPairing(DEFAULT_BROWSER_PORT);
   ensureOwnerOnlyDir(stateRoot);
   const file = join(stateRoot, PAIRING_FILE);
+  if (existsSync(file)) {
+    const current = readPairing(file);
+    if (!current.legacy) { assertStateMaintenanceAvailable(stateRoot); return current.value; }
+    return migrateLegacyPairing(stateRoot, file);
+  }
+  assertStateMaintenanceAvailable(stateRoot);
   for (let attempt = 0; attempt < 2; attempt += 1) {
-    if (existsSync(file)) {
-      ownerOnlyFile(file);
-      let parsed;
-      try { parsed = JSON.parse(readBoundedRegularFileSync(file, 64 * 1024).toString("utf8")); }
-      catch { throw new Error("browser pairing state is not valid bounded JSON"); }
-      if (!/^[A-Za-z0-9_-]{32,100}$/.test(parsed.token) || !Number.isInteger(parsed.port) || parsed.port < 1024 || parsed.port > 65535) {
-        throw new Error("browser pairing state is invalid");
-      }
-      return parsed;
-    }
-    const value = { token: randomBytes(32).toString("base64url"), port: DEFAULT_BROWSER_PORT };
+    const value = newPairing(DEFAULT_BROWSER_PORT);
     try {
-      createExclusiveFileSync(file, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+      createExclusiveFileSync(file, pairingJson(value), { mode: 0o600 });
       ownerOnlyFile(file);
       return value;
     } catch (error) {
       if (error?.code !== "EEXIST") throw error;
+      const created = readPairing(file);
+      if (!created.legacy) return created.value;
     }
   }
-  throw new Error("browser pairing state could not be initialized");
+  return migrateLegacyPairing(stateRoot, file);
 }
 
 export async function savePairing(stateRoot, value) {
   assertStateMaintenanceAvailable(stateRoot);
+  const normalized = normalizePairing(value);
   const file = join(stateRoot, PAIRING_FILE);
-  replaceFileAtomicallySync(file, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  replaceFileAtomicallySync(file, pairingJson(normalized), { mode: 0o600 });
   ownerOnlyFile(file);
 }
 
-export function pairingHtml(port, token) {
-  return `<!doctype html><html><head><meta charset="utf-8"><meta name="machine-bridge-browser-pair" content="1"><meta name="machine-bridge-browser-port" content="${port}"><meta name="machine-bridge-browser-token" content="${token}"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Machine Bridge browser pairing</title></head><body><h1>Machine Bridge browser pairing</h1><p>Expected extension build: <strong>${EXPECTED_EXTENSION_VERSION}</strong>. Reload the unpacked extension after every Machine Bridge upgrade.</p><p>The installed extension reads pairing material from this loopback-only page and stores it in browser-local extension storage. It is not sent to any website.</p><p id="status">Waiting for the Machine Bridge extension.</p></body></html>`;
-}
-
-export function isAllowedExtensionOrigin(origin) {
-  let parsed;
-  try { parsed = new URL(String(origin || "")); } catch { return false; }
-  return parsed.protocol === "chrome-extension:"
-    && /^[a-p]{32}$/.test(parsed.hostname)
-    && !parsed.username
-    && !parsed.password
-    && !parsed.port
-    && (parsed.pathname === "" || parsed.pathname === "/")
-    && !parsed.search
-    && !parsed.hash;
+async function migrateLegacyPairing(stateRoot, file) {
+  const lock = await acquirePairingMigrationLock(stateRoot);
+  try {
+    const current = readPairing(file);
+    if (!current.legacy) return current.value;
+    const value = { schemaVersion: PAIRING_SCHEMA_VERSION, extensionToken: current.value.extensionToken, runtimeToken: token(), port: current.value.port };
+    replaceFileAtomicallySync(file, pairingJson(value), { mode: 0o600 });
+    ownerOnlyFile(file);
+    return value;
+  } finally { lock.release(); }
 }
 
-export function isAllowedLoopbackHost(host, port) {
-  const normalized = String(host || "").toLowerCase();
-  return normalized === `127.0.0.1:${port}` || normalized === `localhost:${port}` || normalized === `[::1]:${port}`;
+async function acquirePairingMigrationLock(stateRoot) {
+  const deadline = createMonotonicDeadline(5_000);
+  do {
+    const lock = acquireMaintenanceLock(stateRoot, { operation: "browser-pairing-migration" });
+    if (lock.acquired) return lock;
+    await new Promise((resolvePromise) => { setTimeout(resolvePromise, Math.min(50, Math.max(1, deadline.remainingMs()))); });
+  } while (!deadline.expired());
+  throw new Error("browser pairing migration could not acquire the state maintenance lock");
 }
 
-export function securityHeaders(contentType) {
-  return {
-    "content-type": contentType,
-    "cache-control": "no-store",
-    "content-security-policy": "default-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'",
-    "x-content-type-options": "nosniff",
-    "referrer-policy": "no-referrer",
-  };
+function readPairing(file) {
+  ownerOnlyFile(file);
+  let parsed;
+  try { parsed = JSON.parse(readBoundedRegularFileSync(file, 64 * 1024).toString("utf8")); }
+  catch { throw new Error("browser pairing state is not valid bounded JSON"); }
+  if (parsed?.schemaVersion === PAIRING_SCHEMA_VERSION) return { legacy: false, value: normalizePairing(parsed) };
+  if (TOKEN_PATTERN.test(String(parsed?.token || "")) && validPort(parsed?.port)) {
+    return { legacy: true, value: { extensionToken: parsed.token, port: Number(parsed.port) } };
+  }
+  throw new Error("browser pairing state is invalid");
 }
 
-export function sendJson(response, value) {
-  response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
-  response.end(`${JSON.stringify(value)}\n`);
+function normalizePairing(value) {
+  if (value?.schemaVersion !== PAIRING_SCHEMA_VERSION || !TOKEN_PATTERN.test(String(value.extensionToken || ""))
+      || !TOKEN_PATTERN.test(String(value.runtimeToken || "")) || value.extensionToken === value.runtimeToken || !validPort(value.port)) {
+    throw new Error("browser pairing state is invalid");
+  }
+  return { schemaVersion: PAIRING_SCHEMA_VERSION, extensionToken: String(value.extensionToken), runtimeToken: String(value.runtimeToken), port: Number(value.port) };
 }
+function newPairing(port) { return { schemaVersion: PAIRING_SCHEMA_VERSION, extensionToken: token(), runtimeToken: token(), port }; }
+function token() { return randomBytes(32).toString("base64url"); }
+function validPort(value) { return Number.isInteger(Number(value)) && Number(value) >= 1024 && Number(value) <= 65535; }
+function pairingJson(value) { return `${JSON.stringify(value, null, 2)}\n`; }

package/src/local/cli-account-admin.mjs

@@ -1,5 +1,8 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { AccountAdminClient, accountRoleNames, generateAccountPassword } from "./account-admin.mjs";
-import { loadState } from "./state.mjs";
+import { createDeviceSessionForRoot } from "./device-root-provider.mjs";
+import { loadState, packageRoot } from "./state.mjs";
 
 export function createAccountCommand({ chooseWorkspace, confirm }) {
   if (typeof chooseWorkspace !== "function" || typeof confirm !== "function") {
@@ -8,7 +11,7 @@ export function createAccountCommand({ chooseWorkspace, confirm }) {
   return async function accountCommand(args) {
     const workspace = await chooseWorkspace({ ...args, _: [] }, { promptOnFirstRun: false, save: false, allowPositional: false });
     const state = loadState(workspace, { stateDir: args.stateDir });
-    const client = accountAdminClient(state);
+    const client = await accountAdminClient(state);
     const action = String(args._[0] || "list").toLowerCase();
     const result = await performAccountAction({ action, args, client, confirm });
     if (result === null) return;
@@ -17,15 +20,36 @@ export function createAccountCommand({ chooseWorkspace, confirm }) {
   };
 }
 
-export function accountAdminClient(state) {
-  if (!state.worker?.url || !state.worker?.accountAdminSecret) {
+export async function accountAdminClient(state, sessionIdentity = null) {
+  if (!state.worker?.url || !state.worker?.deviceIdentity) {
     throw new Error("account administration requires a deployed Worker; run machine-mcp first");
   }
-  return new AccountAdminClient({ workerUrl: state.worker.url, adminSecret: state.worker.accountAdminSecret });
+  const identity = sessionIdentity || await createDeviceSessionForRoot(
+    state.worker.deviceIdentity,
+    state.worker.url,
+    "machine-bridge-mcp",
+    currentPackageVersion(),
+    { profileDir: state.paths.profileDir, reason: "Authorize Machine Bridge account administration" },
+  );
+  return new AccountAdminClient({ workerUrl: state.worker.url, sessionIdentity: identity });
+}
+
+function currentPackageVersion() {
+  return String(JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8")).version);
 }
 
 async function performAccountAction({ action, args, client, confirm }) {
   if (action === "list") return client.list();
+  if (action === "clients") return client.listClients();
+  if (action === "revoke-client") {
+    const clientId = String(args._[1] || "");
+    if (!clientId) throw new Error("account revoke-client requires CLIENT_ID");
+    if (!args.yes && !(await confirm(`Revoke OAuth client ${clientId}?`, false))) {
+      console.log("Client revocation cancelled.");
+      return null;
+    }
+    return client.removeClient({ clientId });
+  }
   if (action === "add") {
     const name = args._[1];
     const role = args._[2];
@@ -56,10 +80,20 @@ async function performAccountAction({ action, args, client, confirm }) {
     }
     return client.remove({ accountId: account.account_id });
   }
-  throw new Error("Unknown account action. Use list, add, role, enable, disable, rotate-password, or remove.");
+  throw new Error("Unknown account action. Use list, clients, revoke-client, add, role, enable, disable, rotate-password, or remove.");
 }
 
 function printAccountResult(action, result) {
+  if (action === "clients") {
+    if (!result.clients.length) {
+      console.log("No OAuth clients configured.");
+      return;
+    }
+    for (const client of result.clients) {
+      console.log(`${client.client_name}\t${client.trusted_role || "untrusted"}\t${client.client_id}\taccess=${client.active_access_tokens} refresh=${client.active_refresh_tokens}`);
+    }
+    return;
+  }
   if (action === "list") {
     if (!result.accounts.length) {
       console.log("No accounts configured.");
@@ -75,5 +109,5 @@ function printAccountResult(action, result) {
     process.stdout.write(`Password: ${result.password}\n`);
     console.log("Save this password now; it is not stored locally or shown again. Do not share this terminal output.");
   }
-  if (result.removed) console.log("Account removed.");
+  if (result.removed) console.log(action === "revoke-client" ? "OAuth client revoked." : "Account removed.");
 }