machine-bridge-mcp 0.1.1 → 0.2.1

package/README.md

@@ -28,15 +28,18 @@ Source checkout:
 3. Generates a stable MCP connection password and daemon secret.
 4. Checks `wrangler whoami`; if needed, opens `wrangler login`.
 5. Deploys the hosted Worker relay with `wrangler deploy --secrets-file`.
-6. Installs login autostart for the local daemon.
-7. Starts the local daemon and prints:
+6. Installs login autostart for the local daemon and default local API provider.
+7. Starts the local daemon and local OpenAI-compatible API provider.
+8. Prints MCP connection details on first run, plus local API settings:
 
 ```text
 MCP Server URL: https://<worker>.<account>.workers.dev/mcp
 MCP connection password: mcp_password_...
+API Base URL: http://127.0.0.1:8765/v1
+API key: local_api_key_...
 ```
 
-Keep the foreground process running for the current session. The installed autostart entry keeps the daemon available after future logins.
+Keep the foreground process running for the current session. The installed autostart entry keeps the daemon and local API available after future logins.
 
 The command is safe to run repeatedly:
 
@@ -44,7 +47,87 @@ The command is safe to run repeatedly:
 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.
+On repeat runs, the CLI reuses existing state and secrets unless you request rotation, skips Worker redeploys when the deployed Worker is healthy and Worker source/config/secrets are 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-only package, CLI, logging, and API-provider changes do not by themselves force a Worker redeploy.
+
+MCP connection details are printed on first run, after secret rotation, when the MCP URL changes, or when you explicitly pass `--print-mcp-credentials`. Routine runs print that MCP details are unchanged.
+
+## Local OpenAI-compatible API provider
+
+`machine-bridge-mcp` exposes a local OpenAI-compatible API provider by default for desktop AI clients such as Cherry Studio, Chatbox, Continue, or other apps that accept an OpenAI-style base URL and API key. No extra command is needed; the recommended `machine-mcp` command starts both the Remote MCP daemon and the local API provider.
+
+Start the normal daemon and API provider:
+
+```zsh
+machine-mcp
+```
+
+Start only the local API service, without the Remote MCP daemon:
+
+```zsh
+machine-mcp api
+```
+
+Disable the default local API provider for a daemon run:
+
+```zsh
+machine-mcp --no-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-port 8766
+machine-mcp 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`, starts with `machine-mcp`, and stores a per-workspace local API key in the same owner-only state profile used by the MCP credentials. Explicit `--api-host`, `--api-port`, `--api-model`, and `--api-upstream-url` values are persisted for the workspace so autostart uses the same non-secret API settings; upstream API keys are not written to state. Rotate the local API key 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
 
@@ -165,7 +248,7 @@ 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 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.
+State contains the MCP password, daemon secret, and local API key. Status/doctor output redacts secrets. The normal foreground `start` command prints the MCP password only when a ChatGPT app is likely to need reconnection: first run, secret rotation, MCP URL changes, or `--print-mcp-credentials`. The local API base URL and API key print on normal foreground starts because desktop AI clients need them. 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.
 
@@ -183,6 +266,8 @@ flowchart LR
   W --> DO["Durable Object broker"]
   D["Local daemon"] -- "outbound WebSocket" --> W
   D --> M["Local filesystem and shell"]
+  API["Default 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"]
@@ -195,7 +280,8 @@ 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.
-- Autostart keeps the daemon alive across logins without requiring MCP clients to change URLs.
+- The local `/v1` API binds to loopback by default, starts automatically with the daemon, and can be disabled with `--no-api`.
+- Autostart keeps the daemon and local API 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.1",
+  "version": "0.2.1",
   "description": "One-command hosted Remote MCP bridge to a local machine daemon.",
   "type": "module",
   "license": "MIT",
@@ -35,7 +35,7 @@
     "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

