machine-bridge-mcp 1.0.8 → 1.1.1

package/docs/TESTING.md

@@ -24,6 +24,8 @@ The suite includes:
 - foreground takeover of active and orphaned background daemons with current service-lock metadata, foreground-process protection, bounded final lock-handoff retry, actual-PID exit waiting, POSIX non-escalating timeout behavior, Windows verified-daemon stop semantics, daemon lock mode/version/process-start metadata, launchd service-target semantics, and silent idempotent duplicate service starts; daemon fixture subprocesses intentionally do not inherit V8 coverage because their purpose is ownership timing rather than code measurement;
 - fail-closed service lifecycle ordering for provider-stop, all-workspace daemon-stop, and definition removal, including platform/daemon/removal failure injection and normalized macOS/systemd/Windows results;
 - machine-level browser-broker ownership/client proxying, authenticated extension origin/subprotocol, non-cacheable local pairing, pairing-token non-disclosure, resource-backed upload routing, broker result redaction, pre-registered runtime-handshake listeners, bounded socket/HTTP waits, frozen-wall-clock browser deadline coverage, installed-application discovery caching, and name-based task matching;
+- Worker health direct/proxy routing through a real local HTTP CONNECT proxy, `NO_PROXY` bypass, exact `workers.dev` origin/name validation, redirect rejection, body/deadline bounds, error classification, bounded propagation retry, and invalid proxy fail-fast behavior without endpoint or credential disclosure;
+- Worker deployment ambiguity/idempotency: a successful Wrangler result followed by health timeout persists the fingerprint, a second start performs no upload, definitive stale-version evidence redeploys under the same name, accidental name changes are rejected, forced replacements clear current endpoint state, and prior names remain in uninstall inventory;
 - relay environment-proxy direct/bypass/agent selection, unsupported proxy rejection, fail-fast invalid configuration, and route observability without endpoint or credential disclosure;
 - canonical path and symbolic-link escape tests;
 - relative-path privacy and error-path redaction tests;
@@ -53,7 +55,7 @@ The suite includes:
 - deterministic property tests over hostile browser-protocol byte strings, canonical/custom policy combinations, argv bounds/NULs, and a real direct process proving shell metacharacters remain literal argv;
 - CLI parsing, policy profiles, and client configuration boundaries;
 - live stdio MCP initialization with session instructions, capability resolution, discovery, calls, rich content, sessions, cancellation, managed-job acceptance, and a detached job/finally phase that survives stdio shutdown;
-- live local Worker OAuth registration, consent, URL-constructed `303` callbacks including the ChatGPT redirect URI and encoded state, PKCE, token replay rejection, throttling, exact built-in ChatGPT/Grok browser origins, additive custom origins, unrelated-origin preflight rejection, no CORS response sharing for unrelated or opaque origins, opaque-origin authorization-form routing, exact per-request redirect-origin CSP, accessible credential-error rendering, protocol negotiation, HMAC-bound MCP session issuance, two-session same-id concurrency, sessionless same-id independence, session-scoped cancellation isolation, same-session duplicate rejection, daemon-backed session bootstrap, dynamic tool advertisement, rich content, daemon replacement, cancellation, malformed daemon JSON/non-object rejection, duplicate hello rejection, and unknown-message closure. The same integration runs an `editor` account against a canonical `full` daemon and proves that `server_info` and remote `project_overview` report effective `edit` authority while retaining the full daemon ceiling only in explicitly scoped fields.
+- live local Worker OAuth registration, the unauthenticated `resource_metadata` challenge, protected-resource and authorization-server discovery, Streamable transport metadata, consent, URL-constructed `303` callbacks including the ChatGPT and hosted Claude redirect URIs with encoded state, PKCE, `offline_access`, form-encoded authorization-code and refresh-token exchanges, access/refresh rotation, stale refresh replay rejection, account-version refresh revocation, authorization-code replay rejection, pending-registration throttling that excludes already authorized DCR clients, exact built-in ChatGPT/Grok browser origins, additive custom origins, unrelated-origin preflight rejection, no CORS response sharing for unrelated or opaque origins, opaque-origin authorization-form routing, exact per-request redirect-origin CSP, accessible credential-error rendering, protocol negotiation, HMAC-bound MCP session issuance, two-session same-id concurrency, sessionless same-id independence, session-scoped cancellation isolation, same-session duplicate rejection, daemon-backed session bootstrap, dynamic tool advertisement, rich content, daemon replacement, cancellation, malformed daemon JSON/non-object rejection, duplicate hello rejection, and unknown-message closure. The metadata/refresh contract is the path used by Claude DCR and Copilot Studio Dynamic discovery. The same integration runs an `editor` account against a canonical `full` daemon and proves that `server_info` and remote `project_overview` report effective `edit` authority while retaining the full daemon ceiling only in explicitly scoped fields.
 - local runtime proof that one blocked tool handler does not serialize an independent handler, plus relay fault injection proving an undeliverable terminal result interrupts the ambiguous socket and enters reconnect backoff.
 - a real headless-Chrome OAuth navigation regression with a negative control showing that `form-action 'self'` blocks a cross-origin `303`, followed by the production policy shape proving the exact callback origin receives `code` and `state`. Linux CI fails if Chrome is unavailable; other environments skip only this browser executable check while retaining the Worker CSP assertions.
 
