machine-bridge-mcp 0.1.0 → 0.2.0

package/README.md

@@ -38,6 +38,86 @@ MCP connection password: mcp_password_...
 
 Keep the foreground process running for the current session. The installed autostart entry keeps the daemon available after future logins.
 
+The command is safe to run repeatedly:
+
+```zsh
+npm install -g machine-bridge-mcp@latest && machine-mcp
+```
+
+On repeat runs, the CLI reuses existing state and secrets unless you request rotation, skips Worker redeploys when the deployed Worker is healthy and unchanged, refreshes the autostart entry, stops any currently loaded autostart daemon before starting the foreground daemon, and refuses to start a second daemon for the same workspace if another foreground instance is already running.
+
+## Local OpenAI-compatible API provider
+
+`machine-bridge-mcp` can also expose a local OpenAI-compatible API provider for desktop AI clients such as Cherry Studio, Chatbox, Continue, or other apps that accept an OpenAI-style base URL and API key.
+
+Start only the local API service:
+
+```zsh
+machine-mcp api
+```
+
+Or run it together with the Remote MCP daemon:
+
+```zsh
+machine-mcp start --api
+```
+
+The CLI prints client settings like:
+
+```text
+API Base URL: http://127.0.0.1:8765/v1
+API key: local_api_key_...
+Client type: OpenAI-compatible
+```
+
+Use these values in the local AI client:
+
+- Base URL: `http://127.0.0.1:8765/v1`
+- API key: the `local_api_key_...` printed by the CLI
+- Model: the model shown by `GET /v1/models` or your configured `--api-model`
+
+If port `8765` conflicts with another local app, choose a different port explicitly:
+
+```zsh
+machine-mcp api --api-port 8766
+machine-mcp start --api --api-port 8766
+```
+
+`--port` is also accepted on the `api` command:
+
+```zsh
+machine-mcp api --port 8766
+```
+
+By default, the local API binds to `127.0.0.1` and does not start unless you run `machine-mcp api` or pass `--api`. It stores a per-workspace local API key in the same owner-only state profile used by the MCP credentials. Rotate it with:
+
+```zsh
+machine-mcp api --rotate-api-key
+```
+
+Configure an upstream OpenAI-compatible provider:
+
+```zsh
+machine-mcp api \
+  --api-upstream-url https://api.openai.com/v1 \
+  --api-upstream-key "$OPENAI_API_KEY" \
+  --api-model gpt-4.1
+```
+
+Environment variables are also supported: `MBM_API_HOST`, `MBM_API_PORT`, `MBM_API_KEY`, `MBM_API_UPSTREAM_URL`, `MBM_API_UPSTREAM_KEY`, `MBM_API_MODEL`, plus common OpenAI names such as `OPENAI_API_KEY`, `OPENAI_BASE_URL`, and `OPENAI_MODEL`.
+
+Supported local API routes:
+
+- `GET /health` without authentication
+- `GET /v1/models` with `Authorization: Bearer <local_api_key>` or `x-api-key`
+- `POST /v1/chat/completions`
+- `POST /v1/responses`
+- `POST /v1/embeddings`
+- `POST /v1/completions`
+
+Model-producing routes proxy to the configured upstream provider. If no upstream key is configured, the API still starts and `/v1/models` works, but generation endpoints return a clear `503 upstream_not_configured` error. Logs record route, status, latency, and safe configuration metadata; request and response bodies and API keys are not logged.
+
+
 ## Re-select workspace
 
 ```zsh
@@ -80,7 +160,7 @@ machine-mcp service uninstall
 machine-mcp --no-autostart
 ```
 
-Autostart runs the daemon with `--daemon-only --no-print-credentials`, so service logs do not contain the MCP connection password. If you start with `--no-write`, `--no-exec`, or `--full-env`, those policy flags are preserved in the autostart entry.
+Autostart runs the daemon with `--daemon-only --no-print-credentials`, so service logs do not contain the MCP connection password. If you start with `--no-write`, `--no-exec`, or `--full-env`, those policy flags are preserved in the autostart entry. macOS/Linux service definitions restart only on process failure; a normal duplicate-instance exit is not treated as a crash loop.
 
 ## Secrets rotation
 
@@ -157,7 +237,9 @@ Default state roots:
 - Linux with `XDG_STATE_HOME`: `$XDG_STATE_HOME/machine-bridge-mcp`
 - Windows: `%APPDATA%\machine-bridge-mcp`
 
-State contains the MCP password and daemon secret. Status/doctor output redacts secrets. The normal foreground `start` command prints the MCP password because users need to paste it into their MCP client.
+State contains the MCP password, daemon secret, and local API key when the API provider has been started. Status/doctor output redacts secrets. The normal foreground `start` command prints the MCP password because users need to paste it into their MCP client; `api` prints the local API key for the same reason. Use `--no-print-credentials` to redact console credentials. State files, temporary Worker secret files, lock files, and log directories are created under the user state root with owner-only permissions where the platform supports POSIX modes.
+
+The Worker rejects browser requests with an `Origin` header unless the origin is the Worker itself or a loopback HTTP origin. To allow additional browser-based MCP clients, set `MBM_ALLOWED_ORIGINS` to a comma-separated list of exact origins in `wrangler.jsonc` or Cloudflare Worker settings.
 
 Override state root:
 
@@ -173,6 +255,8 @@ flowchart LR
   W --> DO["Durable Object broker"]
   D["Local daemon"] -- "outbound WebSocket" --> W
   D --> M["Local filesystem and shell"]
+  API["Optional local /v1 API"] -- "OpenAI-compatible HTTP" --> U["Configured upstream provider"]
+  CLI["machine-mcp CLI"] --> API
   CLI["machine-mcp CLI"] --> W
   CLI --> D
   CLI --> S["Autostart service"]
@@ -185,6 +269,7 @@ Why this architecture:
 - The public MCP URL is stable after deployment.
 - The Worker stores OAuth client/code/token metadata and relays tool calls.
 - The local daemon is the only process touching files or executing commands.
+- The optional local `/v1` API binds to loopback by default and starts only when requested.
 - Autostart keeps the daemon alive across logins without requiring MCP clients to change URLs.
 
 ## Development

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machine-bridge-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "One-command hosted Remote MCP bridge to a local machine daemon.",
   "type": "module",
   "license": "MIT",