@@ -9,6 +9,7 @@ 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();
@@ -23,7 +24,7 @@ if (!match) fail("Could not find `const SERVER_VERSION = \"...\";` in src/worker
 
 const current = match[1];
 if (current === expected) {
-  console.log(`Worker version is in sync: ${expected}`);
+  log(`Worker version is in sync: ${expected}`);
   process.exit(0);
 }
 
@@ -33,7 +34,7 @@ if (checkOnly) {
 
 const updated = source.replace(pattern, `const SERVER_VERSION = "${expected}";`);
 writeFileSync(workerPath, updated);
-console.log(`Updated Worker version: ${current} -> ${expected}`);
+log(`Updated Worker version: ${current} -> ${expected}`);
 
 function fail(message) {
   console.error(message);

package/src/local/api-server.mjs

@@ -0,0 +1,260 @@
+import http from "node:http";
+import { createHash, 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.");
+  }
+  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", api_key_sha256: sha256String(context.apiKey) });
+
+    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 sha256String(value) {
+  return createHash("sha256").update(String(value)).digest("hex");
+}
+
+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-port <free_port>\` or \`machine-mcp api --api-port <free_port>\`.`;
+  }
+  if (error?.code === "EACCES") {
+    error.message = `Local API port ${port} is not permitted. Re-run with \`machine-mcp --api-port <free_port>\` or \`machine-mcp api --api-port <free_port>\`.`;
+  }
+  return error;
+}

package/src/local/cli.mjs

@@ -4,12 +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,
@@ -29,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);
@@ -154,14 +159,21 @@ async function confirm(prompt, assumeYes = false) {
 
 async function startCommand(args) {
   assertNodeVersion();
+  const logger = createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "cli" });
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: true, save: true, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
+  const previousMcpServerUrl = state.worker?.mcpServerUrl || "";
+  const firstMcpConnection = !previousMcpServerUrl || !state.worker?.oauthPassword;
+  const apiEnabled = args.noApi ? false : true;
+
   ensureWorkerSecrets(state, { rotateSecrets: Boolean(args.rotateSecrets), workerName: args.workerName && String(args.workerName) });
+  if (apiEnabled) configureLocalApiState(state, args);
   state.policy = {
     allowWrite: args.noWrite ? false : true,
     allowExec: args.noExec ? false : true,
     unrestrictedPaths: true,
     minimalEnv: args.fullEnv ? false : true,
+    apiEnabled,
     updatedAt: new Date().toISOString(),
   };
   saveState(state);
