machine-bridge-mcp 0.4.2 → 0.6.0

package/src/local/cli.mjs

@@ -1,12 +1,13 @@
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, unlinkSync } from "node:fs";
-import path, { resolve } from "node:path";
+import path, { join, resolve } from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { LocalDaemon } from "./daemon.mjs";
 import { runStdioServer } from "./stdio.mjs";
-import { normalizePolicy } from "./tools.mjs";
-import { createLogger, sanitizeLogText } from "./log.mjs";
+import { DEFAULT_POLICY_PROFILE, DEFAULT_POLICY_REVISION, POLICY_PROFILES, normalizePolicy, policyProfile } from "./tools.mjs";
+import { classifyOperationalError, createLogger, normalizeLogLevel, sanitizeLogText } from "./log.mjs";
+import { activeManagedJobs, inspectResourceFile, loadManagedJobPlan, ManagedJobManager, publicResourceRegistry, validateResourceName } from "./managed-jobs.mjs";
 import { runWrangler } from "./shell.mjs";
 import {
   acquireDaemonLock,
@@ -37,10 +38,10 @@ const BOOLEAN_OPTIONS = new Set([
   "help", "version", "quiet", "json", "verbose", "rotateSecrets", "forceWorker",
   "daemonOnly", "noAutostart", "noPrintCredentials", "printMcpCredentials",
   "printCredentials", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
-  "yes", "keepWorker", "noApi", "api", "rotateApiKey",
+  "yes", "keepWorker", "allowInsecurePermissions",
 ]);
 const VALUE_OPTIONS = new Set([
-  "workspace", "stateDir", "workerName", "profile", "execMode", "client", "apiPort", "apiHost", "apiKey", "apiModel", "port",
+  "workspace", "stateDir", "workerName", "profile", "execMode", "client", "logLevel",
 ]);
 
 export async function main(argv = process.argv.slice(2)) {
@@ -51,6 +52,7 @@ export async function main(argv = process.argv.slice(2)) {
   if (command === "api") throw removedLocalApiError();
   validateCommandOptions(command, args);
   validatePositionals(command, args);
+  validateLoggingOptions(args);
 
   switch (command) {
     case "start": return startCommand(args);
@@ -62,6 +64,8 @@ export async function main(argv = process.argv.slice(2)) {
     case "service":
     case "autostart": return serviceCommand(args);
     case "rotate-secrets": return rotateSecretsCommand(args);
+    case "resource": return resourceCommand(args);
+    case "job": return jobCommand(args);
     case "uninstall": return uninstallCommand(args);
     default:
       console.error(`Unknown command: ${command}`);
@@ -72,19 +76,20 @@ export async function main(argv = process.argv.slice(2)) {
 
 const COMMAND_OPTIONS = {
   start: new Set([
-    "workspace", "stateDir", "workerName", "quiet", "json", "verbose", "rotateSecrets", "forceWorker",
+    "workspace", "stateDir", "workerName", "quiet", "json", "verbose", "logLevel", "rotateSecrets", "forceWorker",
     "daemonOnly", "noAutostart", "noPrintCredentials", "printMcpCredentials", "printCredentials",
     "profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
-    "noApi", "api", "apiPort", "apiHost", "apiKey", "rotateApiKey", "apiModel", "port",
   ]),
-  stdio: new Set(["workspace", "stateDir", "profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths", "verbose"]),
+  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"]),
-  "rotate-secrets": new Set(["workspace", "stateDir", "workerName", "noPrintCredentials", "quiet"]),
+  "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", "json"]),
+  job: new Set(["workspace", "stateDir", "json", "yes"]),
   uninstall: new Set(["stateDir", "keepWorker", "yes"]),
 };
 
@@ -97,14 +102,27 @@ export function validateCommandOptions(command, args) {
   }
 }
 
+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()}`);
 }
 
 export function validatePositionals(command, args) {
   const count = args._.length;
-  const conflict = Boolean(args.workspace) && count > (command === "workspace" || command === "service" || command === "autostart" ? 1 : 0);
-  if (conflict) throw new Error("workspace path was provided both positionally and with --workspace");
   if (["start", "stdio", "status", "doctor", "rotate-secrets"].includes(command)) {
     if (count > 1) throw new Error(`${command} accepts at most one positional workspace path`);
     if (args.workspace && count) throw new Error("workspace path was provided both positionally and with --workspace");
@@ -128,6 +146,18 @@ export function validatePositionals(command, args) {
     if (count > 1) throw new Error("client-config accepts at most one positional client name");
     return;
   }
+  if (command === "resource") {
+    const action = String(args._[0] || "list");
+    const max = action === "add" ? 3 : action === "remove" || action === "check" ? 2 : 1;
+    if (count > max) throw new Error(`resource ${action} received too many positional arguments`);
+    return;
+  }
+  if (command === "job") {
+    const action = String(args._[0] || "list");
+    const max = action === "read" || action === "inspect" || action === "cancel" || action === "approve" || action === "submit" ? 2 : 1;
+    if (count > max) throw new Error(`job ${action} received too many positional arguments`);
+    return;
+  }
   if (command === "uninstall" && count) throw new Error("uninstall does not accept positional arguments");
 }
 
@@ -256,8 +286,7 @@ async function confirm(prompt, assumeYes = false) {
 
 async function startCommand(args) {
   assertNodeVersion();
-  assertNoRemovedLocalApiOptions(args);
-  const logger = createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "cli" });
+  const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), component: "cli" });
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: true, save: true, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
   const startupLock = acquireStartupLock(state);
@@ -273,7 +302,7 @@ async function startCommand(args) {
     } else {
       // Stop an installed service before acquiring the runtime lock. If a
       // foreground daemon owns the lock, no new policy or secret state is saved.
-      await stopAutostartBestEffort(Boolean(args.quiet));
+      await stopAutostartBestEffort(logger);
     }
 
     const lock = acquireDaemonLock(state);
@@ -281,7 +310,7 @@ async function startCommand(args) {
       const pid = lock.owner?.pid ? `pid ${lock.owner.pid}` : "unknown pid";
       logger.warn(`local daemon already running for this workspace (${pid}); requested changes were not applied`);
       if (args.json) printStartJson(state, {
-        noPrintCredentials: Boolean(args.noPrintCredentials),
+        showCredentials: Boolean((args.printMcpCredentials || args.printCredentials) && !args.noPrintCredentials),
         requestedChangesApplied: false,
         notice: "local daemon already running; requested changes were not applied",
       });
@@ -289,6 +318,7 @@ async function startCommand(args) {
         noPrintCredentials: Boolean(args.noPrintCredentials),
         includeCredentials: Boolean(args.printMcpCredentials || args.printCredentials),
         quiet: Boolean(args.quiet),
+        verbose: Boolean(args.verbose),
       });
       return;
     }
@@ -299,7 +329,9 @@ async function startCommand(args) {
       const firstMcpConnection = !previousMcpServerUrl || !state.worker?.oauthPassword;
       const workerName = validateWorkerName(args.workerName);
       ensureWorkerSecrets(state, { rotateSecrets: Boolean(args.rotateSecrets), workerName });
+      const previousPolicyOrigin = state.policy?.origin;
       state.policy = resolvePolicy(args, state.policy);
+      const policyMigrated = !previousPolicyOrigin && state.policy.origin === "migrated";
       state.policy.updatedAt = new Date().toISOString();
       saveState(state);
 
@@ -307,10 +339,10 @@ async function startCommand(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);
+      const shouldPrintMcpCredentials = Boolean(args.printMcpCredentials || args.printCredentials || firstMcpConnection || args.rotateSecrets || mcpConnectionChanged);
 
       if (!args.daemonOnly && !args.noAutostart) {
-        await installAutostartBestEffort({ workspace, stateRoot: state.paths.stateRoot, entryScript: process.argv[1] });
+        await installAutostartBestEffort({ workspace, stateRoot: state.paths.stateRoot, entryScript: process.argv[1], logger });
       }
 
       daemon = new LocalDaemon({
@@ -318,7 +350,10 @@ async function startCommand(args) {
         secret: state.worker.daemonSecret,
         workspace,
         policy: state.policy,
-        logger: createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "daemon" }),
+        logger: createLogger({ level: args.json ? "error" : effectiveLogLevel(args), component: "daemon" }),
+        jobRoot: join(state.paths.profileDir, "jobs"),
+        resources: state.resources,
+        resourceStatePath: state.paths.statePath,
         onSuperseded: () => {
           logger.warn("this daemon was replaced by a newer authenticated instance; exiting without reconnecting");
           lock.release();
@@ -327,13 +362,18 @@ async function startCommand(args) {
       });
 
       const waitForConnect = daemon.start();
-      await waitForConnectWithNotice(waitForConnect, 20_000, Boolean(args.quiet || args.json));
-      if (args.json) printStartJson(state, { noPrintCredentials: Boolean(args.noPrintCredentials) });
+      await waitForConnectWithNotice(waitForConnect, 20_000, logger);
+      if (args.json) printStartJson(state, {
+        showCredentials: Boolean((args.printMcpCredentials || args.printCredentials) && !args.noPrintCredentials),
+        notice: policyMigrated ? "legacy implicit policy migrated to full access" : "",
+      });
       else {
         printMcpConnection(state, {
           noPrintCredentials: Boolean(args.noPrintCredentials),
           includeCredentials: shouldPrintMcpCredentials,
           quiet: Boolean(args.quiet),
+          verbose: Boolean(args.verbose),
+          policyMigrated,
         });
       }
       keepProcessAlive({ daemon, lock, logger });
@@ -347,13 +387,6 @@ async function startCommand(args) {
   }
 }
 
-const POLICY_PROFILES = Object.freeze({
-  review: Object.freeze({ profile: "review", allowWrite: false, execMode: "off", unrestrictedPaths: false, minimalEnv: true, exposeAbsolutePaths: false }),
-  edit: Object.freeze({ profile: "edit", allowWrite: true, execMode: "off", unrestrictedPaths: false, minimalEnv: true, exposeAbsolutePaths: false }),
-  agent: Object.freeze({ profile: "agent", allowWrite: true, execMode: "direct", unrestrictedPaths: false, minimalEnv: true, exposeAbsolutePaths: false }),
-  full: Object.freeze({ profile: "full", allowWrite: true, execMode: "shell", unrestrictedPaths: true, minimalEnv: false, exposeAbsolutePaths: true }),
-});
-
 export function resolvePolicy(args = {}, stored = {}) {
   const hasStored = stored && typeof stored === "object" && (
     typeof stored.allowWrite === "boolean" || typeof stored.allowExec === "boolean" || typeof stored.execMode === "string"
@@ -361,14 +394,15 @@ export function resolvePolicy(args = {}, stored = {}) {
   const explicitKeys = ["profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths"];
   const hasExplicit = explicitKeys.some((key) => Object.prototype.hasOwnProperty.call(args, key));
   let base;
+
   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(", ")}`);
-    base = { ...POLICY_PROFILES[profile] };
+    base = policyProfile(profile, "explicit");
   } else if (hasStored) {
-    base = normalizePolicy(stored);
+    base = migrateLegacyPolicy(stored);
   } else {
-    base = { ...POLICY_PROFILES.full };
+    base = policyProfile(DEFAULT_POLICY_PROFILE, "default");
   }
 
   if (!hasExplicit) return normalizePolicy(base);