@@ -18,6 +18,7 @@
     "bin",
     "src/local",
     "src/worker/index.ts",
+    "scripts",
     "wrangler.jsonc",
     "tsconfig.json",
     "README.md",
@@ -27,9 +28,14 @@
     "start": "node bin/machine-mcp.mjs start",
     "doctor": "node bin/machine-mcp.mjs doctor",
     "self-test": "node src/local/self-test.mjs",
+    "version:sync": "node scripts/sync-worker-version.mjs",
+    "version:check": "node scripts/sync-worker-version.mjs --check",
+    "version": "node scripts/sync-worker-version.mjs && git add package.json package-lock.json src/worker/index.ts",
+    "prepack": "npm run version:check",
+    "prepublishOnly": "npm run check && npm run version:check",
     "worker:types": "wrangler types src/worker/worker-configuration.d.ts",
     "typecheck": "npm run worker:types && tsc -p tsconfig.json --noEmit",
-    "syntax": "sh -n mbm && node --check bin/machine-mcp.mjs && node --check src/local/cli.mjs && node --check src/local/daemon.mjs && node --check src/local/state.mjs && node --check src/local/shell.mjs && node --check src/local/service.mjs && node --check src/local/self-test.mjs",
+    "syntax": "sh -n mbm && node --check bin/machine-mcp.mjs && node --check src/local/cli.mjs && node --check src/local/daemon.mjs && node --check src/local/state.mjs && node --check src/local/shell.mjs && node --check src/local/service.mjs && node --check src/local/self-test.mjs && node --check src/local/api-server.mjs && node --check src/local/log.mjs",
     "check": "npm run typecheck && npm run syntax && npm run self-test"
   },
   "dependencies": {

package/scripts/sync-worker-version.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packagePath = path.join(repoRoot, "package.json");
+const workerPath = path.join(repoRoot, "src", "worker", "index.ts");
+const args = new Set(process.argv.slice(2));
+const checkOnly = args.has("--check");
+const log = message => process.stderr.write(`${message}\n`);
+
+const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+const expected = String(pkg.version || "").trim();
+if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(expected)) {
+  fail(`package.json version is not a valid release version: ${JSON.stringify(expected)}`);
+}
+
+const source = readFileSync(workerPath, "utf8");
+const pattern = /const SERVER_VERSION = "([^"]+)";/;
+const match = source.match(pattern);
+if (!match) fail("Could not find `const SERVER_VERSION = \"...\";` in src/worker/index.ts");
+
+const current = match[1];
+if (current === expected) {
+  log(`Worker version is in sync: ${expected}`);
+  process.exit(0);
+}
+
+if (checkOnly) {
+  fail(`Worker version mismatch: package.json=${expected}, src/worker/index.ts=${current}. Run npm run version:sync.`);
+}
+
+const updated = source.replace(pattern, `const SERVER_VERSION = "${expected}";`);
+writeFileSync(workerPath, updated);
+log(`Updated Worker version: ${current} -> ${expected}`);
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}

package/src/local/api-server.mjs