@@ -169,6 +181,9 @@ async function startCommand(args) {
   if (!args.daemonOnly) await ensureWorker(state, args);
   else if (!state.worker.url) throw new Error("--daemon-only requires an existing worker URL in state; run start once without --daemon-only");
 
+  const mcpConnectionChanged = previousMcpServerUrl && previousMcpServerUrl !== state.worker.mcpServerUrl;
+  const shouldPrintMcpCredentials = Boolean(args.json || args.printMcpCredentials || args.printCredentials || firstMcpConnection || args.rotateSecrets || mcpConnectionChanged);
+
   if (!args.daemonOnly && !args.noAutostart) {
     await installAutostartBestEffort({ workspace, stateRoot: state.paths.stateRoot, entryScript: process.argv[1], policy: state.policy });
   }
@@ -176,54 +191,183 @@ async function startCommand(args) {
   if (!args.daemonOnly) await stopAutostartBestEffort(Boolean(args.quiet));
 
   const lock = acquireDaemonLock(state);
+  let daemon = null;
+  let apiServer = null;
   if (!lock.acquired) {
     if (!args.quiet) {
       const pid = lock.owner?.pid ? `pid ${lock.owner.pid}` : "unknown pid";
-      console.warn(`Local daemon is already running for this workspace (${pid}). Not starting a duplicate.`);
-      printConnection(state, { json: Boolean(args.json), noPrintCredentials: Boolean(args.noPrintCredentials) });
+      logger.warn(`local daemon already running for this workspace (${pid}); not starting a duplicate`);
+      if (!args.json) printMcpConnection(state, {
+        noPrintCredentials: Boolean(args.noPrintCredentials),
+        includeCredentials: shouldPrintMcpCredentials,
+        quiet: Boolean(args.quiet),
+      });
     }
+    if (!apiEnabled) {
+      if (args.json) printStartJson(state, null, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+      return;
+    }
+    apiServer = await startOptionalApiServer(state, args, logger);
+    if (args.json) printStartJson(state, apiServer, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+    else if (apiServer) printApiConnection(apiServer, state, { noPrintCredentials: Boolean(args.noPrintCredentials), quiet: Boolean(args.quiet) });
+    if (apiServer && !apiServer.alreadyRunning) keepProcessAlive({ apiServer, logger });
     return;
   }
 
   try {
-    const daemon = new LocalDaemon({
+    daemon = new LocalDaemon({
       workerUrl: state.worker.url,
       secret: state.worker.daemonSecret,
       workspace,
       policy: state.policy,
-      logger: structuredLogger(args.quiet),
+      logger: createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "daemon" }),
     });
 
     const waitForConnect = daemon.start();
-    await waitForConnectWithNotice(waitForConnect, 20_000);
-    printConnection(state, { json: Boolean(args.json), noPrintCredentials: Boolean(args.noPrintCredentials) });
-    keepProcessAlive(daemon, lock);
+    await waitForConnectWithNotice(waitForConnect, 20_000, Boolean(args.quiet || args.json));
+    if (apiEnabled) apiServer = await startOptionalApiServer(state, args, logger);
+    if (args.json) printStartJson(state, apiServer, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+    else {
+      printMcpConnection(state, {
+        noPrintCredentials: Boolean(args.noPrintCredentials),
+        includeCredentials: shouldPrintMcpCredentials,
+        quiet: Boolean(args.quiet),
+      });
+      if (apiServer) printApiConnection(apiServer, state, { noPrintCredentials: Boolean(args.noPrintCredentials), quiet: Boolean(args.quiet) });
+    }
+    keepProcessAlive({ daemon, lock, apiServer: apiServer?.alreadyRunning ? null : apiServer, logger });
   } catch (error) {
+    try { daemon?.stop?.(); } catch {}
     lock.release();
+    if (apiServer && !apiServer.alreadyRunning) 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 });
+  configureLocalApiState(state, args);
+  saveState(state);
+  const logger = createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "api" });
+  const apiServer = await startConfiguredApiServer(state, args, logger);
+  if (args.json) printApiJson(apiServer, state, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+  else printApiConnection(apiServer, state, { noPrintCredentials: Boolean(args.noPrintCredentials), quiet: Boolean(args.quiet) });
+  keepProcessAlive({ apiServer, logger });
+}
+
+async function startConfiguredApiServer(state, args, logger = createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "api" })) {
+  const apiOptions = apiOptionsFromArgs(state, args);
+  return startLocalApiServer({ ...apiOptions, logger });
+}
+
+async function startOptionalApiServer(state, args, parentLogger) {
+  const logger = createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "api" });
+  const apiOptions = apiOptionsFromArgs(state, args);
+  try {
+    return await startLocalApiServer({ ...apiOptions, logger });
+  } catch (error) {
+    if (error?.code === "EADDRINUSE") {
+      const baseUrl = apiBaseUrl(apiOptions.host, apiOptions.port);
+      const health = await probeLocalApiHealth(baseUrl, state.localApi?.apiKey);
+      if (health.ok) {
+        logger.success("local OpenAI-compatible API already running", { baseUrl });
+        return { ...health, baseUrl, host: apiOptions.host, port: Number(apiOptions.port), alreadyRunning: true, close() { return Promise.resolve(); } };
+      }
+      parentLogger.warn(error.message);
+      return null;
+    }
+    parentLogger.warn(`Local API provider skipped: ${error.message}`);
+    return null;
+  }
+}
+
+function apiBaseUrl(host, port) {
+  const textHost = String(host || DEFAULT_API_HOST);
+  const urlHost = textHost.includes(":") && !textHost.startsWith("[") ? `[${textHost}]` : textHost;
+  return `http://${urlHost}:${port || DEFAULT_API_PORT}/v1`;
+}
+
+async function probeLocalApiHealth(baseUrl, expectedApiKey = "") {
+  try {
+    const healthUrl = `${String(baseUrl).replace(/\/v1$/, "")}/health`;
+    const response = await fetch(healthUrl, { signal: AbortSignal.timeout(750) });
+    if (!response.ok) return { ok: false };
+    const body = await response.json().catch(() => null);
+    if (body?.service !== "machine-bridge-mcp-local-api") return { ok: false };
+    if (body.api_key_sha256 && expectedApiKey && body.api_key_sha256 !== sha256String(expectedApiKey)) return { ok: false, reason: "api_key_mismatch" };
+    return { ok: true };
+  } catch {
+    return { ok: false };
+  }
+}
+
+function apiOptionsFromArgs(state, args = {}) {
+  const upstreamKey = valueFromArgsEnv(args.apiUpstreamKey, "MBM_API_UPSTREAM_KEY", "OPENAI_API_KEY");
+  const explicitPort = explicitArg(args.apiPort) ?? explicitArg(args.port);
+  const envPort = valueFromArgsEnv(undefined, "MBM_API_PORT", "PORT");
+  return {
+    host: valueFromArgsEnv(args.apiHost, "MBM_API_HOST") || state.localApi?.host || DEFAULT_API_HOST,
+    port: explicitPort ?? envPort ?? state.localApi?.port ?? 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") || state.localApi?.upstreamUrl || DEFAULT_UPSTREAM_URL,
+    upstreamKey: upstreamKey || "",
+    model: valueFromArgsEnv(args.apiModel, "MBM_API_MODEL", "OPENAI_MODEL") || state.localApi?.model || DEFAULT_API_MODEL,
+  };
+}
+
+function configureLocalApiState(state, args = {}) {
+  state.localApi ||= {};
+  ensureLocalApiKey(state, { apiKey: valueFromArgsEnv(args.apiKey, "MBM_API_KEY"), rotateApiKey: Boolean(args.rotateApiKey) });
+  const port = explicitArg(args.apiPort) ?? explicitArg(args.port);
+  if (port !== undefined && String(port) !== "0") state.localApi.port = String(port);
+  const host = explicitArg(args.apiHost);
+  if (host !== undefined) state.localApi.host = String(host);
+  const upstreamUrl = explicitArg(args.apiUpstreamUrl);
+  if (upstreamUrl !== undefined) state.localApi.upstreamUrl = String(upstreamUrl);
+  const model = explicitArg(args.apiModel);
+  if (model !== undefined) state.localApi.model = String(model);
+  state.localApi.updatedAt = new Date().toISOString();
+}
+
+function explicitArg(value) {
+  return value !== undefined && value !== null && value !== true ? String(value) : undefined;
+}
+
+function sha256String(value) {
+  return createHash("sha256").update(String(value)).digest("hex");
+}
+
+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 || args.json), 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,
@@ -241,8 +385,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;
 }
 