@@ -388,16 +422,167 @@ export function resolvePolicy(args = {}, stored = {}) {
   if (args.absolutePaths === true) base.exposeAbsolutePaths = true;
   if (args.absolutePaths === false) base.exposeAbsolutePaths = false;
   const overrideKeys = ["execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths"];
-  if (args.profile === undefined || overrideKeys.some((key) => Object.prototype.hasOwnProperty.call(args, key))) base.profile = "custom";
+  if (args.profile === undefined || overrideKeys.some((key) => Object.prototype.hasOwnProperty.call(args, key))) {
+    base.profile = "custom";
+    base.origin = "custom";
+    base.revision = DEFAULT_POLICY_REVISION;
+  }
   return normalizePolicy(base);
 }
 
+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 });
   const state = loadState(workspace, { stateDir: args.stateDir });
   const policy = resolvePolicy(args, state.policy);
-  await runStdioServer({ workspace, policy, verbose: Boolean(args.verbose) });
+  await runStdioServer({
+    workspace,
+    policy,
+    logLevel: effectiveLogLevel(args),
+    jobRoot: join(state.paths.profileDir, "jobs"),
+    resources: state.resources,
+    resourceStatePath: state.paths.statePath,
+  });
+}
+
+async function resourceCommand(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 });
+  state.resources ||= {};
+
+  if (action === "list") {
+    const resources = publicResourceRegistry(state.resources);
+    if (args.json) console.log(JSON.stringify({ workspace, resources }, null, 2));
+    else if (!Object.keys(resources).length) console.log("No local resources registered.");
+    else for (const [name, value] of Object.entries(resources)) console.log(`${name}	${value.path}	${value.mode || "n/a"}	${value.size ?? "n/a"} bytes`);
+    return;
+  }
+
+  if (action === "add") {
+    const name = validateResourceName(args._[1]);
+    const inputPath = args._[2];
+    if (!inputPath) throw new Error("resource add requires NAME and FILE_PATH");
+    const lock = acquireStartupLock(state);
+    if (!lock.acquired) throw new Error("another state-changing operation is already running for this workspace");
+    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 = { name, ...inspected, contents_exposed: false, available_to_new_jobs_immediately: true };
+      if (args.json) console.log(JSON.stringify(result, null, 2));
+      else {
+        console.log(`Registered local resource: ${name}`);
+        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();
+    }
+    return;
+  }
+
+  if (action === "remove") {
+    const name = validateResourceName(args._[1]);
+    const lock = acquireStartupLock(state);
+    if (!lock.acquired) throw new Error("another state-changing operation is already running for this workspace");
+    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();
+    }
+    return;
+  }
+
+  if (action === "check") {
+    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 = { name, ...inspected, contents_exposed: false };
+    if (args.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(`${name}: available (${inspected.mode || "n/a"}, ${inspected.size} bytes)`);
+    return;
+  }
+
+  throw new Error(`Unknown resource action: ${action}`);
+}
+
+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,
+    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) {
@@ -426,17 +611,13 @@ async function clientConfigCommand(args) {
   }
 }
 
