machine-bridge-mcp 2.0.0 → 3.0.0-beta.9

package/src/local/cli-activate.mjs

@@ -0,0 +1,90 @@
+import { acquireDaemonLockWithTakeover, inspectWorkspaceDaemon } from "./daemon-process.mjs";
+import { effectiveLogFormat, effectiveLogLevel } from "./cli-options.mjs";
+import { createLogger } from "./log.mjs";
+import { activatePersistentRuntime } from "./runtime-activation.mjs";
+import { installAutostart, startAutostart, stopAutostart } from "./service.mjs";
+import { acquireStartupLockWithWait, loadState } from "./state.mjs";
+import { workerHealth } from "./worker-health.mjs";
+
+export function createActivateCommand({
+  chooseWorkspace,
+  prepareRemoteState,
+  createRemoteRuntime,
+  currentPackageVersion,
+  assertNodeVersion,
+  structuredLogger,
+} = {}) {
+  for (const [name, value] of Object.entries({
+    chooseWorkspace,
+    prepareRemoteState,
+    createRemoteRuntime,
+    currentPackageVersion,
+    assertNodeVersion,
+    structuredLogger,
+  })) {
+    if (typeof value !== "function") throw new TypeError(`activate command requires ${name}`);
+  }
+
+  return async function activateCommand(args) {
+    assertNodeVersion();
+    const logger = createLogger({
+      level: args.json ? "error" : effectiveLogLevel(args),
+      format: effectiveLogFormat(args),
+      component: "activate",
+    });
+    const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: true, allowPositional: true });
+    const state = loadState(workspace, { stateDir: args.stateDir });
+    if (!state.worker?.url) {
+      throw new Error("activate requires an existing deployment; run machine-mcp once interactively before persistent activation");
+    }
+    const activationArgs = { ...args, noAutostart: true, daemonOnly: false };
+    const expectedVersion = currentPackageVersion();
+    const result = await activatePersistentRuntime({
+      expectedVersion,
+      acquireStartupLock: () => acquireStartupLockWithWait(state, { operation: "activate", logger }),
+      stopAutostart: () => stopAutostart({ logger: structuredLogger(true) }),
+      acquireDaemonLock: () => acquireDaemonLockWithTakeover(state, {
+        takeOverServiceOwner: true,
+        ownerMetadata: { mode: "foreground", version: expectedVersion },
+        logger,
+      }),
+      prepareRemoteState: () => prepareRemoteState({ args: activationArgs, workspace, state, logger }),
+      createRuntime: ({ daemonLock, readiness }) => createRemoteRuntime({
+        args: activationArgs,
+        workspace,
+        state,
+        daemonLock,
+        deviceSessionIdentity: readiness.deviceSessionIdentity,
+        exitOnTerminal: false,
+      }),
+      installAutostart: () => installAutostart({
+        workspace,
+        stateRoot: state.paths.stateRoot,
+        entryScript: process.argv[1],
+        logger: structuredLogger(true),
+      }),
+      startAutostart: () => startAutostart({ logger: structuredLogger(true) }),
+      inspectDaemon: async () => inspectWorkspaceDaemon(state),
+      checkWorker: async () => workerHealth(state.worker.url, expectedVersion, { expectedWorkerName: state.worker.name }),
+    });
+    const convergence = result.convergence;
+    const payload = {
+      ok: true,
+      version: expectedVersion,
+      workspace: state.workspace.path,
+      worker: { name: state.worker.name, url: state.worker.url, health: convergence.worker },
+      daemon: convergence.daemon,
+      service: result.serviceStart,
+      candidate_relay_verified_before_handoff: result.candidateRelayVerified,
+    };
+    if (args.json) console.log(JSON.stringify(payload, null, 2));
+    else {
+      logger.success(`Persistent runtime activated: ${expectedVersion}`);
+      logger.safePlain(`  Worker: ${state.worker.name}`);
+      logger.safePlain(`  Daemon: pid ${convergence.daemon.pid}`);
+      logger.safePlain("  Candidate relay readiness was verified before the login service handoff.");
+      logger.safePlain("  The login service now owns the daemon; the activation terminal may close.");
+    }
+    return payload;
+  };
+}