@@ -284,14 +428,22 @@ function workerDeployHash(state) {
   hash.update(String(state.worker.oauthTokenVersion || ""));
   for (const file of workerDeployHashFiles()) {
     hash.update(path.relative(packageRoot, file));
-    hash.update(readFileSync(file));
+    hash.update(workerHashContent(file));
   }
   return hash.digest("hex");
 }
 
+function workerHashContent(file) {
+  const content = readFileSync(file, "utf8");
+  if (path.relative(packageRoot, file).replaceAll("\\", "/") === "src/worker/index.ts") {
+    return content.replace(/const SERVER_VERSION = "[^"]+";/, 'const SERVER_VERSION = "<ignored-for-deploy-hash>";');
+  }
+  return content;
+}
+
 function workerDeployHashFiles() {
   const files = [];
-  for (const item of ["src/worker", "wrangler.jsonc", "tsconfig.json", "package.json", "package-lock.json"]) {
+  for (const item of ["src/worker", "wrangler.jsonc", "tsconfig.json"]) {
     collectHashFiles(resolve(packageRoot, item), files);
   }
   return files.sort();
@@ -341,17 +493,53 @@ function extractWorkerUrl(text = "") {
   return anyHttps.find(match => /workers\.dev|\/healthz|\/mcp/.test(match[0]))?.[0]?.replace(/[),.]+$/, "") || "";
 }
 
-async function waitForConnectWithNotice(promise, timeoutMs) {
+async function waitForConnectWithNotice(promise, timeoutMs, quiet = false) {
   let timeout;
   const timed = new Promise(resolvePromise => {
     timeout = setTimeout(() => resolvePromise("timeout"), 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", quiet }).warn("Still connecting; the process will keep retrying");
+}
+
+
+function printStartJson(state, apiServer, { noPrintCredentials = false } = {}) {
+  const mcpPassword = noPrintCredentials ? previewSecret(state.worker.oauthPassword) : state.worker.oauthPassword;
+  const apiKey = state.localApi?.apiKey ? (noPrintCredentials ? previewSecret(state.localApi.apiKey) : state.localApi.apiKey) : null;
+  createLogger({ component: "ready" }).json({
+    mcp: {
+      server_url: state.worker.mcpServerUrl,
+      connection_password: mcpPassword,
+      worker_url: state.worker.url,
+      worker_name: state.worker.name,
+    },
+    local_api: apiServer ? {
+      base_url: apiServer.baseUrl,
+      api_key: apiKey,
+      already_running: Boolean(apiServer.alreadyRunning),
+      client_type: "OpenAI-compatible",
+    } : null,
+    workspace: state.workspace.path,
+    state_path: state.paths.statePath,
+    policy: state.policy,
+  });
+}
+
+function printApiJson(apiServer, state, { noPrintCredentials = false } = {}) {
+  createLogger({ component: "ready" }).json({
+    local_api: {
+      base_url: apiServer.baseUrl,
+      api_key: noPrintCredentials ? previewSecret(state.localApi.apiKey) : state.localApi.apiKey,
+      client_type: "OpenAI-compatible",
+    },
+    workspace: state.workspace.path,
+    state_path: state.paths.statePath,
+  });
 }
 
-function printConnection(state, { json = false, noPrintCredentials = false } = {}) {
+function printMcpConnection(state, { json = false, noPrintCredentials = false, includeCredentials = false, quiet = false } = {}) {
+  const logger = createLogger({ component: "ready", quiet });
   const payload = {
     mcp_server_url: state.worker.mcpServerUrl,
     mcp_connection_password: state.worker.oauthPassword,
@@ -363,27 +551,44 @@ 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, lock) {
-  const stop = () => {
-    console.log("Stopping daemon...");
-    daemon.stop();
-    lock?.release?.();
+  if (includeCredentials) {
+    logger.success("Remote MCP bridge is ready; save these connection details if your ChatGPT app needs to reconnect");
+    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)`);
+  } else {
+    logger.success("Remote MCP bridge is ready; MCP connection details unchanged");
+    logger.plain("  Use --print-mcp-credentials only when a ChatGPT app needs to reconnect.");
+  }
+  logger.plain(`  Workspace cwd: ${payload.workspace}`);
+  logger.plain(`  Policy: write=${payload.policy.allowWrite ? "on" : "off"}, exec=${payload.policy.allowExec ? "on" : "off"}, local_api=${payload.policy.apiEnabled === false ? "off" : "on"}, unrestricted_paths=${payload.policy.unrestrictedPaths ? "on" : "off"}`);
+  logger.plain(`  State: ${payload.state_path}`);
+}
+
+function printApiConnection(apiServer, state, { noPrintCredentials = false, quiet = false } = {}) {
+  const logger = createLogger({ component: "ready", quiet });
+  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);
 }
@@ -537,12 +742,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) {
@@ -577,7 +777,8 @@ Usage:
   .\\mbm.cmd                                      # from source checkout on Windows cmd
 
 Commands:
-  start             Deploy/update Worker, install autostart, start local daemon
+  start             Deploy/update Worker, install autostart, start daemon and local API
+  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
@@ -597,12 +798,23 @@ 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-print-credentials Redact credentials in console output
+  --print-mcp-credentials Print MCP URL/password again for reconnecting ChatGPT apps
   --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
+  --json                Print MCP and local API connection details as JSON
+  --no-api              Do not start the local OpenAI-compatible API provider
+  --api                 Deprecated no-op; local API starts by default
+  --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
@@ -610,6 +822,40 @@ Uninstall options:
 `);
 }
 
+function apiUsage() {
+  console.log(`machine-bridge-mcp local API provider
+
+Usage:
+  machine-mcp
+  machine-mcp --api-port 8766
+  machine-mcp api                    # API provider only
+  machine-mcp 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
+  --no-api                Only valid for start; disables the default local API provider
+  --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

@@ -1,12 +1,16 @@
+import { createHash } from "node:crypto";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { daemonSelfTest } from "./daemon.mjs";
-import { acquireDaemonLock, 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,6 +20,7 @@ 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 {
@@ -33,9 +38,59 @@ async function stateSelfTest() {
     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 healthPayload = await health.json();
+    const expectedHash = createHash("sha256").update("local-test-key").digest("hex");
+    if (healthPayload.api_key_sha256 !== expectedHash) throw new Error("health did not expose expected API key hash");
+    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

@@ -54,6 +54,7 @@ function serviceSpec({ workspace, stateRoot, entryScript, policy = {} }) {
       allowWrite: policy.allowWrite !== false,
       allowExec: policy.allowExec !== false,
       minimalEnv: policy.minimalEnv !== false,
+      apiEnabled: policy.apiEnabled !== false,
     },
   };
 }
@@ -71,6 +72,7 @@ function daemonArgs(spec) {
   if (spec.policy.allowWrite === false) args.push("--no-write");
   if (spec.policy.allowExec === false) args.push("--no-exec");
   if (spec.policy.minimalEnv === false) args.push("--full-env");
+  if (spec.policy.apiEnabled === false) args.push("--no-api");
   return args;
 }
 

package/src/local/state.mjs

@@ -207,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)}`;
 }
@@ -237,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.1";
+const SERVER_VERSION = "0.2.1";
 const MCP_PROTOCOL_VERSION = "2025-06-18";
 const JSONRPC_VERSION = "2.0";
 const DEFAULT_MAX_BODY_BYTES = 32 * 1024 * 1024;