@@ -74,7 +76,7 @@ For deterministic release validation, perform an isolated-profile smoke test wit
 
 `npm run coverage:test` runs selected in-process and lightweight entrypoint fixtures under V8 coverage and enforces per-module baselines for policy, typed errors, call registration, execution middleware, lifecycle/observability, logging, Runtime/CLI orchestration, and Worker pending/policy/error modules. The full stdio and Worker OAuth/MCP integrations run separately in the main suite and are not duplicated inside coverage collection. The gate deliberately reports each module rather than one aggregate percentage. JavaScript modules enforce function and branch minima; Node's direct TypeScript stripping does not expose trustworthy branch ranges, so TypeScript modules enforce function coverage plus explicit state-machine tests and the real workerd integration suite.
 
-The current CLI entrypoint remains the weakest covered orchestration surface; its baseline is therefore reported and locked independently, while extracted `cli-options`, `cli-policy`, `records`, and `state-inventory` modules carry substantially higher thresholds. The state-inventory extraction raised the CLI branch floor from 5% to 10%; a refactor may raise a threshold, but must not lower one merely to make CI green without an explicit audit explanation.
+The current CLI entrypoint remains the weakest covered orchestration surface; its baseline is therefore reported and locked independently, while extracted `cli-options`, `cli-policy`, `records`, `state-inventory`, `network-proxy`, `worker-health`, and `worker-deployment` modules carry substantially higher thresholds. The Worker convergence extraction and expanded command fixtures raised the CLI function floor from 40% to 45% and branch floor from 10% to 20%; a refactor may raise a threshold, but must not lower one merely to make CI green without an explicit audit explanation.
 
 ## Additional release checks
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machine-bridge-mcp",
-  "version": "1.0.8",
+  "version": "1.1.1",
   "description": "Cross-client MCP bridge for local agent context, structured browser and application automation, files, Git, processes, resources, and durable jobs over stdio or OAuth relay.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "worker:types": "node scripts/generate-worker-types.mjs",
     "typecheck": "npm run worker:types && tsc -p tsconfig.json --noEmit",
     "syntax": "node scripts/syntax-check.mjs",
-    "check": "npm run privacy:check && npm run privacy:test && npm run release-impact:check && npm run release-impact:test && npm run release-state:test && npm run release-ci:test && npm run network-retry:test && npm run relay:test && npm run secure-file:test && npm run worker-secret-file:test && npm run sarif-security:test && npm run security-properties:test && npm run shell:test && npm run architecture:test && npm run markdown:test && npm run project-metadata:test && npm run numbers:test && npm run records:test && npm run state-inventory:test && npm run commit-message:test && npm run policy:test && npm run account:test && npm run policy-docs:check && npm run tool-docs:check && npm run runtime-infrastructure:test && npm run runtime-handlers:test && npm run cli-entrypoint:test && npm run lifecycle:test && npm run logging-structure:test && npm run coverage:test && npm run worker-runtime-infrastructure:test && npm run lint:test && npm run lint && npm run typecheck && npm run syntax && npm run deadline:test && npm run process-lock:test && npm run service-lifecycle:test && npm run service-platform:test && npm run catalog:test && npm run agent-context:test && npm run capability-ranking:test && npm run browser-command:test && npm run browser-devtools-input:test && npm run browser-service-worker:test && npm run browser-page-automation:test && npm run browser-bridge:test && npm run app-automation:test && npm run self-test && npm run atomic-fs:test && npm run package:test && npm run install:test && npm run ssh-key:test && npm run full-access:test && npm run managed-jobs:test && npm run stdio:integration-test && npm run worker:integration-test && npm run oauth-browser:test",
+    "check": "npm run privacy:check && npm run privacy:test && npm run release-impact:check && npm run release-impact:test && npm run release-state:test && npm run release-ci:test && npm run network-retry:test && npm run worker-deployment:test && npm run relay:test && npm run secure-file:test && npm run worker-secret-file:test && npm run sarif-security:test && npm run security-properties:test && npm run shell:test && npm run architecture:test && npm run markdown:test && npm run project-metadata:test && npm run numbers:test && npm run records:test && npm run state-inventory:test && npm run commit-message:test && npm run policy:test && npm run account:test && npm run policy-docs:check && npm run tool-docs:check && npm run runtime-infrastructure:test && npm run runtime-handlers:test && npm run cli-entrypoint:test && npm run lifecycle:test && npm run logging-structure:test && npm run coverage:test && npm run worker-runtime-infrastructure:test && npm run lint:test && npm run lint && npm run typecheck && npm run syntax && npm run deadline:test && npm run process-lock:test && npm run service-lifecycle:test && npm run service-platform:test && npm run catalog:test && npm run agent-context:test && npm run capability-ranking:test && npm run browser-command:test && npm run browser-devtools-input:test && npm run browser-service-worker:test && npm run browser-page-automation:test && npm run browser-bridge:test && npm run app-automation:test && npm run self-test && npm run atomic-fs:test && npm run package:test && npm run install:test && npm run ssh-key:test && npm run full-access:test && npm run managed-jobs:test && npm run stdio:integration-test && npm run worker:integration-test && npm run oauth-browser:test",
     "worker:dry-run": "wrangler deploy --dry-run",
     "worker:integration-test": "node tests/worker-integration-test.mjs",
     "release:check": "node scripts/github-release.mjs --check",