package/src/local/cli-approval.mjs

@@ -1,14 +1,11 @@
 import {
-  OPERATION_APPROVAL_SCOPES,
-  approvePendingOperation,
   clearOperationLeases,
-  grantOperationLease,
   listOperationApprovals,
   revokeOperationLease,
 } from "./operation-authorization.mjs";
 import { loadState } from "./state.mjs";
 
-const ACTIONS = new Set(["list", "approve", "grant", "revoke", "clear"]);
+const ACTIONS = new Set(["list", "revoke", "clear"]);
 
 export function createApprovalCommand({ chooseWorkspace, confirm }) {
   if (typeof chooseWorkspace !== "function" || typeof confirm !== "function") {
@@ -16,85 +13,44 @@ export function createApprovalCommand({ chooseWorkspace, confirm }) {
   }
   return async function approvalCommand(args) {
     const action = String(args._[0] || "list").toLowerCase();
-    if (!ACTIONS.has(action)) throw new Error(`Unknown approval action: ${action}`);
+    if (!ACTIONS.has(action)) {
+      throw new Error("Terminal operation approval was removed. Remote calls run automatically within the account role ceiling; use account management to change trust and approval revoke/clear only to remove legacy leases.");
+    }
     const workspace = await chooseWorkspace({ ...args, _: [] }, { promptOnFirstRun: false, save: false, allowPositional: false });
     const state = loadState(workspace, { stateDir: args.stateDir });
     const root = state.paths.profileDir;
     if (action === "list") return renderList(listOperationApprovals(root), args.json === true);
-    if (action === "approve") {
-      const id = requiredPositional(args, 1, "approval approve requires APPROVAL_ID");
-      return renderLease(await approvePendingOperation(
-        root,
-        id,
-        args.duration || (args.full ? "8h" : "1h"),
-        Date.now(),
-        args.full ? "full" : "",
-      ), args.json === true, "Approved");
-    }
-    if (action === "grant") {
-      const scope = requiredPositional(args, 1, "approval grant requires SCOPE");
-      if (!OPERATION_APPROVAL_SCOPES.includes(scope)) {
-        throw new Error(`approval scope must be one of: ${OPERATION_APPROVAL_SCOPES.join(", ")}`);
-      }
-      const clientId = String(args.client || "");
-      const accountId = String(args.account || "");
-      if (!clientId) throw new Error("approval grant requires --client CLIENT_ID; use * only for an intentional all-client lease");
-      if (!accountId) throw new Error("approval grant requires --account ACCOUNT_ID; use * only for an intentional all-account lease");
-      return renderLease(await grantOperationLease(root, {
-        accountId,
-        clientId,
-        scope,
-        duration: args.duration || "1h",
-      }), args.json === true, "Granted");
-    }
     if (action === "revoke") {
       const id = requiredPositional(args, 1, "approval revoke requires LEASE_ID");
       const removed = await revokeOperationLease(root, id);
       if (args.json) console.log(JSON.stringify({ lease_id: id, revoked: removed }, null, 2));
-      else console.log(removed ? `Revoked capability lease: ${id}` : `Capability lease was not active: ${id}`);
+      else console.log(removed ? `Revoked legacy capability lease: ${id}` : `Legacy capability lease was not active: ${id}`);
       return;
     }
-    const approved = await confirm("Revoke all active remote capability leases?", args.yes === true);
+    const approved = await confirm("Revoke all legacy remote capability leases?", args.yes === true);
     if (!approved) {
-      console.log("No capability leases were changed.");
+      console.log("No legacy capability leases were changed.");
       return;
     }
     await clearOperationLeases(root);
     if (args.json) console.log(JSON.stringify({ cleared: true }, null, 2));
-    else console.log("Revoked all active remote capability leases.");
+    else console.log("Revoked all legacy remote capability leases.");
   };
 }
 
 function renderList(result, json) {
   if (json) {
-    console.log(JSON.stringify(result, null, 2));
+    console.log(JSON.stringify({ ...result, runtime_authorization: "automatic-within-role-ceiling" }, null, 2));
     return;
   }
-  if (!result.pending.length && !result.leases.length) {
-    console.log("No pending approvals or active capability leases.");
+  if (!result.leases.length) {
+    console.log("No active legacy capability leases. Runtime authorization is automatic within each account role ceiling.");
     return;
   }
-  if (result.pending.length) {
-    console.log("Pending approvals:");
-    for (const item of result.pending) {
-      console.log(`  ${item.id}\t${scopeText(item.scopes)}\t${item.category}\tclient ${shortId(item.client_id)}\texpires ${formatTime(item.expires_at)}`);
-    }
-  }
-  if (result.leases.length) {
-    console.log("Active capability leases:");
-    for (const item of result.leases) {
-      console.log(`  ${item.id}\t${scopeText(item.scopes)}\tclient ${shortId(item.client_id)}\texpires ${formatTime(item.expires_at)}`);
-    }
-  }
-}
-
-function renderLease(lease, json, verb) {
-  if (json) {
-    console.log(JSON.stringify(lease, null, 2));
-    return;
+  console.log("Legacy capability leases (not consumed by the current runtime):");
+  for (const item of result.leases) {
+    console.log(`  ${item.id}\t${scopeText(item.scopes)}\tclient ${shortId(item.client_id)}\texpires ${formatTime(item.expires_at)}`);
   }
-  console.log(`${verb} ${scopeText(lease.scopes)} capability lease for client ${shortId(lease.client_id)} until ${formatTime(lease.expires_at)}.`);
-  console.log(`Lease ID: ${lease.id}`);
 }
 
 function requiredPositional(args, index, message) {

package/src/local/cli-local-admin.mjs

@@ -244,7 +244,10 @@ function readBrowserPairingState(pairingFile) {
     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");
+  const extensionToken = String(pairing.extensionToken || pairing.token || "");
+  if (!/^[A-Za-z0-9_-]{32,100}$/.test(extensionToken) || (pairing.runtimeToken !== undefined && !/^[A-Za-z0-9_-]{32,100}$/.test(String(pairing.runtimeToken)))) {
+    throw new Error("browser bridge state contains invalid bounded tokens");
+  }
   if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error("browser bridge state contains an invalid port");
   return { port };
 }
@@ -302,7 +305,7 @@ function openExternal(target) {
   });
 }
 
-async function jobCommand(args, { chooseWorkspace, confirm }) {
+async function jobCommand(args, { chooseWorkspace }) {
   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 });
@@ -320,19 +323,6 @@ async function jobCommand(args, { chooseWorkspace, confirm }) {
   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");

package/src/local/cli-options.mjs

@@ -3,10 +3,10 @@ import { normalizeLogLevel } from "./log.mjs";
 const BOOLEAN_OPTIONS = new Set([
   "help", "version", "quiet", "json", "verbose", "rotateSecrets", "forceWorker",
   "daemonOnly", "noAutostart", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
-  "yes", "keepWorker", "allowInsecurePermissions", "showPaths", "full",
+  "yes", "keepWorker", "allowInsecurePermissions", "showPaths",
 ]);
 const VALUE_OPTIONS = new Set([
-  "workspace", "stateDir", "workerName", "profile", "execMode", "client", "account", "duration", "logLevel", "logFormat",
+  "workspace", "stateDir", "workerName", "profile", "execMode", "client", "logLevel", "logFormat",
 ]);
 
 const LOG_FORMATS = new Set(["text", "json"]);
@@ -17,6 +17,10 @@ const COMMAND_OPTIONS = new Map(Object.entries({
     "daemonOnly", "noAutostart",
     "profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
   ]),
+  activate: new Set([
+    "workspace", "stateDir", "workerName", "quiet", "json", "verbose", "logLevel", "logFormat", "rotateSecrets", "forceWorker",
+    "profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths",
+  ]),
   stdio: new Set(["workspace", "stateDir", "profile", "execMode", "noWrite", "noExec", "fullEnv", "unrestrictedPaths", "absolutePaths", "verbose", "quiet", "logLevel", "logFormat"]),
   "client-config": new Set(["workspace", "stateDir", "profile", "client", "json"]),
   status: new Set(["workspace", "stateDir"]),
@@ -28,13 +32,13 @@ const COMMAND_OPTIONS = new Map(Object.entries({
   autostart: new Set(["workspace", "stateDir", "quiet"]),
   resource: new Set(["workspace", "stateDir", "allowInsecurePermissions", "showPaths", "json"]),
   account: new Set(["workspace", "stateDir", "json", "yes"]),
-  approval: new Set(["workspace", "stateDir", "json", "yes", "client", "account", "duration", "full"]),
+  approval: new Set(["workspace", "stateDir", "json", "yes"]),
   browser: new Set(["workspace", "stateDir", "json"]),
   job: new Set(["workspace", "stateDir", "json", "yes"]),
   uninstall: new Set(["stateDir", "keepWorker", "yes"]),
 }));
 
-const SINGLE_WORKSPACE_POSITIONAL_COMMANDS = new Set(["start", "stdio", "status", "doctor", "full-test", "rotate-secrets"]);
+const SINGLE_WORKSPACE_POSITIONAL_COMMANDS = new Set(["start", "activate", "stdio", "status", "doctor", "full-test", "rotate-secrets"]);
 const STATIC_POSITIONAL_RULES = new Map([
   ["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" })],
@@ -42,7 +46,7 @@ const STATIC_POSITIONAL_RULES = new Map([
 const RESOURCE_POSITIONAL_LIMITS = new Map(Object.entries({ add: 3, "generate-ssh-key": 3, remove: 2, check: 2 }));
 const JOB_POSITIONAL_LIMITS = new Map(Object.entries({ read: 2, inspect: 2, cancel: 2, approve: 2, submit: 2 }));
 const ACCOUNT_POSITIONAL_LIMITS = new Map(Object.entries({ list: 1, add: 3, role: 3, enable: 2, disable: 2, "rotate-password": 2, remove: 2 }));
-const APPROVAL_POSITIONAL_LIMITS = new Map(Object.entries({ list: 1, approve: 2, grant: 2, revoke: 2, clear: 1 }));
+const APPROVAL_POSITIONAL_LIMITS = new Map(Object.entries({ list: 1, revoke: 2, clear: 1 }));
 const ACTION_POSITIONAL_RULES = new Map(Object.entries({
   workspace(args) {
     const action = String(args._[0] || "show");
@@ -50,7 +54,7 @@ const ACTION_POSITIONAL_RULES = new Map(Object.entries({
   },
   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 };
+    return { max: ["install", "status", "stop"].includes(action) ? 2 : 1, tooMany: `service ${action} received too many positional arguments`, workspaceConflictAfter: 1 };
   },
   autostart(args) { return ACTION_POSITIONAL_RULES.get("service")(args); },
   resource(args) {
@@ -63,7 +67,7 @@ const ACTION_POSITIONAL_RULES = new Map(Object.entries({
   },
   approval(args) {
     const action = String(args._[0] || "list");
-    return { max: APPROVAL_POSITIONAL_LIMITS.get(action) ?? 1, tooMany: `approval ${action} received too many positional arguments` };
+    return { max: APPROVAL_POSITIONAL_LIMITS.get(action) ?? 2, tooMany: `approval ${action} received too many positional arguments` };
   },
   browser(args) {
     const action = String(args._[0] || "status");

package/src/local/cli-service.mjs

@@ -3,12 +3,14 @@ import * as defaultService from "./service.mjs";
 import { inspectWorkspaceDaemon, stopWorkspaceServiceDaemon } from "./daemon-process.mjs";
 import { stopAndRemoveAutostart } from "./service-lifecycle.mjs";
 import { serviceEnvironmentSummary } from "./service-environment.mjs";
+import { scheduleServiceRestart } from "./service-restart-scheduler.mjs";
 import { loadState, resolveWorkspace, selectedWorkspace } from "./state.mjs";
 
 const SERVICE_ACTION_HANDLERS = new Map([
   ["status", serviceStatusAction],
   ["install", serviceInstallAction],
   ["start", serviceStartAction],
+  ["restart", serviceRestartAction],
   ["stop", serviceStopAction],
   ["uninstall", serviceUninstallAction],
   ["remove", serviceUninstallAction],
@@ -24,6 +26,7 @@ export function createServiceCommand(dependencies) {
     stopWorkspaceServiceDaemon: dependencies.stopWorkspaceServiceDaemon || stopWorkspaceServiceDaemon,
     stopAndRemoveAutostart: dependencies.stopAndRemoveAutostart || stopAndRemoveAutostart,
     serviceEnvironmentSummary: dependencies.serviceEnvironmentSummary || serviceEnvironmentSummary,
+    scheduleServiceRestart: dependencies.scheduleServiceRestart || scheduleServiceRestart,
     loadState: dependencies.loadState || loadState,
     resolveWorkspace: dependencies.resolveWorkspace || resolveWorkspace,
     selectedWorkspace: dependencies.selectedWorkspace || selectedWorkspace,
@@ -73,14 +76,24 @@ async function serviceInstallAction({ args, stateRoot, service, context }) {
 }
 
 async function serviceStartAction({ args, service, context }) {
+  assertGlobalServiceAction(args, "start");
   const result = await service.startAutostart({ logger: context.structuredLogger(Boolean(args.quiet)) });
   printServiceResult(result, context);
 }
 
+async function serviceRestartAction({ args, context }) {
+  assertGlobalServiceAction(args, "restart");
+  const result = await context.scheduleServiceRestart();
+  printServiceResult({ ...result, provider: "detached-handoff", reason: "restart_scheduled" }, context);
+}
+
 async function serviceStopAction({ args, stateRoot, service, context }) {
   const logger = context.structuredLogger(Boolean(args.quiet));
-  const provider = await service.stopAutostart({ logger });
   const state = optionalServiceState(args, stateRoot, context);
+  const status = await service.autostartStatus();
+  const before = state ? context.inspectWorkspaceDaemon(state) : null;
+  assertExplicitStopTarget(args, status, before);
+  const provider = await service.stopAutostart({ logger });
   const workspaceDaemon = state
     ? await context.stopWorkspaceServiceDaemon(state, { logger, reason: "service stop" })
     : { ok: true, found: false, stopped: false, verified_service_daemon: false, reason: "workspace_not_selected" };
@@ -92,16 +105,17 @@ async function serviceStopAction({ args, stateRoot, service, context }) {
   }, context);
 }
 
-async function serviceUninstallAction({ args, stateRoot, service, context }) {
+async function serviceUninstallAction({ args, stateRoot, context }) {
+  assertGlobalServiceAction(args, "uninstall");
   const logger = context.structuredLogger(Boolean(args.quiet));
-  const state = optionalServiceState(args, stateRoot, context);
+  const state = optionalServiceState({ ...args, workspace: undefined, stateDir: undefined }, stateRoot, context);
   const lifecycle = await context.stopAndRemoveAutostart({
     states: state ? [state] : [],
     stateRoot,
     logger,
     reason: "service uninstall",
-    stopAutostart: service.stopAutostart,
-    uninstallAutostart: service.uninstallAutostart,
+    stopAutostart: context.service.stopAutostart,
+    uninstallAutostart: context.service.uninstallAutostart,
     stopWorkspaceServiceDaemon: context.stopWorkspaceServiceDaemon,
   });
   printServiceResult({
@@ -112,6 +126,22 @@ async function serviceUninstallAction({ args, stateRoot, service, context }) {
   }, context);
 }
 
+function assertGlobalServiceAction(args, action) {
+  if (args.workspace || args.stateDir || args._[1]) {
+    throw new Error(`service ${action} acts on the single installed machine service and does not accept workspace or state overrides; use service install to change its owner`);
+  }
+}
+
+function assertExplicitStopTarget(args, status, workspaceDaemon) {
+  if (!hasExplicitServiceTarget(args) || status?.active !== true) return;
+  if (workspaceDaemon?.alive === true && workspaceDaemon?.verified_service_daemon === true) return;
+  throw new Error("refusing to stop the active machine service because the requested workspace/state does not own its verified daemon; omit the target to stop the installed service globally");
+}
+
+function hasExplicitServiceTarget(args) {
+  return Boolean(args.workspace || args.stateDir || args._[1]);
+}
+
 function optionalServiceState(args, stateRoot, context) {
   const requested = args.workspace || args._[1] || context.selectedWorkspace(stateRoot);
   if (!requested || requested === true) return null;