@@ -0,0 +1,256 @@
+import http from "node:http";
+import { randomUUID } from "node:crypto";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createLogger } from "./log.mjs";
+
+export const DEFAULT_API_HOST = "127.0.0.1";
+export const DEFAULT_API_PORT = 8765;
+export const DEFAULT_UPSTREAM_URL = "https://api.openai.com/v1";
+export const DEFAULT_API_MODEL = "machine-bridge-mcp";
+export const DEFAULT_API_MAX_BODY_BYTES = 32 * 1024 * 1024;
+
+const PROXY_ROUTES = new Set([
+  "/v1/chat/completions",
+  "/v1/responses",
+  "/v1/embeddings",
+  "/v1/completions",
+]);
+
+const HOP_BY_HOP_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "host",
+  "content-length",
+  "authorization",
+  "x-api-key",
+]);
+
+export function parseApiPort(value, fallback = DEFAULT_API_PORT) {
+  if (value === undefined || value === null || value === true || value === "") return fallback;
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`Invalid API port: ${value}`);
+  return port;
+}
+
+export function normalizeApiHost(value, fallback = DEFAULT_API_HOST) {
+  if (value === undefined || value === null || value === true || value === "") return fallback;
+  const host = String(value).trim();
+  if (!host) return fallback;
+  if (/[/\\\s]/.test(host)) throw new Error(`Invalid API host: ${value}`);
+  return host;
+}
+
+export function normalizeBaseUrl(value, fallback = DEFAULT_UPSTREAM_URL) {
+  const raw = value === undefined || value === null || value === true || value === "" ? fallback : String(value).trim();
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error(`Invalid upstream API URL: ${raw}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Invalid upstream API URL protocol: ${parsed.protocol}`);
+  if (parsed.username || parsed.password) throw new Error("Upstream API URL must not contain credentials; pass keys with --api-upstream-key or environment variables.");
+  if (parsed.search || parsed.hash) throw new Error("Upstream API URL must be a base URL without query strings or fragments.");
+  return parsed.toString().replace(/\/+$/, "");
+}
+
+export async function startLocalApiServer(options = {}) {
+  const logger = options.logger || createLogger({ component: "api", quiet: options.quiet });
+  const host = normalizeApiHost(options.host);
+  const port = parseApiPort(options.port);
+  const apiKey = String(options.apiKey || "");
+  const upstreamUrl = normalizeBaseUrl(options.upstreamUrl);
+  const upstreamKey = String(options.upstreamKey || "");
+  const model = String(options.model || DEFAULT_API_MODEL);
+  const maxBodyBytes = Number(options.maxBodyBytes || DEFAULT_API_MAX_BODY_BYTES);
+
+  if (!apiKey) throw new Error("Local API key is missing");
+
+  const server = http.createServer((req, res) => {
+    void handleRequest(req, res, { logger, apiKey, upstreamUrl, upstreamKey, model, maxBodyBytes });
+  });
+
+  server.keepAliveTimeout = 65_000;
+  server.headersTimeout = 70_000;
+  server.requestTimeout = 0;
+
+  await new Promise((resolve, reject) => {
+    const onError = error => {
+      server.off("listening", onListening);
+      reject(withPortHint(error, port));
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen({ host, port });
+  });
+
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  const baseUrl = `http://${urlHost}:${actualPort}/v1`;
+  logger.success("local OpenAI-compatible API started", { baseUrl, model, upstream: upstreamUrl, upstreamConfigured: Boolean(upstreamKey) });
+
+  return {
+    server,
+    host,
+    port: actualPort,
+    baseUrl,
+    url: `http://${urlHost}:${actualPort}`,
+    close() {
+      return new Promise(resolve => server.close(() => resolve()));
+    },
+  };
+}
+
+async function handleRequest(req, res, context) {
+  const requestId = randomUUID().slice(0, 8);
+  const started = Date.now();
+  const url = new URL(req.url || "/", "http://127.0.0.1");
+  setCorsHeaders(res);
+
+  try {
+    if (req.method === "OPTIONS") return sendEmpty(res, 204);
+    if (req.method === "GET" && url.pathname === "/health") return sendJson(res, 200, { ok: true, service: "machine-bridge-mcp-local-api" });
+
+    if (!isAuthorized(req, context.apiKey)) return sendOpenAiError(res, 401, "invalid_api_key", "Missing or invalid local API key.");
+
+    if (req.method === "GET" && url.pathname === "/v1/models") {
+      context.logger.info("request completed", { requestId, method: req.method, path: url.pathname, status: 200, durationMs: Date.now() - started });
+      return sendJson(res, 200, modelsPayload(context.model));
+    }
+
+    if (req.method === "POST" && PROXY_ROUTES.has(url.pathname)) {
+      if (!context.upstreamKey) {
+        return sendOpenAiError(res, 503, "upstream_not_configured", "No upstream API key is configured. Set --api-upstream-key or MBM_API_UPSTREAM_KEY/OPENAI_API_KEY.");
+      }
+      context.logger.info("proxy request started", { requestId, path: url.pathname, upstream: context.upstreamUrl });
+      await proxyRequest(req, res, url, context);
+      context.logger.info("proxy request completed", { requestId, path: url.pathname, status: res.statusCode, durationMs: Date.now() - started });
+      return;
+    }
+
+    return sendOpenAiError(res, 404, "not_found", `Unknown local API endpoint: ${url.pathname}`);
+  } catch (error) {
+    context.logger.error("request failed", { requestId, path: url.pathname, error: error.message, durationMs: Date.now() - started });
+    if (!res.headersSent) {
+      if (error?.code === "BODY_TOO_LARGE") return sendOpenAiError(res, 413, "request_too_large", error.message);
+      return sendOpenAiError(res, 502, "upstream_error", error.message || "Local API request failed.");
+    }
+    res.destroy(error);
+  }
+}
+
+async function proxyRequest(req, res, url, context) {
+  const body = await readBody(req, context.maxBodyBytes);
+  const upstreamTarget = `${context.upstreamUrl}${url.pathname.slice(3)}${url.search}`;
+  const headers = copyProxyHeaders(req.headers, context.upstreamKey);
+  const response = await fetch(upstreamTarget, {
+    method: "POST",
+    headers,
+    body,
+    signal: AbortSignal.timeout(10 * 60 * 1000),
+  });
+
+  res.statusCode = response.status;
+  for (const [key, value] of response.headers) {
+    if (!HOP_BY_HOP_HEADERS.has(key.toLowerCase())) res.setHeader(key, value);
+  }
+  if (!res.hasHeader("content-type")) res.setHeader("content-type", "application/json");
+  if (response.body) await pipeline(Readable.fromWeb(response.body), res);
+  else res.end();
+}
+
+function copyProxyHeaders(source, upstreamKey) {
+  const out = new Headers();
+  for (const [key, value] of Object.entries(source)) {
+    if (HOP_BY_HOP_HEADERS.has(key.toLowerCase())) continue;
+    if (Array.isArray(value)) out.set(key, value.join(", "));
+    else if (value !== undefined) out.set(key, String(value));
+  }
+  out.set("authorization", `Bearer ${upstreamKey}`);
+  if (!out.has("content-type")) out.set("content-type", "application/json");
+  return out;
+}
+
+function readBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", chunk => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        const error = new Error(`Request body exceeds ${maxBytes} bytes`);
+        error.code = "BODY_TOO_LARGE";
+        req.destroy(error);
+        reject(error);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+function isAuthorized(req, expectedKey) {
+  const auth = String(req.headers.authorization || "");
+  if (auth.startsWith("Bearer ") && auth.slice(7) === expectedKey) return true;
+  const apiKey = req.headers["x-api-key"];
+  return typeof apiKey === "string" && apiKey === expectedKey;
+}
+
+function modelsPayload(model) {
+  return {
+    object: "list",
+    data: [{
+      id: model,
+      object: "model",
+      created: 0,
+      owned_by: "machine-bridge-mcp",
+    }],
+  };
+}
+
+function sendOpenAiError(res, status, code, message) {
+  return sendJson(res, status, { error: { message, type: "invalid_request_error", param: null, code } });
+}
+
+function sendJson(res, status, payload) {
+  if (!res.headersSent) {
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json; charset=utf-8");
+  }
+  res.end(`${JSON.stringify(payload)}\n`);
+}
+
+function sendEmpty(res, status) {
+  res.statusCode = status;
+  res.end();
+}
+
+function setCorsHeaders(res) {
+  res.setHeader("access-control-allow-origin", "*");
+  res.setHeader("access-control-allow-methods", "GET,POST,OPTIONS");
+  res.setHeader("access-control-allow-headers", "authorization,content-type,x-api-key,openai-beta,openai-organization,openai-project");
+}
+
+function withPortHint(error, port) {
+  if (error?.code === "EADDRINUSE") {
+    error.message = `Local API port ${port} is already in use. Re-run with \`machine-mcp api --api-port <free_port>\` or \`machine-mcp start --api --api-port <free_port>\`.`;
+  }
+  if (error?.code === "EACCES") {
+    error.message = `Local API port ${port} is not permitted. Re-run with \`machine-mcp api --api-port <free_port>\`.`;
+  }
+  return error;
+}

package/src/local/cli.mjs

@@ -4,11 +4,15 @@ import path, { resolve } from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { LocalDaemon } from "./daemon.mjs";
+import { startLocalApiServer, DEFAULT_API_HOST, DEFAULT_API_PORT, DEFAULT_API_MODEL, DEFAULT_UPSTREAM_URL } from "./api-server.mjs";
+import { createLogger, redactSecret } from "./log.mjs";
 import { runWrangler } from "./shell.mjs";
 import {
+  acquireDaemonLock,
   appName,
   defaultStateRoot,
   ensureOwnerOnlyDir,
+  ensureLocalApiKey,
   ensureWorkerSecrets,
   expandHome,
   loadGlobalConfig,
@@ -28,11 +32,13 @@ import {
 export async function main(argv = process.argv.slice(2)) {
   const [command, rest] = normalizeCommand(argv);
   const args = parseArgs(rest);
+  if (command === "api" && args.help) return apiUsage();
   if (args.help || command === "help") return usage();
   if (args.version || command === "version") return version();
 
   switch (command) {
     case "start": return startCommand(args);
+    case "api": return apiCommand(args);
     case "status": return statusCommand(args);
     case "doctor": return doctorCommand(args);
     case "workspace": return workspaceCommand(args);
@@ -153,9 +159,11 @@ async function confirm(prompt, assumeYes = false) {
 
 async function startCommand(args) {
   assertNodeVersion();
+  const logger = createLogger({ quiet: Boolean(args.quiet), verbose: Boolean(args.verbose), component: "cli" });
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: true, save: true, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
   ensureWorkerSecrets(state, { rotateSecrets: Boolean(args.rotateSecrets), workerName: args.workerName && String(args.workerName) });
+  if (args.api) ensureLocalApiKey(state, { apiKey: valueFromArgsEnv(args.apiKey, "MBM_API_KEY"), rotateApiKey: Boolean(args.rotateApiKey) });
   state.policy = {
     allowWrite: args.noWrite ? false : true,
     allowExec: args.noExec ? false : true,
@@ -172,40 +180,105 @@ async function startCommand(args) {
     await installAutostartBestEffort({ workspace, stateRoot: state.paths.stateRoot, entryScript: process.argv[1], policy: state.policy });
   }
 
-  const daemon = new LocalDaemon({
-    workerUrl: state.worker.url,
-    secret: state.worker.daemonSecret,
-    workspace,
-    policy: state.policy,
-    logger: structuredLogger(args.quiet),
-  });
+  if (!args.daemonOnly) await stopAutostartBestEffort(Boolean(args.quiet));
+
+  const lock = acquireDaemonLock(state);
+  let apiServer = null;
+  if (!lock.acquired) {
+    if (!args.quiet) {
+      const pid = lock.owner?.pid ? `pid ${lock.owner.pid}` : "unknown pid";
+      logger.warn(`local daemon already running for this workspace (${pid}); not starting a duplicate`);
+      printConnection(state, { json: Boolean(args.json), noPrintCredentials: Boolean(args.noPrintCredentials) });
+    }
+    if (!args.api) return;
+    apiServer = await startConfiguredApiServer(state, args);
+    printApiConnection(apiServer, state, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+    keepProcessAlive({ apiServer, logger });
+    return;
+  }
+
+  try {
+    const daemon = new LocalDaemon({
+      workerUrl: state.worker.url,
+      secret: state.worker.daemonSecret,
+      workspace,
+      policy: state.policy,
+      logger: createLogger({ quiet: Boolean(args.quiet), verbose: Boolean(args.verbose), component: "daemon" }),
+    });
+
+    const waitForConnect = daemon.start();
+    await waitForConnectWithNotice(waitForConnect, 20_000);
+    if (args.api) apiServer = await startConfiguredApiServer(state, args);
+    printConnection(state, { json: Boolean(args.json), noPrintCredentials: Boolean(args.noPrintCredentials) });
+    if (apiServer) printApiConnection(apiServer, state, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+    keepProcessAlive({ daemon, lock, apiServer, logger });
+  } catch (error) {
+    lock.release();
+    if (apiServer) await apiServer.close().catch(() => {});
+    throw error;
+  }
+}
+
+async function apiCommand(args) {
+  assertNodeVersion();
+  const workspace = await chooseWorkspace(args, { promptOnFirstRun: true, save: true, allowPositional: true });
+  const state = loadState(workspace, { stateDir: args.stateDir });
+  ensureLocalApiKey(state, { apiKey: valueFromArgsEnv(args.apiKey, "MBM_API_KEY"), rotateApiKey: Boolean(args.rotateApiKey) });
+  saveState(state);
+  const logger = createLogger({ quiet: Boolean(args.quiet), verbose: Boolean(args.verbose), component: "api" });
+  const apiServer = await startConfiguredApiServer(state, args, logger);
+  printApiConnection(apiServer, state, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+  keepProcessAlive({ apiServer, logger });
+}
+
+async function startConfiguredApiServer(state, args, logger = createLogger({ quiet: Boolean(args.quiet), verbose: Boolean(args.verbose), component: "api" })) {
+  const apiOptions = apiOptionsFromArgs(state, args);
+  return startLocalApiServer({ ...apiOptions, logger });
+}
 
-  const waitForConnect = daemon.start();
-  await waitForConnectWithNotice(waitForConnect, 20_000);
-  printConnection(state, { json: Boolean(args.json), noPrintCredentials: Boolean(args.noPrintCredentials) });
-  keepProcessAlive(daemon);
+function apiOptionsFromArgs(state, args = {}) {
+  const upstreamKey = valueFromArgsEnv(args.apiUpstreamKey, "MBM_API_UPSTREAM_KEY", "OPENAI_API_KEY");
+  const explicitPort = args.apiPort !== undefined && args.apiPort !== true ? args.apiPort : (args.port !== undefined && args.port !== true ? args.port : undefined);
+  const envPort = valueFromArgsEnv(undefined, "MBM_API_PORT", "PORT");
+  return {
+    host: valueFromArgsEnv(args.apiHost, "MBM_API_HOST") || DEFAULT_API_HOST,
+    port: explicitPort ?? envPort ?? DEFAULT_API_PORT,
+    apiKey: valueFromArgsEnv(args.apiKey, "MBM_API_KEY") || state.localApi?.apiKey || ensureLocalApiKey(state, { rotateApiKey: Boolean(args.rotateApiKey) }),
+    upstreamUrl: valueFromArgsEnv(args.apiUpstreamUrl, "MBM_API_UPSTREAM_URL", "OPENAI_BASE_URL", "OPENAI_API_BASE") || DEFAULT_UPSTREAM_URL,
+    upstreamKey: upstreamKey || "",
+    model: valueFromArgsEnv(args.apiModel, "MBM_API_MODEL", "OPENAI_MODEL") || DEFAULT_API_MODEL,
+  };
+}
+
+function valueFromArgsEnv(argValue, ...envNames) {
+  if (argValue !== undefined && argValue !== null && argValue !== true) return String(argValue);
+  for (const name of envNames) {
+    if (process.env[name]) return process.env[name];
+  }
+  return undefined;
 }
 
 async function ensureWorker(state, args) {
+  const logger = createLogger({ quiet: Boolean(args.quiet), verbose: Boolean(args.verbose), component: "worker" });
   const desiredHash = workerDeployHash(state);
   const complete = state.worker.url && state.worker.mcpServerUrl && state.worker.oauthPassword && 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);
     if (health.ok) {
-      console.log(`Worker unchanged and healthy: ${state.worker.url}`);
+      logger.success("Worker unchanged and healthy", { url: state.worker.url });
       return state.worker;
     }
-    console.warn(`Worker health check failed, redeploying: ${health.error}`);
+    logger.warn("Worker health check failed; redeploying", { error: health.error });
   }
 
-  console.log("Checking Cloudflare Wrangler login...");
+  logger.info("Checking Cloudflare Wrangler login");
   const whoami = await runWrangler(["whoami"], { capture: true, allowFailure: true });
   if (whoami.code !== 0) {
-    console.log("Wrangler is not logged in; opening Cloudflare login...");
+    logger.info("Wrangler is not logged in; opening Cloudflare login");
     await runWrangler(["login"]);
   }
 
-  console.log(`Deploying Cloudflare Worker '${state.worker.name}'...`);
+  logger.info("Deploying Cloudflare Worker", { name: state.worker.name });
   const deploy = await withSecretsFile(state, secretFile => runWrangler([
     "deploy",
     "--name", state.worker.name,
@@ -223,8 +296,8 @@ async function ensureWorker(state, args) {
   saveState(state);
 
   const health = await retryHealth(state.worker.url, 8);
-  if (!health.ok) console.warn(`Worker deployed but health check did not pass yet: ${health.error}`);
-  else console.log(`Worker ready: ${state.worker.url}`);
+  if (!health.ok) logger.warn("Worker deployed but health check did not pass yet", { error: health.error });
+  else logger.success("Worker ready", { url: state.worker.url });
   return state.worker;
 }
 
@@ -330,10 +403,11 @@ async function waitForConnectWithNotice(promise, timeoutMs) {
   });
   const result = await Promise.race([promise.then(() => "connected"), timed]);
   clearTimeout(timeout);
-  if (result === "timeout") console.warn("Daemon is still connecting; credentials are printed now and the process will keep retrying.");
+  if (result === "timeout") createLogger({ component: "daemon" }).warn("Still connecting; credentials are printed now and the process will keep retrying");
 }
 
 function printConnection(state, { json = false, noPrintCredentials = false } = {}) {
+  const logger = createLogger({ component: "ready" });
   const payload = {
     mcp_server_url: state.worker.mcpServerUrl,
     mcp_connection_password: state.worker.oauthPassword,
@@ -345,26 +419,40 @@ function printConnection(state, { json = false, noPrintCredentials = false } = {
   };
   if (json) {
     const safePayload = noPrintCredentials ? { ...payload, mcp_connection_password: previewSecret(payload.mcp_connection_password) } : payload;
-    console.log(JSON.stringify(safePayload, null, 2));
+    logger.json(safePayload);
     return;
   }
-  console.log("\nMachine Bridge MCP is ready. Keep this process running.\n");
-  console.log(`MCP Server URL: ${payload.mcp_server_url}`);
-  if (!noPrintCredentials) console.log(`MCP connection password: ${payload.mcp_connection_password}`);
-  else console.log(`MCP connection password: ${previewSecret(payload.mcp_connection_password)} (redacted)`);
-  console.log(`Workspace cwd for relative paths: ${payload.workspace}`);
-  console.log(`Policy: write=${payload.policy.allowWrite ? "on" : "off"}, exec=${payload.policy.allowExec ? "on" : "off"}, unrestricted_paths=${payload.policy.unrestrictedPaths ? "on" : "off"}`);
-  console.log(`State: ${payload.state_path}\n`);
-}
-
-function keepProcessAlive(daemon) {
-  const stop = () => {
-    console.log("Stopping daemon...");
-    daemon.stop();
+  logger.success("Remote MCP bridge is ready; keep this process running");
+  logger.plain(`  MCP Server URL: ${payload.mcp_server_url}`);
+  if (!noPrintCredentials) logger.plain(`  MCP connection password: ${payload.mcp_connection_password}`);
+  else logger.plain(`  MCP connection password: ${previewSecret(payload.mcp_connection_password)} (redacted)`);
+  logger.plain(`  Workspace cwd: ${payload.workspace}`);
+  logger.plain(`  Policy: write=${payload.policy.allowWrite ? "on" : "off"}, exec=${payload.policy.allowExec ? "on" : "off"}, unrestricted_paths=${payload.policy.unrestrictedPaths ? "on" : "off"}`);
+  logger.plain(`  State: ${payload.state_path}`);
+}
+
+function printApiConnection(apiServer, state, { noPrintCredentials = false } = {}) {
+  const logger = createLogger({ component: "ready" });
+  logger.success("Local model API provider is ready");
+  logger.plain(`  API Base URL: ${apiServer.baseUrl}`);
+  logger.plain(`  API key: ${noPrintCredentials ? `${redactSecret(state.localApi.apiKey)} (redacted)` : state.localApi.apiKey}`);
+  logger.plain("  Client type: OpenAI-compatible");
+}
+
+function keepProcessAlive({ daemon = null, lock = null, apiServer = null, logger = createLogger({ component: "cli" }) } = {}) {
+  let stopping = false;
+  const stop = async () => {
+    if (stopping) return;
+    stopping = true;
+    logger.info("stopping local services");
+    try { daemon?.stop?.(); } catch {}
+    try { await apiServer?.close?.(); } catch {}
+    try { lock?.release?.(); } catch {}
     process.exit(0);
   };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
+  process.once("SIGINT", () => void stop());
+  process.once("SIGTERM", () => void stop());
+  process.once("exit", () => lock?.release?.());
   setInterval(() => {}, 2 ** 31 - 1);
 }
 
@@ -449,6 +537,15 @@ async function installAutostartBestEffort({ workspace, stateRoot, entryScript, p
   }
 }
 
+async function stopAutostartBestEffort(quiet = false) {
+  try {
+    const { stopAutostart } = await import("./service.mjs");
+    await stopAutostart({ logger: structuredLogger(true) });
+  } catch (error) {
+    if (!quiet) console.warn(`Autostart stop skipped: ${error.message}`);
+  }
+}
+
 async function uninstallCommand(args) {
   const stateRoot = stateRootFromArgs(args);
   const deleteRemote = !args.keepWorker;
@@ -508,12 +605,7 @@ async function removeAutostartBestEffort(stateRoot) {
 }
 
 function structuredLogger(quiet) {
-  if (quiet) return { info() {}, warn() {}, error() {} };
-  return {
-    info: msg => console.log(`[daemon] ${msg}`),
-    warn: msg => console.warn(`[daemon] ${msg}`),
-    error: msg => console.error(`[daemon] ${msg}`),
-  };
+  return createLogger({ quiet, component: "daemon" });
 }
 
 function sanitizeLines(text) {
@@ -549,6 +641,7 @@ Usage:
 
 Commands:
   start             Deploy/update Worker, install autostart, start local daemon
+  api               Start local OpenAI-compatible API provider only
   workspace show    Show remembered workspace
   workspace set     Re-select workspace; prompts with current/default path
   service status    Show autostart status
@@ -568,11 +661,21 @@ Start options:
   --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
+  --no-print-credentials Redact the MCP password in console output
   --no-write            Disable write_file (default: write enabled)
   --no-exec             Disable exec_command (default: exec enabled)
   --full-env            Pass full parent environment to exec_command (default: minimal env)
   --state-dir DIR       Override state root
   --json                Print connection details as JSON
+  --api                 Also start local OpenAI-compatible API provider
+  --api-port PORT       Local API port (default: 8765)
+  --port PORT           Alias for --api-port on the api command
+  --api-host HOST       Local API host (default: 127.0.0.1)
+  --api-key KEY         Set or replace local API key in state
+  --rotate-api-key      Rotate local API key
+  --api-upstream-url URL  Upstream OpenAI-compatible base URL (default: https://api.openai.com/v1)
+  --api-upstream-key KEY  Upstream provider key; env OPENAI_API_KEY also works
+  --api-model MODEL     Model id advertised by /v1/models
 
 Uninstall options:
   --keep-worker         Do not delete deployed Worker(s) during uninstall
@@ -580,6 +683,38 @@ Uninstall options:
 `);
 }
 
+function apiUsage() {
+  console.log(`machine-bridge-mcp local API provider
+
+Usage:
+  machine-mcp api
+  machine-mcp api --api-port 8766
+  machine-mcp start --api --api-port 8766
+
+Client settings:
+  API Base URL: http://127.0.0.1:<port>/v1
+  API key: printed on startup unless --no-print-credentials is set
+  Client type: OpenAI-compatible
+
+Options:
+  --workspace PATH        Use and remember this workspace path
+  --api-host HOST         Local API host (default: 127.0.0.1)
+  --api-port PORT         Local API port (default: 8765)
+  --port PORT             Alias for --api-port
+  --api-key KEY           Set or replace local API key in state
+  --rotate-api-key        Rotate local API key
+  --api-upstream-url URL  Upstream OpenAI-compatible base URL
+  --api-upstream-key KEY  Upstream provider key; env OPENAI_API_KEY also works
+  --api-model MODEL       Model id advertised by /v1/models
+  --no-print-credentials  Redact the local API key in console output
+  --state-dir DIR         Override state root
+
+Environment:
+  MBM_API_HOST, MBM_API_PORT, MBM_API_KEY, MBM_API_UPSTREAM_URL, MBM_API_UPSTREAM_KEY, MBM_API_MODEL
+  OPENAI_API_KEY, OPENAI_BASE_URL, OPENAI_API_BASE, OPENAI_MODEL
+`);
+}
+
 function version() {
   const pkg = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
   console.log(`${pkg.name} ${pkg.version}`);

package/src/local/log.mjs

@@ -0,0 +1,60 @@
+import process from "node:process";
+
+const COLORS = {
+  dim: "\x1b[2m",
+  reset: "\x1b[0m",
+  blue: "\x1b[34m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  gray: "\x1b[90m",
+};
+
+export function createLogger(options = {}) {
+  const quiet = Boolean(options.quiet);
+  const verbose = Boolean(options.verbose);
+  const component = options.component ? String(options.component) : "cli";
+  const useColor = shouldUseColor(options);
+
+  const write = (stream, level, label, color, message, fields) => {
+    if (quiet && level !== "error") return;
+    if (level === "debug" && !verbose) return;
+    const prefix = useColor ? `${color}${label}${COLORS.reset}` : label;
+    const suffix = formatFields(fields);
+    stream.write(`${prefix} ${component}: ${String(message)}${suffix}\n`);
+  };
+
+  return {
+    child(childComponent) {
+      return createLogger({ ...options, component: childComponent });
+    },
+    info(message, fields) { write(process.stdout, "info", "[info]", COLORS.blue, message, fields); },
+    success(message, fields) { write(process.stdout, "success", "[ok]", COLORS.green, message, fields); },
+    warn(message, fields) { write(process.stderr, "warn", "[warn]", COLORS.yellow, message, fields); },
+    error(message, fields) { write(process.stderr, "error", "[error]", COLORS.red, message, fields); },
+    debug(message, fields) { write(process.stderr, "debug", "[debug]", COLORS.gray, message, fields); },
+    plain(message = "") { if (!quiet) process.stdout.write(`${String(message)}\n`); },
+    json(value) { process.stdout.write(`${JSON.stringify(value, null, 2)}\n`); },
+  };
+}
+
+export function redactSecret(value) {
+  const text = String(value || "");
+  if (!text) return "<empty>";
+  if (text.length <= 12) return "<redacted>";
+  return `${text.slice(0, 6)}...${text.slice(-4)}`;
+}
+
+export function formatFields(fields) {
+  if (!fields || typeof fields !== "object" || !Object.keys(fields).length) return "";
+  return ` ${JSON.stringify(fields, (_key, value) => {
+    if (value instanceof Error) return value.message;
+    return value;
+  })}`;
+}
+
+function shouldUseColor(options) {
+  if (options.color === false || process.env.NO_COLOR) return false;
+  if (options.color === true) return true;
+  return Boolean(process.stderr.isTTY || process.stdout.isTTY);
+}

package/src/local/self-test.mjs

@@ -2,11 +2,14 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { daemonSelfTest } from "./daemon.mjs";
-import { ensureWorkerSecrets, loadState, previewSecret, redactState, selectedWorkspace, setSelectedWorkspace } from "./state.mjs";
+import { normalizeBaseUrl, startLocalApiServer } from "./api-server.mjs";
+import { createLogger, redactSecret } from "./log.mjs";
+import { acquireDaemonLock, ensureLocalApiKey, ensureWorkerSecrets, loadState, previewSecret, redactState, selectedWorkspace, setSelectedWorkspace } from "./state.mjs";
 
 await daemonSelfTest();
 await stateSelfTest();
-console.log("local daemon/state self-test ok");
+await apiSelfTest();
+console.log("local daemon/state/api self-test ok");
 
 async function stateSelfTest() {
   const stateRoot = await mkdtemp(join(tmpdir(), "mbm-state-test-"));
@@ -16,13 +19,74 @@ async function stateSelfTest() {
     if (selectedWorkspace(stateRoot) !== workspace) throw new Error("selected workspace was not persisted");
     const state = loadState(workspace, { stateDir: stateRoot });
     ensureWorkerSecrets(state, { rotateSecrets: true });
+    ensureLocalApiKey(state, { rotateApiKey: true });
+    const lock = acquireDaemonLock(state);
+    if (!lock.acquired) throw new Error("first daemon lock acquisition failed");
+    try {
+      const duplicate = acquireDaemonLock(state);
+      if (duplicate.acquired) throw new Error("duplicate daemon lock acquisition should fail");
+      if (duplicate.owner?.pid !== process.pid) throw new Error("duplicate daemon lock owner was not reported");
+    } finally {
+      lock.release();
+    }
+    const relock = acquireDaemonLock(state);
+    if (!relock.acquired) throw new Error("daemon lock was not released");
+    relock.release();
+
     const redacted = redactState(state);
     if (redacted.worker.oauthPassword === state.worker.oauthPassword) throw new Error("oauthPassword was not redacted");
     if (redacted.worker.daemonSecret === state.worker.daemonSecret) throw new Error("daemonSecret was not redacted");
     if (redacted.worker.oauthTokenVersion === state.worker.oauthTokenVersion) throw new Error("oauthTokenVersion was not redacted");
+    if (redacted.localApi.apiKey === state.localApi.apiKey) throw new Error("local API key was not redacted");
     if (!previewSecret(state.worker.oauthPassword).includes("...")) throw new Error("previewSecret did not preview long secret");
+    if (!redactSecret(state.localApi.apiKey).includes("...")) throw new Error("redactSecret did not preview long secret");
   } finally {
     await rm(stateRoot, { recursive: true, force: true }).catch(() => {});
     await rm(workspace, { recursive: true, force: true }).catch(() => {});
   }
 }
+
+
+async function apiSelfTest() {
+  try {
+    normalizeBaseUrl("https://user:pass@example.com/v1");
+    throw new Error("upstream URL credentials were accepted");
+  } catch (error) {
+    if (!/must not contain credentials/.test(error.message)) throw error;
+  }
+  try {
+    normalizeBaseUrl("https://example.com/v1?api_key=secret");
+    throw new Error("upstream URL query string was accepted");
+  } catch (error) {
+    if (!/without query strings/.test(error.message)) throw error;
+  }
+
+  const logger = createLogger({ quiet: true, component: "api-test" });
+  const api = await startLocalApiServer({
+    host: "127.0.0.1",
+    port: 0,
+    apiKey: "local-test-key",
+    upstreamKey: "",
+    model: "test-model",
+    logger,
+  });
+  const base = `http://${api.host}:${api.port}`;
+  try {
+    const health = await fetch(`${base}/health`);
+    if (health.status !== 200) throw new Error(`health returned ${health.status}`);
+    const unauth = await fetch(`${base}/v1/models`);
+    if (unauth.status !== 401) throw new Error(`unauthorized models returned ${unauth.status}`);
+    const models = await fetch(`${base}/v1/models`, { headers: { authorization: "Bearer local-test-key" } });
+    if (models.status !== 200) throw new Error(`authorized models returned ${models.status}`);
+    const payload = await models.json();
+    if (payload?.data?.[0]?.id !== "test-model") throw new Error("model payload did not include configured model");
+    const chat = await fetch(`${base}/v1/chat/completions`, {
+      method: "POST",
+      headers: { authorization: "Bearer local-test-key", "content-type": "application/json" },
+      body: JSON.stringify({ model: "test-model", messages: [] }),
+    });
+    if (chat.status !== 503) throw new Error(`missing upstream key should return 503, got ${chat.status}`);
+  } finally {
+    await api.close();
+  }
+}

package/src/local/service.mjs

@@ -132,7 +132,10 @@ function launchdPlist({ args, stdout, stderr }) {
 ${args.map(arg => `    <string>${escapeXml(arg)}</string>`).join("\n")}
   </array>
   <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key><false/>
+  </dict>
   <key>StandardOutPath</key><string>${escapeXml(stdout)}</string>
   <key>StandardErrorPath</key><string>${escapeXml(stderr)}</string>
 </dict>
@@ -179,7 +182,7 @@ After=network-online.target
 [Service]
 Type=simple
 ExecStart=${execArgs}
-Restart=always
+Restart=on-failure
 RestartSec=5
 StandardOutput=append:${spec.stdout}
 StandardError=append:${spec.stderr}

package/src/local/state.mjs

@@ -1,5 +1,5 @@
 import { createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, realpathSync, rmSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync, chmodSync, realpathSync, rmSync, unlinkSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -89,7 +89,7 @@ export function loadState(workspace, options = {}) {
   ensureOwnerOnlyDir(profileDir);
   let state = {};
   if (existsSync(statePath)) {
-    state = JSON.parse(readFileSync(statePath, "utf8"));
+    state = readJsonObjectOrBackup(statePath);
   }
   state.schemaVersion = 1;
   state.workspace = {
@@ -112,6 +112,93 @@ export function saveState(state) {
   ownerOnlyFile(statePath);
 }
 
+export function daemonLockPathForState(state) {
+  const profileDir = state?.paths?.profileDir;
+  if (!profileDir) throw new Error("state profile dir is missing");
+  return path.join(profileDir, "daemon.lock");
+}
+
+export function acquireDaemonLock(state) {
+  const lockPath = daemonLockPathForState(state);
+  ensureOwnerOnlyDir(path.dirname(lockPath));
+  const token = randomBytes(16).toString("hex");
+  const payload = {
+    pid: process.pid,
+    token,
+    workspace: state?.workspace?.path || "",
+    startedAt: new Date().toISOString(),
+    entryScript: process.argv[1] || "",
+  };
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    let fd;
+    try {
+      fd = openSync(lockPath, "wx", 0o600);
+      writeFileSync(fd, JSON.stringify(payload, null, 2) + "\n");
+      closeSync(fd);
+      ownerOnlyFile(lockPath);
+      return {
+        acquired: true,
+        path: lockPath,
+        owner: payload,
+        release() {
+          releaseDaemonLock(lockPath, token);
+        },
+      };
+    } catch (error) {
+      if (fd !== undefined) {
+        try { closeSync(fd); } catch {}
+      }
+      if (error?.code !== "EEXIST") throw error;
+      const owner = readDaemonLockOwner(lockPath);
+      if (owner?.pid && isPidAlive(owner.pid)) {
+        return { acquired: false, path: lockPath, owner, release() {} };
+      }
+      try { unlinkSync(lockPath); } catch {}
+    }
+  }
+  const owner = readDaemonLockOwner(lockPath);
+  return { acquired: false, path: lockPath, owner, release() {} };
+}
+
+function releaseDaemonLock(lockPath, token) {
+  const owner = readDaemonLockOwner(lockPath);
+  if (owner?.token !== token) return;
+  try { unlinkSync(lockPath); } catch {}
+}
+
+export function readDaemonLockOwner(lockPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(lockPath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPidAlive(pid) {
+  const parsed = Number(pid);
+  if (!Number.isInteger(parsed) || parsed <= 0) return false;
+  try {
+    process.kill(parsed, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+function readJsonObjectOrBackup(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    const backupPath = `${filePath}.corrupt-${Date.now()}`;
+    try { renameSync(filePath, backupPath); } catch {}
+    return {};
+  }
+}
+
+
 export function ensureWorkerSecrets(state, options = {}) {
   state.worker ||= {};
   if (!state.worker.oauthPassword || options.rotateSecrets) state.worker.oauthPassword = randomToken("mcp_password");
@@ -120,6 +207,14 @@ export function ensureWorkerSecrets(state, options = {}) {
   if (!state.worker.name || options.workerName) state.worker.name = options.workerName || defaultWorkerName(state.workspace.hash);
 }
 
+export function ensureLocalApiKey(state, options = {}) {
+  state.localApi ||= {};
+  if (options.apiKey && options.apiKey !== true) state.localApi.apiKey = String(options.apiKey);
+  if (!state.localApi.apiKey || options.rotateApiKey) state.localApi.apiKey = randomToken("local_api_key");
+  state.localApi.updatedAt = new Date().toISOString();
+  return state.localApi.apiKey;
+}
+
 export function defaultWorkerName(hash) {
   return `mbm-${String(hash || "default").slice(0, 12)}`;
 }
@@ -150,6 +245,7 @@ export function redactState(state) {
   if (clone.worker?.oauthPassword) clone.worker.oauthPassword = previewSecret(clone.worker.oauthPassword);
   if (clone.worker?.daemonSecret) clone.worker.daemonSecret = previewSecret(clone.worker.daemonSecret);
   if (clone.worker?.oauthTokenVersion) clone.worker.oauthTokenVersion = previewSecret(clone.worker.oauthTokenVersion);
+  if (clone.localApi?.apiKey) clone.localApi.apiKey = previewSecret(clone.localApi.apiKey);
   return clone;
 }
 

package/src/worker/index.ts

@@ -1,7 +1,7 @@
 import { DurableObject } from "cloudflare:workers";
 
 const SERVER_NAME = "machine-bridge-mcp";
-const SERVER_VERSION = "0.1.0";
+const SERVER_VERSION = "0.2.0";
 const MCP_PROTOCOL_VERSION = "2025-06-18";
 const JSONRPC_VERSION = "2.0";
 const DEFAULT_MAX_BODY_BYTES = 32 * 1024 * 1024;
@@ -353,7 +353,10 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
         tools: this.allTools().map((tool) => tool.name),
       };
     }
-    if (workspaceTools.some((tool) => tool.name === name)) return this.callDaemonTool(name, args);
+    if (workspaceTools.some((tool) => tool.name === name)) {
+      if (!this.daemonToolEnabled(name)) throw new Error(`tool disabled by local daemon policy: ${name}`);
+      return this.callDaemonTool(name, args);
+    }
     throw new Error(`unknown tool: ${name}`);
   }
 
@@ -399,7 +402,23 @@ export class BridgeRoom extends DurableObject<BridgeEnv> {
   }
 
   private allTools(): Array<Record<string, unknown>> {
-    return [serverInfoTool, ...workspaceTools].map((tool) => ({ ...tool }));
+    const advertised = this.daemonAdvertisedTools();
+    const localTools = advertised
+      ? workspaceTools.filter((tool) => advertised.has(tool.name))
+      : workspaceTools;
+    return [serverInfoTool, ...localTools].map((tool) => ({ ...tool }));
+  }
+
+  private daemonToolEnabled(name: string): boolean {
+    const advertised = this.daemonAdvertisedTools();
+    return !advertised || advertised.has(name);
+  }
+
+  private daemonAdvertisedTools(): Set<string> | null {
+    const socket = this.daemonSockets()[0];
+    const attachment = socket ? this.daemonAttachment(socket) : undefined;
+    if (!attachment?.tools?.length) return null;
+    return new Set(attachment.tools);
   }
 
   private daemonSockets(): WebSocket[] {
@@ -847,7 +866,6 @@ function validateOrigin(request: Request, base: string, configured = ""): boolea
   try {
     const parsed = new URL(origin);
     if (origin === base) return true;
-    if (parsed.protocol === "https:") return true;
     return parsed.protocol === "http:" && isLoopbackHost(parsed.hostname);
   } catch {
     return false;