-function assertNoRemovedLocalApiOptions(args) {
-  const removed = ["api", "noApi", "apiPort", "apiHost", "apiKey", "rotateApiKey", "apiModel", "port"].filter((key) => args[key] !== undefined);
-  if (removed.length) throw removedLocalApiError();
-}
-
 function removedLocalApiError() {
   return new Error("Local /v1 API support has been removed. Use the printed Remote MCP Server URL/password with an MCP client instead.");
 }
 
+
 async function ensureWorker(state, args) {
-  const logger = createLogger({ quiet: Boolean(args.quiet || args.json), verbose: Boolean(args.verbose), component: "worker" });
+  const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(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;
@@ -487,7 +668,7 @@ async function withSecretsFile(state, callback) {
   const dir = state.paths.profileDir;
   ensureOwnerOnlyDir(dir);
   cleanupStaleSecretFiles(dir);
-  const tempPath = resolve(dir, `worker-secrets-${process.pid}-${Date.now()}.json`);
+  const tempPath = resolve(dir, `worker-secrets-${process.pid}-${Date.now()}-${randomBytes(6).toString("hex")}.json`);
   const payload = {
     MCP_OAUTH_PASSWORD: state.worker.oauthPassword,
     DAEMON_SHARED_SECRET: state.worker.daemonSecret,
@@ -504,10 +685,14 @@ async function withSecretsFile(state, callback) {
 
 function cleanupStaleSecretFiles(dir) {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isFile() || !/^worker-secrets-.*\.json$/.test(entry.name)) continue;
+    if (!entry.isFile()) continue;
+    const match = /^worker-secrets-(\d+)-(\d+)(?:-[a-f0-9]+)?\.json$/.exec(entry.name);
+    if (!match) continue;
     const file = resolve(dir, entry.name);
     try {
-      if (Date.now() - statSync(file).mtimeMs > 60 * 60 * 1000) unlinkSync(file);
+      const pid = Number(match[1]);
+      const ageMs = Date.now() - statSync(file).mtimeMs;
+      if (!isPidAlive(pid) || ageMs > 60 * 60 * 1000) unlinkSync(file);
     } catch {}
   }
 }
@@ -562,10 +747,18 @@ async function workerHealth(workerUrl, expectedVersion = currentPackageVersion()
     if (body?.version !== expectedVersion) return { ok: false, error: `version_mismatch:${body?.version || "unknown"}!=${expectedVersion}` };
     return { ok: true, version: body.version };
   } catch (error) {
-    return { ok: false, error: error.message };
+    return { ok: false, error: workerHealthError(error) };
   }
 }
 
+function workerHealthError(error) {
+  const message = String(error?.message || error || "");
+  if (/timeout|aborted/i.test(message)) return "timeout";
+  if (/certificate|TLS|SSL/i.test(message)) return "tls_error";
+  if (/fetch failed|network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) return "network_error";
+  return "request_failed";
+}
+
 async function retryHealth(workerUrl, expectedVersion, attempts) {
   let last = { ok: false, error: "not_checked" };
   for (let i = 0; i < attempts; i += 1) {
@@ -583,23 +776,22 @@ function extractWorkerUrl(text = "") {
   return anyHttps.find(match => /workers\.dev|\/healthz|\/mcp/.test(match[0]))?.[0]?.replace(/[),.]+$/, "") || "";
 }
 
-async function waitForConnectWithNotice(promise, timeoutMs, quiet = false) {
+async function waitForConnectWithNotice(promise, timeoutMs, logger) {
   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") createLogger({ component: "daemon", quiet }).warn("Still connecting; the process will keep retrying");
+  if (result === "timeout") logger.warn("Still connecting; the process will keep retrying");
 }
 
 
-function printStartJson(state, { noPrintCredentials = false, requestedChangesApplied = true, notice = "" } = {}) {
-  const mcpPassword = noPrintCredentials ? previewSecret(state.worker.oauthPassword) : state.worker.oauthPassword;
+function printStartJson(state, { showCredentials = false, requestedChangesApplied = true, notice = "" } = {}) {
   createLogger({ component: "ready" }).json({
     mcp: {
       server_url: state.worker.mcpServerUrl,
-      connection_password: mcpPassword,
+      connection_password: showCredentials ? state.worker.oauthPassword : previewSecret(state.worker.oauthPassword),
       worker_url: state.worker.url,
       worker_name: state.worker.name,
     },
@@ -611,36 +803,45 @@ function printStartJson(state, { noPrintCredentials = false, requestedChangesApp
   });
 }
 
-function printMcpConnection(state, { json = false, noPrintCredentials = false, includeCredentials = false, quiet = false } = {}) {
-  const logger = createLogger({ component: "ready", quiet });
+function printMcpConnection(state, {
+  noPrintCredentials = false,
+  includeCredentials = false,
+  quiet = false,
+  verbose = false,
+  policyMigrated = false,
+} = {}) {
+  const logger = createLogger({ component: "ready", quiet, level: quiet ? "error" : verbose ? "debug" : "info" });
   const payload = {
     mcp_server_url: state.worker.mcpServerUrl,
     mcp_connection_password: state.worker.oauthPassword,
-    worker_url: state.worker.url,
-    worker_name: state.worker.name,
     workspace: state.workspace.path,
     state_path: state.paths.statePath,
     policy: state.policy,
   };
-  if (json) {
-    const safePayload = noPrintCredentials ? { ...payload, mcp_connection_password: previewSecret(payload.mcp_connection_password) } : payload;
-    logger.json(safePayload);
-    return;
-  }
   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.success("Remote MCP bridge is ready");
+    logger.plain("  Connection credentials unchanged; use --print-mcp-credentials only when reconnecting a client.");
+  }
+  if (policyMigrated) {
+    logger.warn("Legacy implicit policy migrated to full access; use --profile agent, edit, or review to narrow it.");
   }
-  logger.plain(`  Workspace cwd: ${payload.workspace}`);
-  logger.plain(`  Policy: profile=${payload.policy.profile || "custom"}, write=${payload.policy.allowWrite ? "on" : "off"}, exec_mode=${payload.policy.execMode || (payload.policy.allowExec ? "shell" : "off")}, unrestricted_paths=${payload.policy.unrestrictedPaths ? "on" : "off"}, absolute_paths=${payload.policy.exposeAbsolutePaths ? "on" : "off"}`);
-  logger.plain(`  State: ${payload.state_path}`);
+  logger.plain(`  Workspace: ${payload.workspace}`);
+  logger.plain(`  Policy: ${formatPolicySummary(payload.policy)}`);
+  if (verbose) logger.plain(`  State: ${payload.state_path}`);
+}
+
+function formatPolicySummary(policy = {}) {
+  const scope = policy.unrestrictedPaths ? "all local paths" : "workspace only";
+  const environment = policy.minimalEnv ? "isolated env" : "full parent env";
+  return `${policy.profile || "custom"} [${policy.origin || "unknown"}; write=${policy.allowWrite ? "on" : "off"}; exec=${policy.execMode || "off"}; ${scope}; ${environment}; absolute_paths=${policy.exposeAbsolutePaths ? "on" : "off"}]`;
 }
 
+
 function keepProcessAlive({ daemon = null, lock = null, logger = createLogger({ component: "cli" }) } = {}) {
   let stopping = false;
   const stop = async () => {
@@ -660,8 +861,14 @@ function keepProcessAlive({ daemon = null, lock = null, logger = createLogger({
 async function statusCommand(args) {
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
   const state = loadState(workspace, { stateDir: args.stateDir });
+  const storedPolicyOrigin = state.policy?.origin;
+  state.policy = resolvePolicy({}, state.policy);
   const health = state.worker?.url ? await workerHealth(state.worker.url) : { ok: false, error: "no worker url" };
-  const payload = { ...redactState(state), workerHealth: health };
+  const payload = {
+    ...redactState(state),
+    policyMigrationPending: !storedPolicyOrigin && state.policy.origin === "migrated",
+    workerHealth: health,
+  };
   console.log(JSON.stringify(payload, null, 2));
 }
 
@@ -674,9 +881,40 @@ async function doctorCommand(args) {
   const whoami = await runWrangler(["whoami"], { capture: true, allowFailure: true });
   checks.push({ name: "cloudflare-login", ok: whoami.code === 0, detail: whoami.code === 0 ? "authenticated" : sanitizeLines(whoami.stderr || whoami.stdout) });
   const state = loadState(workspace, { stateDir: args.stateDir });
+  const storedPolicyOrigin = state.policy?.origin;
+  state.policy = resolvePolicy({}, state.policy);
+  checks.push({ name: "policy", ok: true, detail: formatPolicySummary(state.policy) });
   const health = state.worker?.url ? await workerHealth(state.worker.url) : { ok: false, error: "no worker url" };
   checks.push({ name: "worker-health", ok: health.ok, detail: health.ok ? state.worker.url : health.error });
-  console.log(JSON.stringify({ ok: checks.every(check => check.ok), checks, state: redactState(state) }, null, 2));
+  const diagnosticRuntime = new LocalDaemon({
+    workspace,
+    policy: state.policy,
+    logger: createLogger({ level: "error", component: "doctor" }),
+    jobRoot: join(state.paths.profileDir, "jobs"),
+    resources: state.resources,
+    resourceStatePath: state.paths.statePath,
+    recoverJobs: false,
+  });
+  let runtimeDiagnostics;
+  try {
+    runtimeDiagnostics = await diagnosticRuntime.diagnoseRuntime();
+  } finally {
+    diagnosticRuntime.stop();
+  }
+  for (const check of runtimeDiagnostics.checks) {
+    checks.push({
+      name: `runtime:${check.layer}`,
+      ok: check.skipped === true || check.ok === true,
+      detail: check.skipped ? `skipped (${check.error_class || "not applicable"})` : check.ok ? "ok" : check.error_class || "failed",
+    });
+  }
+  console.log(JSON.stringify({
+    ok: checks.every(check => check.ok),
+    checks,
+    runtimeDiagnostics,
+    policyMigrationPending: !storedPolicyOrigin && state.policy.origin === "migrated",
+    state: redactState(state),
+  }, null, 2));
 }
 
 async function rotateSecretsCommand(args) {
@@ -688,7 +926,7 @@ async function rotateSecretsCommand(args) {
     throw new Error(`another startup/deployment operation is already running for this workspace (${pid})`);
   }
   try {
-    await stopAutostartBestEffort(Boolean(args.quiet));
+    await stopAutostartBestEffort(createLogger({ level: args.quiet ? "error" : "warn", component: "service" }));
     await sleep(500);
     const daemonOwner = readDaemonLockOwner(daemonLockPathForState(state));
     if (daemonOwner?.pid && isPidAlive(daemonOwner.pid)) {
@@ -696,9 +934,10 @@ async function rotateSecretsCommand(args) {
     }
     ensureWorkerSecrets(state, { rotateSecrets: true, workerName: validateWorkerName(args.workerName) });
     saveState(state);
-    console.log(`Rotated MCP password: ${args.noPrintCredentials ? "<redacted>" : state.worker.oauthPassword}`);
-    console.log(`Rotated daemon secret: ${args.noPrintCredentials ? "<redacted>" : previewSecret(state.worker.daemonSecret)}`);
-    console.log("Run start to redeploy the Worker with the new secrets and revoke old OAuth access tokens.");
+    const showMcpPassword = Boolean((args.printMcpCredentials || args.printCredentials) && !args.noPrintCredentials);
+    console.log(`Rotated MCP connection password: ${showMcpPassword ? state.worker.oauthPassword : previewSecret(state.worker.oauthPassword)}`);
+    console.log(`Rotated daemon secret: ${previewSecret(state.worker.daemonSecret)}`);
+    console.log("Run `machine-mcp --print-mcp-credentials` to redeploy and display the new client connection credentials when needed.");
   } finally {
     startupLock.release();
   }
@@ -742,23 +981,23 @@ async function serviceCommand(args) {
   throw new Error(`Unknown service action: ${action}`);
 }
 
-async function installAutostartBestEffort({ workspace, stateRoot, entryScript }) {
+async function installAutostartBestEffort({ workspace, stateRoot, entryScript, logger }) {
   try {
     const { installAutostart } = await import("./service.mjs");
-    const result = await installAutostart({ workspace, stateRoot, entryScript, logger: structuredLogger(false) });
-    if (result?.ok) console.log("Autostart installed for future logins. Use `machine-mcp service status` to inspect or `machine-mcp service uninstall` to remove.");
-    else console.warn("Autostart installation returned a warning; run `machine-mcp service status` for details.");
+    const result = await installAutostart({ workspace, stateRoot, entryScript, logger: structuredLogger(true) });
+    if (result?.ok) logger.info("Autostart installed for future logins", { provider: result.provider });
+    else logger.warn("Autostart installation reported a problem; run `machine-mcp service status` for details");
   } catch (error) {
-    console.warn(`Autostart installation skipped: ${error.message}`);
+    logger.warn("Autostart installation skipped", { error_class: classifyOperationalError(error) });
   }
 }
 
-async function stopAutostartBestEffort(quiet = false) {
+async function stopAutostartBestEffort(logger) {
   try {
     const { stopAutostart } = await import("./service.mjs");
     await stopAutostart({ logger: structuredLogger(true) });
   } catch (error) {
-    if (!quiet) console.warn(`Autostart stop skipped: ${error.message}`);
+    logger.warn("Autostart stop skipped", { error_class: classifyOperationalError(error) });
   }
 }
 
@@ -774,6 +1013,12 @@ async function uninstallCommand(args) {
     console.log("Uninstall cancelled. Re-run with `machine-mcp uninstall --yes` to skip confirmation.");
     return;
   }
+  const activeJobs = activeStateJobs(stateRoot);
+  if (activeJobs.length) {
+    const detail = activeJobs.slice(0, 5).map((item) => `${item.job_id}:${item.status}`).join(", ");
+    const suffix = activeJobs.length > 5 ? `, and ${activeJobs.length - 5} more` : "";
+    throw new Error(`refusing to uninstall while managed jobs are active (${detail}${suffix}); inspect or cancel them with machine-mcp job list/cancel`);
+  }
   const autostartRemoved = await removeAutostartBestEffort(stateRoot);
   if (!autostartRemoved) throw new Error("autostart removal failed; state and Worker were kept so the uninstall can be retried safely");
   await sleep(500);
@@ -820,6 +1065,7 @@ function knownWorkerNames(stateRoot) {
     const stateFile = resolve(profiles, entry.name, "state.json");
     if (!existsSync(stateFile)) continue;
     try {
+      if (statSync(stateFile).size > 2 * 1024 * 1024) continue;
       const state = JSON.parse(readFileSync(stateFile, "utf8"));
       const name = String(state?.worker?.name || "");
       if (/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(name)) names.add(name);
@@ -839,11 +1085,24 @@ async function removeAutostartBestEffort(stateRoot) {
     }
     return true;
   } catch (error) {
-    console.warn(`Autostart removal skipped or failed: ${error.message}`);
+    console.warn(`Autostart removal skipped or failed (${classifyOperationalError(error)}). Run machine-mcp service status for details.`);
     return false;
   }
 }
 
+function activeStateJobs(stateRoot) {
+  const profiles = resolve(expandHome(stateRoot), "profiles");
+  if (!existsSync(profiles)) return [];
+  const active = [];
+  for (const profile of readdirSync(profiles, { withFileTypes: true })) {
+    if (!profile.isDirectory()) continue;
+    for (const job of activeManagedJobs(resolve(profiles, profile.name, "jobs"))) {
+      active.push({ profile: profile.name, ...job });
+    }
+  }
+  return active;
+}
+
 function activeStateLocks(stateRoot) {
   const profiles = resolve(expandHome(stateRoot), "profiles");
   if (!existsSync(profiles)) return [];
@@ -872,9 +1131,10 @@ function isPidAlive(pid) {
 }
 
 function structuredLogger(quiet) {
-  return createLogger({ quiet, component: "daemon" });
+  return createLogger({ quiet, component: "service" });
 }
 
+
 function sanitizeLines(text) {
   const home = process.env.HOME || process.env.USERPROFILE || "";
   const homePattern = home ? new RegExp(escapeRegExp(home), "g") : null;
@@ -910,7 +1170,7 @@ function usage() {
   console.log(`machine-bridge-mcp
 
 Usage:
-  npm install -g machine-bridge-mcp@latest && machine-mcp
+  npm install -g --allow-scripts=esbuild,workerd,sharp machine-bridge-mcp@latest && machine-mcp
   npx machine-bridge-mcp@latest                  # no global install; autostart may rely on npm cache
   ./mbm                                          # from source checkout
   .\\mbm.cmd                                      # from source checkout on Windows cmd
@@ -946,9 +1206,14 @@ Start options:
   --no-exec             Disable run_process and exec_command
   --full-env            Pass the full parent environment to local commands
   --unrestricted-paths  Allow filesystem tools outside the workspace
-  --absolute-paths      Return absolute local paths in tool results (off by default)
+  --absolute-paths      Return absolute local paths (enabled by the full profile)
   --state-dir DIR       Override state root
-  --json                Print MCP connection details as JSON
+  --json                Print connection details as JSON; credentials stay redacted unless explicitly requested
+  --log-level LEVEL     error, warn, info (default), or debug
+  --verbose             Alias for --log-level debug; includes per-tool success/correlation logs
+  --quiet               Alias for --log-level error
+  --allow-insecure-permissions
+                        Permit resource registration when a file is group/other-readable
 
 Uninstall options:
   --keep-worker         Do not delete deployed Worker(s) during uninstall