@@ -107,7 +107,8 @@
     "lint:test": "node tests/lint-gate-test.mjs",
     "shell:test": "node tests/shell-test.mjs",
     "deadline:test": "node tests/monotonic-deadline-test.mjs",
-    "oauth-browser:test": "node tests/oauth-browser-navigation-test.mjs"
+    "oauth-browser:test": "node tests/oauth-browser-navigation-test.mjs",
+    "worker-deployment:test": "node tests/worker-deployment-test.mjs"
   },
   "dependencies": {
     "https-proxy-agent": "9.1.0",

package/scripts/coverage-check.mjs

@@ -18,6 +18,7 @@ const tests = [
   "tests/records-test.mjs",
   "tests/project-metadata-test.mjs",
   "tests/state-inventory-test.mjs",
+  "tests/worker-deployment-test.mjs",
 ];
 
 try {
@@ -45,13 +46,16 @@ try {
     "src/local/process-tracker.mjs": [65, 35],
     "src/local/log.mjs": [60, 40],
     "src/local/runtime.mjs": [60, 35],
-    "src/local/cli.mjs": [40, 10],
+    "src/local/cli.mjs": [45, 20],
     "src/local/cli-options.mjs": [65, 35],
     "src/local/cli-policy.mjs": [70, 35],
     "src/local/numbers.mjs": [100, 100],
     "src/local/records.mjs": [100, 100],
     "src/local/project-metadata.mjs": [85, 55],
-    "src/local/state-inventory.mjs": [80, 50],
+    "src/local/state-inventory.mjs": [85, 55],
+    "src/local/network-proxy.mjs": [90, 65],
+    "src/local/worker-health.mjs": [85, 60],
+    "src/local/worker-deployment.mjs": [80, 55],
     "src/worker/pending-calls.ts": [85, null],
     "src/worker/policy.ts": [90, null],
     "src/worker/errors.ts": [100, null],

package/src/local/cli-options.mjs

@@ -22,7 +22,7 @@ const COMMAND_OPTIONS = {
   status: new Set(["workspace", "stateDir"]),
   doctor: new Set(["workspace", "stateDir"]),
   "full-test": new Set(["workspace", "stateDir", "json"]),
-  "rotate-secrets": new Set(["workspace", "stateDir", "workerName", "quiet"]),
+  "rotate-secrets": new Set(["workspace", "stateDir", "quiet"]),
   workspace: new Set(["workspace", "stateDir"]),
   service: new Set(["workspace", "stateDir", "quiet"]),
   autostart: new Set(["workspace", "stateDir", "quiet"]),

package/src/local/cli.mjs

@@ -1,6 +1,5 @@
-import { createHmac } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import path, { join, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { LocalRuntime } from "./runtime.mjs";
@@ -19,12 +18,13 @@ import { classifyOperationalError, createLogger, sanitizeLogText } from "./log.m
 import { runExecutable, runWrangler } from "./shell.mjs";
 import { runFullAccessTest } from "./full-access-test.mjs";
 import { stopAndRemoveAutostart } from "./service-lifecycle.mjs";
+import { ensureWorkerDeployment } from "./worker-deployment.mjs";
+import { workerHealth } from "./worker-health.mjs";
+export { workerHealthUserReason } from "./worker-health.mjs";
 import { activeStateJobs, activeStateLocks, knownProfileStates, knownWorkerNames } from "./state-inventory.mjs";
-import { withWorkerSecretsFile } from "./worker-secret-file.mjs";
 import {
   acquireMaintenanceLock,
   acquireStartupLockWithWait,
-  appName,
   daemonLockPathForState,
   defaultFirstRunWorkspace,
   defaultStateRoot,
@@ -225,7 +225,7 @@ function reportExistingDaemon(args, state, owner, logger) {
   logger.plain(`  Workspace: ${state.workspace.path}`);
 }
 
-function isIdempotentDaemonOnlyStart(args) {
+export function isIdempotentDaemonOnlyStart(args) {
   if (!args.daemonOnly || args.json) return false;
   return !Boolean(
     args.profile
@@ -258,7 +258,11 @@ async function startRemoteRuntime({ args, workspace, state, daemonLock, logger }
 
 async function prepareRemoteState({ args, workspace, state, logger }) {
   const workerName = validateWorkerName(args.workerName);
-  ensureWorkerSecrets(state, { rotateSecrets: Boolean(args.rotateSecrets), workerName });
+  ensureWorkerSecrets(state, {
+    rotateSecrets: Boolean(args.rotateSecrets),
+    workerName,
+    allowWorkerRename: Boolean(args.forceWorker),
+  });
   state.policy = resolvePolicy(args, state.policy);
   state.policy.updatedAt = new Date().toISOString();
   saveState(state);
@@ -366,146 +370,9 @@ async function clientConfigCommand(args) {
 
 async function ensureWorker(state, args) {
   const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "worker" });
-  const desiredHash = workerDeploymentFingerprint(state);
-  const expectedVersion = currentPackageVersion();
-  const complete = state.worker.url && state.worker.mcpServerUrl && state.worker.accountAdminSecret && state.worker.daemonSecret && state.worker.oauthTokenVersion && state.worker.name;
-  if (!args.forceWorker && !args.rotateSecrets && complete && state.worker.deployHash === desiredHash) {
-    const health = await workerHealth(state.worker.url, expectedVersion);
-    if (health.ok) {
-      logger.success("Worker unchanged and healthy", { url: state.worker.url });
-      return state.worker;
-    }
-    logger.warn("Worker is not healthy at the expected version; redeploying automatically", { reason: workerHealthUserReason(health.error) });
-    logger.debug("Worker health check detail", { health_error: health.error });
-  }
-
-  logger.info("Checking Cloudflare Wrangler login");
-  const whoami = await runWrangler(["whoami"], { capture: true, allowFailure: true });
-  if (whoami.code !== 0) {
-    logger.info("Wrangler is not logged in; opening Cloudflare login");
-    await runWrangler(["login"]);
-  }
-
-  logger.info("Deploying Cloudflare Worker", { name: state.worker.name });
-  const deploy = await withWorkerSecretsFile(state, secretFile => runWrangler([
-    "deploy",
-    "--name", state.worker.name,
-    "--minify",
-    "--keep-vars",
-    "--secrets-file", secretFile,
-  ], { capture: true }));
-
-  const workerUrl = extractWorkerUrl(deploy.stdout) || extractWorkerUrl(deploy.stderr) || state.worker.url;
-  if (!workerUrl) throw new Error("Worker deployed but URL could not be detected. Re-run with --worker-name or inspect Wrangler output.");
-  state.worker.url = workerUrl.replace(/\/+$/, "");
-  state.worker.mcpServerUrl = `${state.worker.url}/mcp`;
-  delete state.worker.deployHash;
-  state.worker.updatedAt = new Date().toISOString();
-  saveState(state);
-
-  const health = await retryHealth(state.worker.url, expectedVersion, 8);
-  if (!health.ok) {
-    throw new Error(`Worker deployment did not become healthy at the expected version: ${health.error}`);
-  }
-  state.worker.deployHash = desiredHash;
-  saveState(state);
-  logger.success("Worker ready", { url: state.worker.url, version: health.version });
-  return state.worker;
-}
-
-
-function workerDeploymentFingerprint(state) {
-  const keyMaterial = [
-    String(state.worker.accountAdminSecret || ""),
-    String(state.worker.daemonSecret || ""),
-    String(state.worker.oauthTokenVersion || ""),
-  ].join("\0");
-  const fingerprint = createHmac("sha256", keyMaterial);
-  fingerprint.update("mbm-worker-deploy-v3");
-  fingerprint.update(String(state.worker.name || ""));
-  for (const file of workerDeployHashFiles()) {
-    fingerprint.update(path.relative(packageRoot, file));
-    fingerprint.update(workerHashContent(file));
-  }
-  return fingerprint.digest("hex");
-}
-
-function workerHashContent(file) {
-  return readFileSync(file, "utf8");
-}
-
-function workerDeployHashFiles() {
-  const files = [];
-  for (const item of ["src/worker", "src/shared", "wrangler.jsonc", "tsconfig.json"]) {
-    collectHashFiles(resolve(packageRoot, item), files);
-  }
-  return files.sort();
+  return ensureWorkerDeployment(state, args, { logger });
 }
 
-function collectHashFiles(target, out) {
-  if (!existsSync(target)) return;
-  const info = statSync(target);
-  if (info.isFile()) {
-    if (/\.(ts|js|mjs|json|jsonc|yaml|yml|lock)$/.test(target)) out.push(target);
-    return;
-  }
-  if (!info.isDirectory()) return;
-  for (const entry of readdirSync(target, { withFileTypes: true })) {
-    if (entry.name === "node_modules" || entry.name === ".wrangler" || entry.name.endsWith(".d.ts")) continue;
-    collectHashFiles(resolve(target, entry.name), out);
-  }
-}
-
-async function workerHealth(workerUrl, expectedVersion = currentPackageVersion()) {
-  if (!workerUrl) return { ok: false, error: "missing_worker_url" };
-  try {
-    const response = await fetch(`${String(workerUrl).replace(/\/+$/, "")}/healthz`, { signal: AbortSignal.timeout(5000) });
-    if (!response.ok) return { ok: false, error: `HTTP ${response.status}` };
-    const body = await response.json().catch(() => null);
-    if (body?.ok !== true || body?.server !== appName) return { ok: false, error: "unexpected_health_response" };
-    if (body?.version !== expectedVersion) return { ok: false, error: `version_mismatch:${body?.version || "unknown"}!=${expectedVersion}` };
-    return { ok: true, version: body.version };
-  } catch (error) {
-    return { ok: false, error: workerHealthError(error) };
-  }
-}
-
-export function workerHealthUserReason(value) {
-  const reason = String(value || "");
-  if (reason.startsWith("version_mismatch:")) return "deployed version does not match the local package";
-  if (/^HTTP \d+$/.test(reason)) return "health endpoint returned an HTTP error";
-  if (reason === "unexpected_health_response") return "health endpoint returned an unexpected response";
-  if (reason === "timeout") return "health check timed out";
-  if (reason === "tls_error") return "TLS validation failed";
-  if (reason === "network_error") return "network request failed";
-  if (reason === "missing_worker_url") return "Worker URL is missing";
-  return "health check failed";
-}
-
-function workerHealthError(error) {
-  const message = String(error?.message || error || "");
-  if (/timeout|aborted/i.test(message)) return "timeout";
-  if (/certificate|TLS|SSL/i.test(message)) return "tls_error";
-  if (/fetch failed|network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) return "network_error";
-  return "request_failed";
-}
-
-async function retryHealth(workerUrl, expectedVersion, attempts) {
-  let last = { ok: false, error: "not_checked" };
-  for (let i = 0; i < attempts; i += 1) {
-    last = await workerHealth(workerUrl, expectedVersion);
-    if (last.ok) return last;
-    await sleep(1000 + i * 500);
-  }
-  return last;
-}
-
-function extractWorkerUrl(text = "") {
-  const matches = [...String(text).matchAll(/https:\/\/[^\s"'<>]+\.workers\.dev[^\s"'<>]*/g)];
-  if (matches.length) return matches.at(-1)[0].replace(/[),.]+$/, "");
-  const anyHttps = [...String(text).matchAll(/https:\/\/[^\s"'<>]+/g)];
-  return anyHttps.find(match => /workers\.dev|\/healthz|\/mcp/.test(match[0]))?.[0]?.replace(/[),.]+$/, "") || "";
-}
 
 function printStartJson(state, { requestedChangesApplied = true, notice = "", initialOwner = null } = {}) {
   createLogger({ component: "ready" }).json({
@@ -566,7 +433,7 @@ async function statusCommand(args) {
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
   state.policy = resolvePolicy({}, state.policy);
-  const health = state.worker?.url ? await workerHealth(state.worker.url) : { ok: false, error: "no worker url" };
+  const health = state.worker?.url ? await workerHealth(state.worker.url, currentPackageVersion(), { expectedWorkerName: state.worker.name }) : { ok: false, error: "no worker url" };
   const payload = {
     ...redactState(state),
     workerHealth: health,
@@ -597,7 +464,7 @@ async function doctorCommand(args) {
       checks.push({ name: "full-policy-contract", ok: false, detail: sanitizeLines(error?.message || error) });
     }
   }
-  const health = state.worker?.url ? await workerHealth(state.worker.url) : { ok: false, error: "no worker url" };
+  const health = state.worker?.url ? await workerHealth(state.worker.url, currentPackageVersion(), { expectedWorkerName: state.worker.name }) : { ok: false, error: "no worker url" };
   checks.push({ name: "worker-health", ok: health.ok, detail: health.ok ? state.worker.url : health.error });
   const diagnosticRuntime = new LocalRuntime({
     workspace,
@@ -656,7 +523,7 @@ async function rotateSecretsCommand(args) {
     if (daemonIdentity?.current) {
       throw new Error(`refusing to rotate secrets while the daemon is active (pid ${daemonOwner.pid}); stop the foreground daemon and retry`);
     }
-    ensureWorkerSecrets(state, { rotateSecrets: true, workerName: validateWorkerName(args.workerName) });
+    ensureWorkerSecrets(state, { rotateSecrets: true });
     saveState(state);
     console.log("Rotated account administration, daemon, and global token-version secrets.");
     console.log("All account access tokens are invalid. Run machine-mcp to redeploy, then reconnect clients.");
@@ -963,8 +830,8 @@ Commands:
 
 Start options:
   --workspace PATH      Use and remember this workspace path
-  --worker-name NAME    Worker name (default: mbm-<workspace-hash>)
-  --force-worker        Force wrangler deploy even if hash and health match
+  --worker-name NAME    Worker name (default: mbm-<workspace-hash>); changing an existing name requires --force-worker
+  --force-worker        Force same-name deployment, or explicitly allow an intentional --worker-name replacement
   --rotate-secrets      Rotate secrets before deploying
   --daemon-only         Skip deploy and only connect daemon from existing state
   --no-autostart        Do not install login autostart during start

package/src/local/network-proxy.mjs

@@ -1,21 +1,39 @@
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { getProxyForUrl } from "proxy-from-env";
 
+const HTTP_PROTOCOLS = new Set(["http:", "https:"]);
+
 export function proxyAgentForWebSocket(webSocketUrl, proxyResolver = getProxyForUrl) {
   const target = new URL(String(webSocketUrl));
   if (target.protocol !== "ws:" && target.protocol !== "wss:") throw new Error("relay WebSocket URL must use ws or wss");
-  const proxyLookupUrl = new URL(target);
-  proxyLookupUrl.protocol = target.protocol === "wss:" ? "https:" : "http:";
-  const proxyValue = String(proxyResolver(proxyLookupUrl.href) || "").trim();
+  const lookupUrl = new URL(target);
+  lookupUrl.protocol = target.protocol === "wss:" ? "https:" : "http:";
+  return proxyAgentForLookup(lookupUrl, proxyResolver, {
+    errorCode: "relay_proxy_configuration",
+    subject: "relay proxy",
+  });
+}
+
+export function proxyAgentForHttp(httpUrl, proxyResolver = getProxyForUrl) {
+  const target = new URL(String(httpUrl));
+  if (!HTTP_PROTOCOLS.has(target.protocol)) throw new Error("HTTP request URL must use http or https");
+  return proxyAgentForLookup(target, proxyResolver, {
+    errorCode: "http_proxy_configuration",
+    subject: "HTTP proxy",
+  });
+}
+
+function proxyAgentForLookup(lookupUrl, proxyResolver, context) {
+  const proxyValue = String(proxyResolver(lookupUrl.href) || "").trim();
   if (!proxyValue) return { agent: null, mode: "direct" };
   let proxyUrl;
   try {
     proxyUrl = new URL(proxyValue);
   } catch {
-    throw proxyConfigurationError("relay proxy configuration is not a valid URL");
+    throw proxyConfigurationError(`${context.subject} configuration is not a valid URL`, context.errorCode);
   }
-  if (!new Set(["http:", "https:"]).has(proxyUrl.protocol)) {
-    throw proxyConfigurationError("relay proxy must use HTTP or HTTPS");
+  if (!HTTP_PROTOCOLS.has(proxyUrl.protocol)) {
+    throw proxyConfigurationError(`${context.subject} must use HTTP or HTTPS`, context.errorCode);
   }
   try {
     return {
@@ -23,12 +41,12 @@ export function proxyAgentForWebSocket(webSocketUrl, proxyResolver = getProxyFor
       mode: "proxy",
     };
   } catch {
-    throw proxyConfigurationError("relay proxy configuration could not be initialized");
+    throw proxyConfigurationError(`${context.subject} configuration could not be initialized`, context.errorCode);
   }
 }
 
-function proxyConfigurationError(message) {
+function proxyConfigurationError(message, code) {
   const error = new Error(message);
-  error.code = "relay_proxy_configuration";
+  error.code = code;
   return error;
 }

package/src/local/state-inventory.mjs

@@ -28,11 +28,15 @@ export function knownWorkerNames(stateRoot) {
       throw unreadableWorkerState(entry.name);
     }
     if (!state || typeof state !== "object" || Array.isArray(state)) throw unreadableWorkerState(entry.name);
-    const name = String(state?.worker?.name || "");
-    if (name && !WORKER_NAME.test(name)) {
-      throw new Error(`profile ${entry.name} contains an invalid Worker name; local state was kept for inspection`);
+    const currentName = String(state?.worker?.name || "");
+    const previousNames = Array.isArray(state?.worker?.previousNames) ? state.worker.previousNames : [];
+    for (const name of [currentName, ...previousNames]) {
+      if (!name) continue;
+      if (typeof name !== "string" || !WORKER_NAME.test(name)) {
+        throw new Error(`profile ${entry.name} contains an invalid Worker name; local state was kept for inspection`);
+      }
+      names.add(name);
     }
-    if (name) names.add(name);
   }
   return [...names];
 }

package/src/local/state.mjs

@@ -594,7 +594,26 @@ export function ensureWorkerSecrets(state, options = {}) {
   if (!state.worker.accountAdminSecret || options.rotateSecrets) state.worker.accountAdminSecret = randomToken("account_admin");
   if (!state.worker.daemonSecret || options.rotateSecrets) state.worker.daemonSecret = randomToken("daemon_secret");
   if (!state.worker.oauthTokenVersion || options.rotateSecrets) state.worker.oauthTokenVersion = randomToken("token_version");
-  if (!state.worker.name || options.workerName) state.worker.name = options.workerName || defaultWorkerName(state.workspace.hash);
+
+  const requestedName = options.workerName || "";
+  if (!state.worker.name) {
+    state.worker.name = requestedName || defaultWorkerName(state.workspace.hash);
+    return;
+  }
+  if (!requestedName || requestedName === state.worker.name) return;
+  if (!options.allowWorkerRename) {
+    throw new Error(`this workspace already uses Worker ${state.worker.name}; changing --worker-name to ${requestedName} would create another Worker. Re-run with --force-worker only when that replacement is intentional`);
+  }
+
+  const previous = String(state.worker.name);
+  const previousNames = Array.isArray(state.worker.previousNames) ? state.worker.previousNames : [];
+  state.worker.previousNames = [...new Set([...previousNames, previous])].slice(-32);
+  state.worker.name = requestedName;
+  delete state.worker.url;
+  delete state.worker.mcpServerUrl;
+  delete state.worker.deployHash;
+  delete state.worker.deployedVersion;
+  delete state.worker.updatedAt;
 }
 
 function defaultWorkerName(hash) {

package/src/local/worker-deployment.mjs

@@ -0,0 +1,170 @@
+import { createHmac } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import path, { resolve } from "node:path";
+import { runWrangler } from "./shell.mjs";
+import { packageRoot, saveState } from "./state.mjs";
+import { withWorkerSecretsFile } from "./worker-secret-file.mjs";
+import {
+  retryWorkerHealth,
+  workerHealthRequiresRedeploy,
+  workerHealthUserReason,
+} from "./worker-health.mjs";
+
+export async function ensureWorkerDeployment(state, args = {}, options = {}) {
+  const logger = options.logger || console;
+  const expectedVersion = options.expectedVersion || currentPackageVersion(options.packageRoot || packageRoot);
+  const desiredHash = workerDeploymentFingerprint(state, { packageRoot: options.packageRoot || packageRoot });
+  const runWranglerFn = options.runWrangler || runWrangler;
+  const saveStateFn = options.saveState || saveState;
+  const retryHealthFn = options.retryHealth || retryWorkerHealth;
+  const withSecretsFileFn = options.withSecretsFile || withWorkerSecretsFile;
+  const healthOptions = { expectedWorkerName: state.worker.name, ...(options.healthOptions || {}) };
+  const complete = hasCompleteWorkerState(state.worker);
+
+  if (!args.forceWorker && !args.rotateSecrets && complete && state.worker.deployHash === desiredHash) {
+    const health = await retryHealthFn(state.worker.url, expectedVersion, options.existingHealthAttempts || 2, healthOptions);
+    if (health.ok) {
+      logger.success?.("Worker unchanged and healthy", { url: state.worker.url });
+      logger.debug?.("Worker health route", { network_route: health.networkRoute || "unknown" });
+      return state.worker;
+    }
+    if (!workerHealthRequiresRedeploy(health.error)) {
+      logger.debug?.("Worker health check detail", { health_error: health.error, network_route: health.networkRoute || "unknown" });
+      throw workerVerificationError(health.error, { deploymentSucceeded: false });
+    }
+    logger.warn?.("Recorded Worker is stale; redeploying the same Worker", { reason: workerHealthUserReason(health.error) });
+    logger.debug?.("Worker health check detail", { health_error: health.error, network_route: health.networkRoute || "unknown" });
+  }
+
+  logger.info?.("Checking Cloudflare Wrangler login");
+  const whoami = await runWranglerFn(["whoami"], { capture: true, allowFailure: true });
+  if (whoami.code !== 0) {
+    logger.info?.("Wrangler is not logged in; opening Cloudflare login");
+    await runWranglerFn(["login"]);
+  }
+
+  logger.info?.("Deploying Cloudflare Worker", { name: state.worker.name });
+  const deploy = await withSecretsFileFn(state, secretFile => runWranglerFn([
+    "deploy",
+    "--name", state.worker.name,
+    "--minify",
+    "--keep-vars",
+    "--secrets-file", secretFile,
+  ], { capture: true }));
+
+  const detectedUrl = extractWorkerUrl(deploy.stdout) || extractWorkerUrl(deploy.stderr);
+  const recordedUrl = workerUrlMatchesName(state.worker.url, state.worker.name) ? state.worker.url : "";
+  const workerUrl = detectedUrl || recordedUrl;
+  if (!workerUrl) {
+    throw new Error("Worker upload returned success, but Wrangler output contained no workers.dev URL and no matching recorded URL exists. The deployment fingerprint was not saved; rerun with --verbose and inspect the Wrangler output before retrying.");
+  }
+
+  state.worker.url = workerUrl.replace(/\/+$/, "");
+  state.worker.mcpServerUrl = `${state.worker.url}/mcp`;
+  state.worker.deployHash = desiredHash;
+  state.worker.deployedVersion = expectedVersion;
+  state.worker.updatedAt = new Date().toISOString();
+  saveStateFn(state);
+
+  const health = await retryHealthFn(state.worker.url, expectedVersion, options.deploymentHealthAttempts || 8, healthOptions);
+  if (!health.ok) {
+    logger.debug?.("Worker post-deployment health detail", { health_error: health.error, network_route: health.networkRoute || "unknown" });
+    throw workerVerificationError(health.error, { deploymentSucceeded: true });
+  }
+  logger.success?.("Worker ready", { url: state.worker.url, version: health.version });
+  logger.debug?.("Worker health route", { network_route: health.networkRoute || "unknown" });
+  return state.worker;
+}
+
+export function workerDeploymentFingerprint(state, options = {}) {
+  const root = resolve(options.packageRoot || packageRoot);
+  const keyMaterial = [
+    String(state.worker.accountAdminSecret || ""),
+    String(state.worker.daemonSecret || ""),
+    String(state.worker.oauthTokenVersion || ""),
+  ].join("\0");
+  const fingerprint = createHmac("sha256", keyMaterial);
+  fingerprint.update("mbm-worker-deploy-v3");
+  fingerprint.update(String(state.worker.name || ""));
+  for (const file of workerDeployHashFiles(root)) {
+    fingerprint.update(path.relative(root, file));
+    fingerprint.update(readFileSync(file, "utf8"));
+  }
+  return fingerprint.digest("hex");
+}
+
+export function extractWorkerUrl(text = "") {
+  const matches = [...String(text).matchAll(/https:\/\/[^\s"'<>]+\.workers\.dev[^\s"'<>]*/g)];
+  if (matches.length) return matches.at(-1)[0].replace(/[),.]+$/, "");
+  const anyHttps = [...String(text).matchAll(/https:\/\/[^\s"'<>]+/g)];
+  return anyHttps.find(match => /workers\.dev|\/healthz|\/mcp/.test(match[0]))?.[0]?.replace(/[),.]+$/, "") || "";
+}
+
+export function workerUrlMatchesName(workerUrl, workerName) {
+  if (!workerUrl || !workerName) return false;
+  try {
+    const url = new URL(String(workerUrl));
+    return url.protocol === "https:"
+      && url.hostname.endsWith(".workers.dev")
+      && url.hostname.startsWith(`${String(workerName)}.`);
+  } catch {
+    return false;
+  }
+}
+
+function hasCompleteWorkerState(worker = {}) {
+  return Boolean(worker.url && worker.mcpServerUrl && worker.accountAdminSecret && worker.daemonSecret && worker.oauthTokenVersion && worker.name);
+}
+
+function workerDeployHashFiles(root) {
+  const files = [];
+  for (const item of ["src/worker", "src/shared", "wrangler.jsonc", "tsconfig.json"]) {
+    collectHashFiles(resolve(root, item), files);
+  }
+  return files.sort();
+}
+
+function collectHashFiles(target, out) {
+  if (!existsSync(target)) return;
+  const info = statSync(target);
+  if (info.isFile()) {
+    if (/\.(ts|js|mjs|json|jsonc|yaml|yml|lock)$/.test(target)) out.push(target);
+    return;
+  }
+  if (!info.isDirectory()) return;
+  for (const entry of readdirSync(target, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".wrangler" || entry.name.endsWith(".d.ts")) continue;
+    collectHashFiles(resolve(target, entry.name), out);
+  }
+}
+
+function workerVerificationError(reason, { deploymentSucceeded }) {
+  const readable = workerHealthUserReason(reason);
+  const guidance = workerVerificationGuidance(reason);
+  const message = deploymentSucceeded
+    ? `Cloudflare reported the Worker deployment succeeded, but ${readable}. The deployment fingerprint was saved, so retrying will verify the same Worker instead of deploying again. ${guidance}`
+    : `The recorded Worker could not be verified because ${readable}. No deployment was attempted. ${guidance}`;
+  const error = new Error(message);
+  error.code = "worker_health_unverified";
+  error.healthError = reason;
+  error.deploymentSucceeded = deploymentSucceeded;
+  return error;
+}
+
+function workerVerificationGuidance(reason) {
+  if (reason === "proxy_configuration") {
+    return "Check HTTPS_PROXY, HTTP_PROXY, and NO_PROXY, then run machine-mcp doctor.";
+  }
+  if (["timeout", "tls_error", "network_error", "request_failed"].includes(reason)) {
+    return "Check network/TLS access and HTTPS_PROXY, HTTP_PROXY, and NO_PROXY, then run machine-mcp doctor.";
+  }
+  if (/^HTTP 5\d\d$/.test(String(reason || ""))) {
+    return "Retry after the service recovers, or run machine-mcp doctor for the current health result.";
+  }
+  return "Run machine-mcp doctor and inspect the health endpoint before forcing another deployment.";
+}
+
+function currentPackageVersion(root) {
+  const pkg = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
+  return String(pkg.version);
+}