machine-bridge-mcp 0.15.0 → 0.16.1

package/src/local/cli.mjs

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import path, { join, resolve } from "node:path";
@@ -7,11 +6,15 @@ import readline from "node:readline/promises";
 import { LocalRuntime } from "./runtime.mjs";
 import { acquireDaemonLockWithTakeover, inspectWorkspaceDaemon, stopWorkspaceServiceDaemon } from "./daemon-process.mjs";
 import { runStdioServer } from "./stdio.mjs";
-import { assertCanonicalFullPolicy, DEFAULT_POLICY_PROFILE, DEFAULT_POLICY_REVISION, POLICY_PROFILES, normalizePolicy, policyProfile, toolsForPolicy } from "./tools.mjs";
+import { assertCanonicalFullPolicy, POLICY_PROFILES, toolsForPolicy } from "./tools.mjs";
+import { resolvePolicy } from "./cli-policy.mjs";
+import { effectiveLogFormat, effectiveLogLevel, normalizeCommand, parseArgs, validateCommandOptions, validateLoggingOptions, validatePositionals } from "./cli-options.mjs";
+import { createLocalAdminCommands } from "./cli-local-admin.mjs";
+export { resolvePolicy } from "./cli-policy.mjs";
+export { parseArgs, validateCommandOptions, validateLoggingOptions, validatePositionals } from "./cli-options.mjs";
 import { classifyOperationalError, createLogger, normalizeLogLevel, sanitizeLogText } from "./log.mjs";
-import { activeManagedJobs, inspectResourceFile, loadManagedJobPlan, ManagedJobManager, publicResourceRegistry, validateResourceName } from "./managed-jobs.mjs";
+import { activeManagedJobs } from "./managed-jobs.mjs";
 import { run, runWrangler } from "./shell.mjs";
-import { generateRegisteredSshKey } from "./resource-operations.mjs";
 import { runFullAccessTest } from "./full-access-test.mjs";
 import { readBoundedRegularFileSync } from "./secure-file.mjs";
 import { inspectProcessInstance } from "./process-identity.mjs";
@@ -42,15 +45,7 @@ import {
   setSelectedWorkspace,
 } from "./state.mjs";
 
