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

package/scripts/wrangler-command-lifecycle.mjs

@@ -0,0 +1,115 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_COMPLETION_EXIT_GRACE_MS = 500;
+const DEFAULT_TERMINATION_GRACE_MS = 2_000;
+
+export async function runCompletedWranglerCommand(options = {}) {
+  const cwd = requiredString(options.cwd, "cwd");
+  const wranglerPath = requiredString(options.wranglerPath, "wranglerPath");
+  const args = Array.isArray(options.args) ? options.args.map(String) : [];
+  const label = requiredString(options.label, "label");
+  const completionMarker = requiredString(options.completionMarker, "completionMarker");
+  const completionCheck = typeof options.completionCheck === "function" ? options.completionCheck : () => true;
+  const timeoutMs = positiveInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, "timeoutMs");
+  const completionExitGraceMs = positiveInteger(options.completionExitGraceMs, DEFAULT_COMPLETION_EXIT_GRACE_MS, "completionExitGraceMs");
+  const terminationGraceMs = positiveInteger(options.terminationGraceMs, DEFAULT_TERMINATION_GRACE_MS, "terminationGraceMs");
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
+  const env = options.env || process.env;
+  const killChild = typeof options.killChild === "function" ? options.killChild : null;
+  const child = spawn(process.execPath, [wranglerPath, ...args], {
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  await new Promise((resolvePromise, rejectPromise) => {
+    let completionObserved = false;
+    let cleanupRequested = false;
+    let forceKillUsed = false;
+    let hardTimedOut = false;
+    let outputTail = "";
+    let completionTimer;
+    let forceTimer;
+    let settled = false;
+
+    const hardTimer = setTimeout(() => {
+      hardTimedOut = true;
+      requestTermination();
+    }, timeoutMs);
+    const clearTimers = () => {
+      clearTimeout(hardTimer);
+      clearTimeout(completionTimer);
+      clearTimeout(forceTimer);
+    };
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      if (error) rejectPromise(error);
+      else resolvePromise();
+    };
+    const requestTermination = () => {
+      if (cleanupRequested) return;
+      cleanupRequested = true;
+      try {
+        if (killChild) killChild(child, "SIGTERM");
+        else child.kill("SIGTERM");
+      }
+      catch (error) { finish(new Error(`${label} could not request graceful cleanup`, { cause: error })); return; }
+      forceTimer = setTimeout(() => {
+        if (child.exitCode !== null || child.signalCode !== null) return;
+        forceKillUsed = true;
+        try {
+          const killed = killChild ? killChild(child, "SIGKILL") : child.kill("SIGKILL");
+          if (killed !== true) finish(new Error(`${label} could not force cleanup`));
+        } catch (error) { finish(new Error(`${label} could not force cleanup`, { cause: error })); }
+      }, terminationGraceMs);
+    };
+    const observeOutput = (destination, chunk) => {
+      destination.write(chunk);
+      outputTail = `${outputTail}${String(chunk)}`.slice(-4096);
+      if (completionObserved || !outputTail.includes(completionMarker)) return;
+      completionObserved = true;
+      completionTimer = setTimeout(() => {
+        if (child.exitCode === null && child.signalCode === null) requestTermination();
+      }, completionExitGraceMs);
+    };
+    const completionIsValid = () => {
+      try { return completionCheck() === true; }
+      catch (error) { finish(error); return false; }
+    };
+
+    child.stdout.on("data", (chunk) => observeOutput(stdout, chunk));
+    child.stderr.on("data", (chunk) => observeOutput(stderr, chunk));
+    child.once("error", finish);
+    child.once("close", (code, signal) => {
+      if (hardTimedOut) { finish(new Error(`${label} timed out after ${timeoutMs}ms`)); return; }
+      if (forceKillUsed) { finish(new Error(`${label} completed but did not terminate after graceful cleanup`)); return; }
+      if (code === 0 && completionIsValid()) { finish(); return; }
+      if (cleanupRequested && completionObserved && signal === "SIGTERM" && completionIsValid()) {
+        stderr.write(`${label} completed but did not exit; terminated the completed CLI after a bounded grace period\n`);
+        finish();
+        return;
+      }
+      if (settled) return;
+      const status = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
+      finish(new Error(`${label} failed with ${status}`));
+    });
+  });
+}
+
+function requiredString(value, name) {
+  const text = String(value || "");
+  if (!text) throw new TypeError(`${name} must be a non-empty string`);
+  return text;
+}
+
+function positiveInteger(value, fallback, name) {
+  if (value === undefined) return fallback;
+  if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${name} must be a positive integer`);
+  return value;
+}

package/src/local/account-access.mjs

@@ -1,8 +1,10 @@
 import accessContract from "../shared/access-contract.json" with { type: "json" };
 import { BridgeError } from "./errors.mjs";
+import { buildAuthorityContext } from "./authority-context.mjs";
 import { policyProfile, toolNamesForPolicy, assertToolAllowed } from "./policy.mjs";
 
 export const ACCOUNT_ACCESS_REVISION = Number(accessContract.revision);
+const OWNER_ONLY_TOOLS = new Set((accessContract.ownerOnlyTools || []).map(String));
 const ACCOUNT_ROLE_ENTRIES = Object.entries(accessContract.roles)
   .map(([name, value]) => [name, Object.freeze({ ...value })]);
 const ACCOUNT_ROLE_BY_NAME = new Map(ACCOUNT_ROLE_ENTRIES);
@@ -22,16 +24,26 @@ export function accountRolePolicy(role) {
 }
 
 export function accountRoleToolNames(role) {
-  return toolNamesForPolicy(accountRolePolicy(role));
+  const normalized = normalizeAccountRole(role);
+  const names = toolNamesForPolicy(accountRolePolicy(normalized));
+  return normalized === OWNER_ACCOUNT_ROLE ? names : names.filter((name) => !OWNER_ONLY_TOOLS.has(name));
 }
 
 export class AccountAccessGate {
   assert(role, tool) {
     const normalized = normalizeAccountRole(role);
+    if (normalized !== OWNER_ACCOUNT_ROLE && OWNER_ONLY_TOOLS.has(String(tool || ""))) {
+      throw new BridgeError("authorization_denied", `tool is reserved for the owner account: ${String(tool || "")}`);
+    }
     assertToolAllowed(accountRolePolicy(normalized), tool);
     return normalized;
   }
 
+  authority(authorization, daemonPolicy, origin = "relay") {
+    const role = origin === "relay" ? normalizeAccountRole(authorization?.role) : "owner";
+    return buildAuthorityContext({ authorization: { ...authorization, role }, daemonPolicy, origin });
+  }
+
   names(role) {
     return accountRoleToolNames(role);
   }

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

@@ -0,0 +1,92 @@
+import { BridgeError } from "./errors.mjs";
+
+const MAX_ADMIN_RESPONSE_BYTES = 1024 * 1024;
+const MAX_ADMIN_ERROR_CHARS = 2_000;
+
+export function isReadOnlyAdminMethod(method) { return method === "GET" || method === "HEAD"; }
+
+export async function validateAdminResponseStatus(response, method, pathname) {
+  const expectedStatus = method === "DELETE" && pathname === "/admin/accounts" ? 204
+    : method === "POST" && pathname === "/admin/accounts" ? 201 : 200;
+  if (!response.ok || response.status === expectedStatus) return;
+  await cancelResponseBody(response.body);
+  throw adminResponseProtocolError(response, method, "account administration response used an unexpected success status");
+}
+
+export function boundedRemoteAdminMessage(payload, status) {
+  const fallback = `account administration failed (${status})`;
+  const candidate = typeof payload?.message === "string" ? payload.message : typeof payload?.error === "string" ? payload.error : fallback;
+  const normalized = candidate.replace(/[\u0000-\u001f\u007f\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g, " ").replace(/\s+/g, " ").trim();
+  return (normalized || fallback).slice(0, MAX_ADMIN_ERROR_CHARS);
+}
+
+export async function readAdminJsonResponse(response, method) {
+  const declared = Number(response.headers.get("content-length") || "0");
+  if (Number.isFinite(declared) && declared > MAX_ADMIN_RESPONSE_BYTES) {
+    await cancelResponseBody(response.body);
+    throw adminResponseProtocolError(response, method, "account administration response exceeded the size limit");
+  }
+  if (!response.body) {
+    if (response.ok) throw adminResponseProtocolError(response, method, "account administration response was empty");
+    return {};
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let bytes = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      bytes += value.byteLength;
+      if (bytes > MAX_ADMIN_RESPONSE_BYTES) {
+        await cancelReader(reader);
+        throw adminResponseProtocolError(response, method, "account administration response exceeded the size limit");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  let payload;
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(concatBytes(chunks, bytes));
+    payload = JSON.parse(text);
+  } catch (cause) {
+    if (response.ok) throw adminResponseProtocolError(response, method, "account administration response was not valid JSON", cause);
+    return {};
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    if (response.ok) throw adminResponseProtocolError(response, method, "account administration response was not a JSON object");
+    return {};
+  }
+  return payload;
+}
+
+function adminResponseProtocolError(response, method, message, cause) {
+  const mutation = response.ok && !isReadOnlyAdminMethod(method);
+  return new BridgeError("protocol_error", message, {
+    ...(cause ? { cause } : {}),
+    ...(mutation ? { retryable: false, details: { request_delivery: "sent", effect_settlement: "unknown" } } : {}),
+  });
+}
+
+async function cancelResponseBody(body) {
+  if (!body) return;
+  const reader = body.getReader();
+  try { await cancelReader(reader); } finally { reader.releaseLock(); }
+}
+
+async function cancelReader(reader) {
+  try { await reader.cancel("response size limit reached"); } catch { /* cleanup only */ }
+}
+
+function concatBytes(chunks, bytes) {
+  const output = new Uint8Array(bytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}

package/src/local/account-admin.mjs

@@ -1,6 +1,8 @@
-import { createHash, createHmac, randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { ADMIN_AUTH_SCHEME, adminAuthTranscript } from "../shared/admin-auth.mjs";
 import { ACCOUNT_ROLES, normalizeAccountRole } from "./account-access.mjs";
+import { boundedRemoteAdminMessage, isReadOnlyAdminMethod, readAdminJsonResponse, validateAdminResponseStatus } from "./account-admin-response.mjs";
+import { encodeDeviceSessionCertificate, signWithDeviceSessionIdentity, validateDeviceSessionIdentity } from "./device-identity.mjs";
 import { BridgeError } from "./errors.mjs";
 
 const REQUEST_TIMEOUT_MS = 15_000;
@@ -10,15 +12,18 @@ export function generateAccountPassword() {
 }
 
 export class AccountAdminClient {
-  constructor({ workerUrl, adminSecret, fetchImpl = fetch }) {
+  constructor({ workerUrl, sessionIdentity, fetchImpl = fetch }) {
     this.workerUrl = normalizeWorkerUrl(workerUrl);
-    if (typeof adminSecret !== "string" || adminSecret.length < 24) throw new BridgeError("invalid_request", "account administration secret is missing");
-    this.adminSecret = adminSecret;
+    this.sessionIdentity = validateDeviceSessionIdentity(sessionIdentity);
     this.fetchImpl = fetchImpl;
   }
 
-  list() {
-    return this.request("GET", "/admin/accounts");
+  list() { return this.request("GET", "/admin/accounts"); }
+  listClients() { return this.request("GET", "/admin/clients"); }
+
+  removeClient({ clientId }) {
+    if (!/^mcp_client_[A-Za-z0-9_-]{43}$/.test(String(clientId || ""))) throw new BridgeError("invalid_request", "OAuth client id is invalid");
+    return this.request("DELETE", "/admin/clients", { client_id: clientId });
   }
 
   create({ name, role, password, displayName = "" }) {
@@ -61,7 +66,7 @@ export class AccountAdminClient {
   async request(method, pathname, body) {
     const serializedBody = body === undefined ? "" : JSON.stringify(body);
     const headers = accountAdminRequestHeaders({
-      secret: this.adminSecret,
+      sessionIdentity: this.sessionIdentity,
       origin: this.workerUrl,
       method,
       pathname,
@@ -74,40 +79,68 @@ export class AccountAdminClient {
         ...(body === undefined ? {} : { "content-type": "application/json" }),
       },
       body: body === undefined ? undefined : serializedBody,
+      redirect: "error",
       signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
       cache: "no-store",
     }).catch((error) => {
-      throw new BridgeError("network_error", "account administration request failed", { cause: error, retryable: true });
+      const retryable = isReadOnlyAdminMethod(method);
+      throw new BridgeError("network_error", "account administration request failed", {
+        cause: error,
+        retryable,
+        ...(retryable ? {} : { details: { request_delivery: "unknown", effect_settlement: "unknown" } }),
+      });
     });
+    await validateAdminResponseStatus(response, method, pathname);
     if (response.status === 204) return { removed: true };
-    const payload = await response.json().catch(() => ({}));
+    const payload = await readAdminJsonResponse(response, method);
     if (!response.ok) {
-      const message = typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : `account administration failed (${response.status})`;
+      const message = boundedRemoteAdminMessage(payload, response.status);
+      if (response.status >= 500) {
+        const retryable = isReadOnlyAdminMethod(method);
+        throw new BridgeError("unavailable", message, {
+          retryable,
+          ...(retryable ? {} : { details: { request_delivery: "sent", effect_settlement: "unknown" } }),
+        });
+      }
       throw new BridgeError(response.status === 404 ? "not_found" : response.status === 409 ? "conflict" : response.status === 401 ? "authentication_failed" : "invalid_request", message);
     }
     return payload;
   }
 }
 
-
-export function accountAdminRequestHeaders({ secret, origin, method, pathname, body = "", now = Date.now(), nonce = randomBytes(24).toString("base64url") }) {
-  if (typeof secret !== "string" || secret.length < 24) throw new BridgeError("invalid_request", "account administration secret is missing");
+export function accountAdminRequestHeaders({
+  sessionIdentity,
+  origin,
+  method,
+  pathname,
+  body = "",
+  now = Date.now(),
+  nonce = randomBytes(24).toString("base64url"),
+}) {
+  validateDeviceSessionIdentity(sessionIdentity, now);
   const issuedAt = Math.floor(Number(now) / 1000);
   const bodyHash = createHash("sha256").update(String(body)).digest("hex");
-  const transcript = adminAuthTranscript({ origin, method: String(method).toUpperCase(), pathname, bodyHash, issuedAt, nonce });
-  const signature = createHmac("sha256", secret).update(transcript).digest("base64url");
+  const transcript = adminAuthTranscript({
+    origin,
+    method: String(method).toUpperCase(),
+    pathname,
+    bodyHash,
+    keyId: sessionIdentity.keyId,
+    issuedAt,
+    nonce,
+  });
   return {
     "X-Bridge-Admin-Scheme": ADMIN_AUTH_SCHEME,
     "X-Bridge-Admin-Time": String(issuedAt),
     "X-Bridge-Admin-Nonce": nonce,
     "X-Bridge-Admin-Body-SHA256": bodyHash,
-    "X-Bridge-Admin-Signature": signature,
+    "X-Bridge-Admin-Key": sessionIdentity.keyId,
+    "X-Bridge-Admin-Signature": signWithDeviceSessionIdentity(sessionIdentity, transcript),
+    "X-Bridge-Device-Certificate": encodeDeviceSessionCertificate(sessionIdentity),
   };
 }
 
-export function accountRoleNames() {
-  return Object.keys(ACCOUNT_ROLES);
-}
+export function accountRoleNames() { return Object.keys(ACCOUNT_ROLES); }
 
 function normalizeWorkerUrl(value) {
   const url = new URL(String(value || ""));

package/src/local/agent-context-projection.mjs

@@ -36,6 +36,9 @@ import { createHash } from "node:crypto";
  */
 /**
  * @typedef {object} ProjectionState
+ * @property {string} target
+ * @property {string} targetDir
+ * @property {string} scopeRoot
  * @property {string[]} configFiles
  * @property {InstructionItem | null} builtinInstructions
  * @property {InstructionItem | null} automaticProjectContext
@@ -47,18 +50,34 @@ import { createHash } from "node:crypto";
 /** @param {ProjectionState} state @param {SkillSummary[]} skills */
 export function capabilityFingerprint(state, skills) {
   return sha256(JSON.stringify({
-    configs: state.configFiles,
+    target: state.target,
+    target_dir: state.targetDir,
+    scope_root: state.scopeRoot,
+    configs: [...state.configFiles],
     instructions: [
-      state.builtinInstructions?.sha256 || "",
-      state.automaticProjectContext?.sha256 || "",
-      state.modelInstructions?.sha256 || "",
-      ...state.instructions.map((item) => item.sha256),
+      instructionFingerprintItem(state.builtinInstructions),
+      instructionFingerprintItem(state.automaticProjectContext),
+      instructionFingerprintItem(state.modelInstructions),
+      ...state.instructions.map(instructionFingerprintItem),
     ],
-    skills: skills.map((skill) => [skill.id, skill.sha256]),
-    commands: [...state.commands.values()].map((command) => [command.name, command.argv]),
+    skills: skills
+      .map((skill) => [skill.id, skill.name, skill.entrypoint, skill.sourceRoot, skill.sha256])
+      .sort((left, right) => String(left[0]).localeCompare(String(right[0]))),
+    commands: [...state.commands.values()]
+      .map((command) => [
+        command.name, command.description, command.argv, command.cwd, command.timeoutSeconds,
+        command.allowExtraArgs, command.source, command.sourceType || "", command.script || "",
+      ])
+      .sort((left, right) => String(left[0]).localeCompare(String(right[0]))),
   }));
 }
 
+/** @param {InstructionItem | null | undefined} item */
+function instructionFingerprintItem(item) {
+  if (!item) return null;
+  return [item.source || "", item.path || "", item.scope, item.sha256, item.precedence, item.bytes];
+}
+
 /** @param {SkillSummary} skill @param {DisplayPath} displayPath */
 export function publicSkill(skill, displayPath) {
   return {