-const BOOLEAN_OPTIONS = new Set([
-  "help", "version", "quiet", "json", "verbose", "rotateSecrets", "forceWorker",
-  "daemonOnly", "noAutostart", "noPrintCredentials", "printMcpCredentials",
-  "printCredentials", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
-  "yes", "keepWorker", "allowInsecurePermissions", "showPaths",
-]);
-const VALUE_OPTIONS = new Set([
-  "workspace", "stateDir", "workerName", "profile", "execMode", "client", "logLevel",
-]);
+const localAdminCommands = createLocalAdminCommands({ chooseWorkspace, confirm });
 
 const COMMAND_HANDLERS = Object.freeze({
   start: startCommand,
@@ -63,9 +58,9 @@ const COMMAND_HANDLERS = Object.freeze({
   service: serviceCommand,
   autostart: serviceCommand,
   "rotate-secrets": rotateSecretsCommand,
-  resource: resourceCommand,
-  browser: browserCommand,
-  job: jobCommand,
+  resource: localAdminCommands.resourceCommand,
+  browser: localAdminCommands.browserCommand,
+  job: localAdminCommands.jobCommand,
   uninstall: uninstallCommand,
 });
 
@@ -85,155 +80,6 @@ export async function main(argv = process.argv.slice(2)) {
   process.exitCode = 2;
 }
 
-const COMMAND_OPTIONS = {
-  start: new Set([
-    "workspace", "stateDir", "workerName", "quiet", "json", "verbose", "logLevel", "rotateSecrets", "forceWorker",
-    "daemonOnly", "noAutostart", "noPrintCredentials", "printMcpCredentials", "printCredentials",
-    "profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
-  ]),
-  stdio: new Set(["workspace", "stateDir", "profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths", "verbose", "quiet", "logLevel"]),
-  "client-config": new Set(["workspace", "stateDir", "profile", "client", "json"]),
-  status: new Set(["workspace", "stateDir"]),
-  doctor: new Set(["workspace", "stateDir"]),
-  "full-test": new Set(["workspace", "stateDir", "json"]),
-  "rotate-secrets": new Set(["workspace", "stateDir", "workerName", "noPrintCredentials", "printMcpCredentials", "printCredentials", "quiet"]),
-  workspace: new Set(["workspace", "stateDir"]),
-  service: new Set(["workspace", "stateDir", "quiet"]),
-  autostart: new Set(["workspace", "stateDir", "quiet"]),
-  resource: new Set(["workspace", "stateDir", "allowInsecurePermissions", "showPaths", "json"]),
-  browser: new Set(["workspace", "stateDir", "json"]),
-  job: new Set(["workspace", "stateDir", "json", "yes"]),
-  uninstall: new Set(["stateDir", "keepWorker", "yes"]),
-};
-
-export function validateCommandOptions(command, args) {
-  const allowed = COMMAND_OPTIONS[command];
-  if (!allowed) return;
-  for (const key of Object.keys(args)) {
-    if (key === "_" || key === "help" || key === "version") continue;
-    if (!allowed.has(key)) throw new Error(`Option --${toKebab(key)} is not valid for ${command}`);
-  }
-}
-
-export function validateLoggingOptions(args = {}) {
-  if (args.quiet && args.verbose) throw new Error("--quiet and --verbose cannot be used together");
-  if (args.logLevel !== undefined && (args.quiet || args.verbose)) {
-    throw new Error("--log-level cannot be combined with --quiet or --verbose");
-  }
-  if (args.logLevel !== undefined) normalizeLogLevel(args.logLevel);
-}
-
-function effectiveLogLevel(args = {}) {
-  if (args.logLevel !== undefined) return normalizeLogLevel(args.logLevel);
-  if (args.quiet) return "error";
-  if (args.verbose) return "debug";
-  return "info";
-}
-
-function toKebab(value) {
-  return String(value).replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`);
-}
-
-const SINGLE_WORKSPACE_POSITIONAL_COMMANDS = new Set(["start", "stdio", "status", "doctor", "full-test", "rotate-secrets"]);
-const STATIC_POSITIONAL_RULES = Object.freeze({
-  "client-config": Object.freeze({ max: 1, tooMany: "client-config accepts at most one positional client name" }),
-  uninstall: Object.freeze({ max: 0, tooMany: "uninstall does not accept positional arguments" }),
-});
-const RESOURCE_POSITIONAL_LIMITS = Object.freeze({ add: 3, "generate-ssh-key": 3, remove: 2, check: 2 });
-const JOB_POSITIONAL_LIMITS = Object.freeze({ read: 2, inspect: 2, cancel: 2, approve: 2, submit: 2 });
-const ACTION_POSITIONAL_RULES = Object.freeze({
-  workspace(args) {
-    const action = String(args._[0] || "show");
-    return { max: action === "set" || action === "select" ? 2 : 1, tooMany: `workspace ${action} received too many positional arguments`, workspaceConflictAfter: 1 };
-  },
-  service(args) {
-    const action = String(args._[0] || "status");
-    return { max: ["install", "status", "stop", "uninstall", "remove"].includes(action) ? 2 : 1, tooMany: `service ${action} received too many positional arguments`, workspaceConflictAfter: 1 };
-  },
-  autostart(args) {
-    return ACTION_POSITIONAL_RULES.service(args);
-  },
-  resource(args) {
-    const action = String(args._[0] || "list");
-    return { max: RESOURCE_POSITIONAL_LIMITS[action] ?? 1, tooMany: `resource ${action} received too many positional arguments` };
-  },
-  browser(args) {
-    const action = String(args._[0] || "status");
-    return { max: 1, tooMany: `browser ${action} received too many positional arguments` };
-  },
-  job(args) {
-    const action = String(args._[0] || "list");
-    return { max: JOB_POSITIONAL_LIMITS[action] ?? 1, tooMany: `job ${action} received too many positional arguments` };
-  },
-});
-
-export function validatePositionals(command, args) {
-  const count = args._.length;
-  const rule = positionalRule(command, args);
-  if (!rule) return;
-  if (count > rule.max) throw new Error(rule.tooMany);
-  if (args.workspace && Number.isInteger(rule.workspaceConflictAfter) && count > rule.workspaceConflictAfter) {
-    throw new Error("workspace path was provided both positionally and with --workspace");
-  }
-}
-
-function positionalRule(command, args) {
-  if (SINGLE_WORKSPACE_POSITIONAL_COMMANDS.has(command)) {
-    return {
-      max: 1,
-      tooMany: `${command} accepts at most one positional workspace path`,
-      workspaceConflictAfter: 0,
-    };
-  }
-  if (STATIC_POSITIONAL_RULES[command]) return STATIC_POSITIONAL_RULES[command];
-  return ACTION_POSITIONAL_RULES[command]?.(args) || null;
-}
-
-function normalizeCommand(argv) {
-  if (!argv.length || argv[0].startsWith("--")) return ["start", argv];
-  return [argv[0], argv.slice(1)];
-}
-
-export function parseArgs(argv) {
-  const out = { _: [] };
-  let positionalOnly = false;
-  for (let i = 0; i < argv.length; i += 1) {
-    const raw = argv[i];
-    if (positionalOnly || raw === "-" || !raw.startsWith("--")) {
-      out._.push(raw);
-      continue;
-    }
-    if (raw === "--") {
-      positionalOnly = true;
-      continue;
-    }
-    const eq = raw.indexOf("=");
-    const rawKey = raw.slice(2, eq >= 0 ? eq : undefined);
-    if (!rawKey) throw new Error("invalid empty option");
-    const key = toCamel(rawKey);
-    if (!BOOLEAN_OPTIONS.has(key) && !VALUE_OPTIONS.has(key)) throw new Error(`Unknown option: --${rawKey}`);
-    if (Object.prototype.hasOwnProperty.call(out, key)) throw new Error(`Duplicate option: --${rawKey}`);
-    if (BOOLEAN_OPTIONS.has(key)) {
-      out[key] = eq >= 0 ? parseBooleanOption(raw.slice(eq + 1), rawKey) : true;
-      continue;
-    }
-    const value = eq >= 0 ? raw.slice(eq + 1) : argv[++i];
-    if (value === undefined || value === "" || value.startsWith("--")) throw new Error(`Option --${rawKey} requires a value`);
-    out[key] = value;
-  }
-  return out;
-}
-
-function parseBooleanOption(value, key) {
-  if (value === "true" || value === "1") return true;
-  if (value === "false" || value === "0") return false;
-  throw new Error(`Option --${key} expects true or false when using =`);
-}
-
-function toCamel(key) {
-  return key.replace(/-([a-z])/g, (_, ch) => ch.toUpperCase());
-}
-
 function stateRootFromArgs(args) {
   return args.stateDir ? expandHome(String(args.stateDir)) : defaultStateRoot();
 }
@@ -314,7 +160,7 @@ async function confirm(prompt, assumeYes = false) {
 
 async function startCommand(args) {
   assertNodeVersion();
-  const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), component: "cli" });
+  const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "cli" });
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: true, save: true, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
   const startupLock = await acquireStartupLockWithWait(state, { operation: "start", logger });
@@ -442,7 +288,7 @@ function createRemoteRuntime({ args, workspace, state, daemonLock, logger }) {
     expectedRelayVersion: currentPackageVersion(),
     workspace,
     policy: state.policy,
-    logger: createLogger({ level: args.json ? "error" : effectiveLogLevel(args), component: "daemon" }),
+    logger: createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "daemon" }),
     jobRoot: join(state.paths.profileDir, "jobs"),
     resources: state.resources,
     resourceStatePath: state.paths.statePath,
@@ -475,77 +321,6 @@ function reportRemoteReady(args, state, readiness) {
   });
 }
 
-export function resolvePolicy(args = {}, stored = {}) {
-  const hasStored = stored && typeof stored === "object" && (
-    typeof stored.allowWrite === "boolean" || typeof stored.allowExec === "boolean" || typeof stored.execMode === "string"
-  );
-  const explicitKeys = ["profile", ...POLICY_OVERRIDE_KEYS];
-  const hasExplicit = explicitKeys.some((key) => Object.prototype.hasOwnProperty.call(args, key));
-  const base = selectPolicyBase(args, stored, hasStored);
-  if (!hasExplicit) return normalizePolicy(base);
-  applyPolicyOverrides(base, args);
-  if (args.profile === undefined || POLICY_OVERRIDE_KEYS.some((key) => Object.prototype.hasOwnProperty.call(args, key))) {
-    base.profile = "custom";
-    base.origin = "custom";
-    base.revision = DEFAULT_POLICY_REVISION;
-  }
-  return normalizePolicy(base);
-}
-
-const POLICY_OVERRIDE_KEYS = Object.freeze(["execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths"]);
-
-function selectPolicyBase(args, stored, hasStored) {
-  if (args.profile !== undefined) {
-    const profile = String(args.profile).trim().toLowerCase();
-    if (!POLICY_PROFILES[profile]) throw new Error(`--profile must be one of: ${Object.keys(POLICY_PROFILES).join(", ")}`);
-    return policyProfile(profile, "explicit");
-  }
-  if (hasStored) return migrateLegacyPolicy(stored);
-  return policyProfile(DEFAULT_POLICY_PROFILE, "default");
-}
-
-function applyPolicyOverrides(policy, args) {
-  if (args.execMode !== undefined) {
-    const execMode = String(args.execMode).trim().toLowerCase();
-    if (!["off", "direct", "shell"].includes(execMode)) throw new Error("--exec-mode must be off, direct, or shell");
-    policy.execMode = execMode;
-  }
-  applyBooleanOverride(args, "noWrite", (enabled) => { policy.allowWrite = !enabled; });
-  applyBooleanOverride(args, "noExec", (enabled) => {
-    if (enabled) policy.execMode = "off";
-    else if (policy.execMode === "off") policy.execMode = "direct";
-  });
-  applyBooleanOverride(args, "fullEnv", (enabled) => { policy.minimalEnv = !enabled; });
-  applyBooleanOverride(args, "unrestrictedPaths", (enabled) => { policy.unrestrictedPaths = enabled; });
-  applyBooleanOverride(args, "absolutePaths", (enabled) => { policy.exposeAbsolutePaths = enabled; });
-}
-
-function applyBooleanOverride(args, key, apply) {
-  if (typeof args[key] === "boolean") apply(args[key]);
-}
-
-function migrateLegacyPolicy(stored = {}) {
-  if (stored.origin === "default" && Number(stored.revision || 0) < DEFAULT_POLICY_REVISION) {
-    return policyProfile(DEFAULT_POLICY_PROFILE, "default");
-  }
-  if (stored.origin === "migrated" && Number(stored.revision || 0) < DEFAULT_POLICY_REVISION) {
-    return policyProfile(DEFAULT_POLICY_PROFILE, "migrated");
-  }
-  if (stored.origin) return normalizePolicy(stored);
-  const normalized = normalizePolicy(stored);
-  const looksLikeLegacyImplicitDefault = (
-    normalized.profile === "custom" &&
-    normalized.allowWrite === true &&
-    normalized.execMode === "shell" &&
-    normalized.unrestrictedPaths === false &&
-    normalized.minimalEnv === true &&
-    normalized.exposeAbsolutePaths === false
-  );
-  if (looksLikeLegacyImplicitDefault) return policyProfile("full", "migrated");
-  return normalizePolicy({ ...normalized, origin: "legacy-preserved", revision: DEFAULT_POLICY_REVISION });
-}
-
-
 async function stdioCommand(args) {
   assertNodeVersion();
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
@@ -555,6 +330,7 @@ async function stdioCommand(args) {
     workspace,
     policy,
     logLevel: effectiveLogLevel(args),
+    logFormat: effectiveLogFormat(args),
     jobRoot: join(state.paths.profileDir, "jobs"),
     resources: state.resources,
     resourceStatePath: state.paths.statePath,
@@ -562,288 +338,6 @@ async function stdioCommand(args) {
   });
 }
 
-const RESOURCE_ACTION_HANDLERS = Object.freeze({
-  list: resourceListAction,
-  add: resourceAddAction,
-  "generate-ssh-key": resourceGenerateSshKeyAction,
-  remove: resourceRemoveAction,
-  check: resourceCheckAction,
-});
-
-async function resourceCommand(args) {
-  const action = String(args._[0] || "list").toLowerCase();
-  const handler = RESOURCE_ACTION_HANDLERS[action];
-  if (!handler) throw new Error(`Unknown resource action: ${action}`);
-  const workspace = await chooseWorkspace({ ...args, _: [] }, { promptOnFirstRun: false, save: false, allowPositional: false });
-  const state = loadState(workspace, { stateDir: args.stateDir });
-  state.resources ||= {};
-  return handler({ args, workspace, state });
-}
-
-function resourceListAction({ args, workspace, state }) {
-  const includePaths = args.showPaths === true;
-  const resources = publicResourceRegistry(state.resources, { includePaths });
-  if (args.json) {
-    console.log(JSON.stringify({
-      workspace: includePaths ? workspace : "<local-workspace>",
-      paths_exposed: includePaths,
-      resources,
-    }, null, 2));
-    return;
-  }
-  if (!Object.keys(resources).length) {
-    console.log("No local resources registered.");
-    return;
-  }
-  for (const [name, value] of Object.entries(resources)) {
-    const fields = [name, value.mode || "n/a", `${value.size ?? "n/a"} bytes`];
-    if (includePaths) fields.splice(1, 0, value.path);
-    console.log(fields.join("	"));
-  }
-}
-
-async function resourceAddAction({ args, workspace, state }) {
-  const name = validateResourceName(args._[1]);
-  const inputPath = args._[2];
-  if (!inputPath) throw new Error("resource add requires NAME and FILE_PATH");
-  const lock = await acquireStartupLockWithWait(state, { operation: "resource-add" });
-  try {
-    const latest = loadState(workspace, { stateDir: args.stateDir });
-    latest.resources ||= {};
-    const inspected = inspectResourceFile(expandHome(inputPath), { allowInsecurePermissions: args.allowInsecurePermissions === true });
-    if (!Object.prototype.hasOwnProperty.call(latest.resources, name) && Object.keys(latest.resources).length >= 64) {
-      throw new Error("local resource registry limit reached (64)");
-    }
-    latest.resources[name] = inspected;
-    saveState(latest);
-    const result = publicResourceInspection(name, inspected, {
-      includePath: args.showPaths === true,
-      available_to_new_jobs_immediately: true,
-    });
-    if (args.json) console.log(JSON.stringify(result, null, 2));
-    else {
-      console.log(`Registered local resource: ${name}`);
-      if (args.showPaths === true) console.log(`Path: ${inspected.path}`);
-      console.log(`Mode: ${inspected.mode || "n/a"}; size: ${inspected.size} bytes`);
-      console.log("The resource is available to newly submitted managed jobs immediately.");
-    }
-  } finally {
-    lock.release();
-  }
-}
-
-async function resourceGenerateSshKeyAction({ args, workspace }) {
-  const name = validateResourceName(args._[1]);
-  const home = process.env.HOME || process.env.USERPROFILE;
-  if (!home) throw new Error("HOME or USERPROFILE is required to choose a default SSH key path");
-  const requestedPath = args._[2] ? expandHome(args._[2]) : join(home, ".ssh", `machine-mcp-${name}-ed25519`);
-  const key = await generateRegisteredSshKey({
-    workspace,
-    stateDir: args.stateDir,
-    name,
-    targetPath: requestedPath,
-    comment: `machine-mcp:${name}`,
-  });
-  const includePaths = args.showPaths === true;
-  const result = {
-    name: key.name,
-    created: key.created,
-    fingerprint: key.fingerprint,
-    key_type: key.keyType,
-    private_mode: key.privateMode,
-    public_mode: key.publicMode,
-    private_key_content_exposed: key.privateKeyContentExposed,
-    registered: key.registered,
-    available_to_new_jobs_immediately: key.availableToNewJobsImmediately,
-    paths_exposed: includePaths,
-    ...(includePaths ? { private_key_path: key.privateKeyPath, public_key_path: key.publicKeyPath } : {}),
-  };
-  if (args.json) console.log(JSON.stringify(result, null, 2));
-  else {
-    console.log(`${key.created ? "Generated and registered" : "Reused and registered"} SSH key resource: ${name}`);
-    if (includePaths) {
-      console.log(`Private key: ${key.privateKeyPath}`);
-      console.log(`Public key: ${key.publicKeyPath}`);
-    }
-    console.log(`Fingerprint: ${key.fingerprint}`);
-    console.log("Private key content was not printed or sent through MCP.");
-  }
-}
-
-async function resourceRemoveAction({ args, workspace, state }) {
-  const name = validateResourceName(args._[1]);
-  const lock = await acquireStartupLockWithWait(state, { operation: "resource-remove" });
-  try {
-    const latest = loadState(workspace, { stateDir: args.stateDir });
-    latest.resources ||= {};
-    const existed = Object.prototype.hasOwnProperty.call(latest.resources, name);
-    delete latest.resources[name];
-    saveState(latest);
-    const result = { name, removed: existed, affects_new_jobs_immediately: true };
-    if (args.json) console.log(JSON.stringify(result, null, 2));
-    else {
-      console.log(existed ? `Removed local resource: ${name}` : `Local resource was not registered: ${name}`);
-      console.log("The change applies to newly submitted managed jobs immediately.");
-    }
-  } finally {
-    lock.release();
-  }
-}
-
-function resourceCheckAction({ args, state }) {
-  const name = validateResourceName(args._[1]);
-  const resource = state.resources[name];
-  if (!resource) throw new Error(`local resource is not registered: ${name}`);
-  const inspected = inspectResourceFile(resource.path, { allowInsecurePermissions: resource.allowInsecurePermissions === true });
-  const result = publicResourceInspection(name, inspected, { includePath: args.showPaths === true });
-  if (args.json) console.log(JSON.stringify(result, null, 2));
-  else {
-    const pathDetail = args.showPaths === true ? ` at ${inspected.path}` : "";
-    console.log(`${name}: available${pathDetail} (${inspected.mode || "n/a"}, ${inspected.size} bytes)`);
-  }
-}
-
-function publicResourceInspection(name, inspected, { includePath = false, ...extra } = {}) {
-  return {
-    name,
-    kind: inspected.kind,
-    size: inspected.size ?? null,
-    mode: inspected.mode ?? null,
-    updated_at: inspected.updatedAt ?? null,
-    allow_insecure_permissions: inspected.allowInsecurePermissions === true,
-    ...extra,
-    paths_exposed: includePath,
-    contents_exposed: false,
-    ...(includePath ? { path: inspected.path } : {}),
-  };
-}
-
-async function browserCommand(args) {
-  const action = String(args._[0] || "status").toLowerCase();
-  const extensionPath = resolve(packageRoot, "browser-extension");
-  if (action === "path") {
-    if (args.json) console.log(JSON.stringify({ extension_path: extensionPath }, null, 2));
-    else console.log(extensionPath);
-    return;
-  }
-  if (!["status", "setup", "pair"].includes(action)) throw new Error(`Unknown browser action: ${action}`);
-  const workspace = await chooseWorkspace({ ...args, _: [] }, { promptOnFirstRun: false, save: false, allowPositional: false });
-  const state = loadState(workspace, { stateDir: args.stateDir });
-  const pairingFile = join(state.paths.stateRoot, "browser-bridge.json");
-  if (!existsSync(pairingFile)) {
-    throw new Error("browser bridge is not initialized; start machine-mcp once, then run this command again");
-  }
-  ownerOnlyFile(pairingFile);
-  let pairing;
-  try {
-    pairing = JSON.parse(readBoundedRegularFileSync(pairingFile, 64 * 1024).toString("utf8"));
-  } catch {
-    throw new Error("browser bridge state is invalid; restart machine-mcp to repair it");
-  }
-  const port = Number(pairing.port);
-  if (!/^[A-Za-z0-9_-]{32,100}$/.test(String(pairing.token || ""))) throw new Error("browser bridge state contains an invalid token");
-  if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error("browser bridge state contains an invalid port");
-  const pairingUrl = `http://127.0.0.1:${port}/pair`;
-  const healthUrl = `http://127.0.0.1:${port}/healthz`;
-  const health = await fetch(healthUrl, { signal: AbortSignal.timeout(2000), cache: "no-store" })
-    .then(async (response) => response.ok ? await response.json() : null)
-    .catch(() => null);
-  const result = {
-    running: health?.ok === true && health?.broker === "machine-bridge-browser",
-    connected: health?.broker === "machine-bridge-browser" && health?.connected === true,
-    extension_path: extensionPath,
-    pairing_url: pairingUrl,
-    expected_extension_version: typeof health?.expected_extension_version === "string" ? health.expected_extension_version : "",
-    extension_protocol: Number.isInteger(health?.extension_protocol) ? health.extension_protocol : null,
-    extension_version: typeof health?.extension_version === "string" ? health.extension_version : "",
-    extension_capabilities: Array.isArray(health?.extension_capabilities) ? health.extension_capabilities : [],
-    extension_reload_required: health?.extension_reload_required === true,
-    controls_existing_profile: health?.controls_existing_profile === true,
-    controls_extension_profile: health?.controls_extension_profile === true,
-    machine_bridge_launches_browser: health?.machine_bridge_launches_browser === true,
-    profile_identity_verifiable: health?.profile_identity_verifiable === true,
-    token_exposed: false,
-  };
-  if (action === "status") {
-    if (args.json) console.log(JSON.stringify(result, null, 2));
-    else {
-      console.log(`Browser bridge: ${result.running ? "running" : "not reachable"}`);
-      console.log(`Extension: ${result.connected ? "connected" : result.extension_reload_required ? "reload required" : "not connected"}`);
-      if (result.expected_extension_version) console.log(`Expected extension build: ${result.expected_extension_version}`);
-      if (result.extension_version || result.extension_protocol) console.log(`Connected extension build: ${result.extension_version || "unknown"} (protocol ${result.extension_protocol ?? "unknown"})`);
-      console.log(`Browser profile: ${result.controls_extension_profile ? "the Chromium profile where this extension is installed" : "unknown"}`);
-      if (result.controls_extension_profile) console.log(`Profile provenance: Machine Bridge did not launch the browser; daily-vs-isolated profile identity is not machine-verifiable.`);
-      console.log(`Extension path: ${extensionPath}`);
-    }
-    return;
-  }
-  if (!result.running) throw new Error("browser bridge is not reachable; keep machine-mcp running and retry");
-  await openExternal(pairingUrl);
-  if (args.json) console.log(JSON.stringify({ ...result, pairing_page_opened: true }, null, 2));
-  else {
-    console.log(`Extension path: ${extensionPath}`);
-    console.log("Load this directory in the Chromium profile you use every day; Machine Bridge does not install it into Playwright or a separate automation profile.");
-    console.log("Enable Developer mode, choose Load unpacked, and reload the extension after each Machine Bridge upgrade.");
-    console.log(`Pairing page opened: ${pairingUrl}`);
-  }
-}
-
-function openExternal(target) {
-  const command = process.platform === "darwin"
-    ? { file: "open", args: [target] }
-    : process.platform === "win32"
-      ? { file: "cmd.exe", args: ["/d", "/s", "/c", "start", "", target] }
-      : { file: "xdg-open", args: [target] };
-  return new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(command.file, command.args, { detached: true, stdio: "ignore", windowsHide: true });
-    child.once("spawn", () => {
-      child.unref();
-      resolvePromise();
-    });
-    child.once("error", rejectPromise);
-  });
-}
-
-async function jobCommand(args) {
-  const action = String(args._[0] || "list").toLowerCase();
-  const workspace = await chooseWorkspace({ ...args, _: [] }, { promptOnFirstRun: false, save: false, allowPositional: false });
-  const state = loadState(workspace, { stateDir: args.stateDir });
-  const manager = new ManagedJobManager({
-    jobRoot: join(state.paths.profileDir, "jobs"),
-    workspace,
-    policy: resolvePolicy({}, state.policy),
-    resources: state.resources,
-    resourceStatePath: state.paths.statePath,
-    stateRoot: state.paths.stateRoot,
-    logger: createLogger({ level: "warn", component: "job" }),
-  });
-  let result;
-  if (action === "list") result = manager.list({ limit: 50 });
-  else if (action === "read") result = manager.read({ job_id: args._[1] });
-  else if (action === "inspect") result = manager.inspectLocal({ job_id: args._[1] });
-  else if (action === "cancel") result = manager.cancel({ job_id: args._[1] });
-  else if (action === "approve") {
-    if (args.json && !args.yes) throw new Error("job approve --json requires --yes");
-    const inspection = manager.inspectLocal({ job_id: args._[1] });
-    if (!args.yes) {
-      console.log(JSON.stringify(inspection, null, 2));
-      const approved = await confirm(`Approve and execute managed job ${args._[1]}?`, false);
-      if (!approved) {
-        console.log("Managed job approval cancelled. Re-run with --yes after review to skip confirmation.");
-        return;
-      }
-    }
-    result = manager.approve({ job_id: args._[1] }, { localOperator: true });
-  }
-  else if (action === "submit") {
-    const planPath = args._[1];
-    if (!planPath) throw new Error("job submit requires a JSON plan file");
-    const plan = loadManagedJobPlan(expandHome(planPath));
-    result = manager.start(plan);
-  } else throw new Error(`Unknown job action: ${action}`);
-  console.log(JSON.stringify(result, null, 2));
-}
-
 async function clientConfigCommand(args) {
   const workspaceArgs = { ...args, _: [] };
   const workspace = await chooseWorkspace(workspaceArgs, { promptOnFirstRun: false, save: false, allowPositional: false });
@@ -876,7 +370,7 @@ function removedLocalApiError() {
 
 
 async function ensureWorker(state, args) {
-  const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), component: "worker" });
+  const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "worker" });
   const desiredHash = workerDeployHash(state);
   const expectedVersion = currentPackageVersion();
   const complete = state.worker.url && state.worker.mcpServerUrl && state.worker.oauthPassword && state.worker.daemonSecret && state.worker.oauthTokenVersion && state.worker.name;
@@ -1647,6 +1141,7 @@ Start options:
   --state-dir DIR       Override state root
   --json                Print connection details as JSON; credentials stay redacted unless explicitly requested
   --log-level LEVEL     error, warn, info (default), or debug
+  --log-format FORMAT   text (default) or newline-delimited json
   --verbose             Alias for --log-level debug; includes per-tool success/correlation logs
   --quiet               Alias for --log-level error
   --allow-insecure-permissions