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

package/src/local/runtime-relay.mjs

@@ -1,49 +1,21 @@
 import { Buffer } from "node:buffer";
-import { RelayConnection } from "./relay-connection.mjs";
-import { createDaemonAuthentication, createDaemonPreflightHeaders } from "./device-identity.mjs";
-import { MCP_SUPPORTED_PROTOCOL_VERSIONS, SERVER_NAME } from "./tools.mjs";
+import relayContract from "../shared/relay-contract.json" with { type: "json" };
+import { ResilientRelayConnection } from "./resilient-relay-connection.mjs";
+import { createDeviceSessionIdentity, validateDeviceSessionIdentity } from "./device-identity.mjs";
+import { SERVER_NAME } from "./tools.mjs";
 import { normalizeAccountRole } from "./account-access.mjs";
-import { clampInteger } from "./numbers.mjs";
 import { isPlainRecord } from "./records.mjs";
-
-export const MAX_RELAY_MESSAGE_BYTES = 8 * 1024 * 1024;
-
+import { MAX_RELAY_MESSAGE_BYTES, runtimeRelayConnectionOptions } from "./runtime-relay-connection-options.mjs";
+export { MAX_RELAY_MESSAGE_BYTES } from "./runtime-relay-connection-options.mjs";
+const RELAY_CALL_ID = /^call_[A-Za-z0-9_-]{8,240}$/; const RELAY_TOOL_NAME = /^[a-z][a-z0-9_]{0,127}$/;
 export function createRuntimeRelayConnection(runtime, { workerUrl, deviceIdentity, expectedVersion, onFatal }) {
-  if (!workerUrl) return null;
-  return new RelayConnection({
-    workerUrl,
-    logger: runtime.logger,
-    maxPayload: MAX_RELAY_MESSAGE_BYTES,
-    expectedServer: SERVER_NAME,
-    expectedVersion: String(expectedVersion || ""),
-    connectionHeaders: () => createDaemonPreflightHeaders(
-      deviceIdentity,
-      workerUrl,
-      SERVER_NAME,
-      String(expectedVersion || ""),
-    ),
-    helloMessage: async (welcome) => ({
-      type: "hello",
-      instance_id: runtime.relayInstanceId,
-      tools: runtime.tools(),
-      policy: runtime.policy,
-      protocol_versions: MCP_SUPPORTED_PROTOCOL_VERSIONS,
-      authentication: await createDaemonAuthentication(deviceIdentity, welcome, runtime.relayInstanceId),
-    }),
+  if (!workerUrl || !deviceIdentity) return null;
+  const sessionIdentity = deviceIdentity?.certificate ? validateDeviceSessionIdentity(deviceIdentity)
+    : createDeviceSessionIdentity(deviceIdentity, workerUrl, SERVER_NAME, String(expectedVersion || ""));
+  return new ResilientRelayConnection(runtimeRelayConnectionOptions(runtime, {
+    workerUrl, sessionIdentity, expectedVersion, onFatal,
     onMessage: (data, relayContext) => handleRelayData(runtime, data, relayContext),
-    onDisconnect: () => runtime.handleRelayDisconnect(),
-    onReady: () => runtime.handleRelayReady(),
-    onSuperseded: () => {
-      runtime.terminateActiveProcesses("SIGKILL");
-      runtime.processSessionManager.clear();
-      runtime.onSuperseded?.();
-    },
-    onFatal: (error) => {
-      runtime.terminateActiveProcesses("SIGKILL");
-      runtime.processSessionManager.clear();
-      onFatal?.(error);
-    },
-  });
+  }));
 }
 
 export function normalizeRelayResumeCalls(message) {
@@ -51,7 +23,7 @@ export function normalizeRelayResumeCalls(message) {
   const ids = [];
   const seen = new Set();
   for (const value of message.ids) {
-    if (typeof value !== "string" || !/^call_[A-Za-z0-9_-]{8,240}$/.test(value) || seen.has(value)) {
+    if (typeof value !== "string" || !RELAY_CALL_ID.test(value) || seen.has(value)) {
       return { ok: false, ids: [] };
     }
     seen.add(value);
@@ -61,18 +33,21 @@ export function normalizeRelayResumeCalls(message) {
 }
 
 export function normalizeRelayToolCall(message) {
-  const id = typeof message.id === "string" && message.id.length <= 256 ? message.id : "";
-  const tool = typeof message.tool === "string" && message.tool.length <= 128 ? message.tool : "";
+  const id = typeof message.id === "string" && RELAY_CALL_ID.test(message.id) ? message.id : "";
+  const tool = typeof message.tool === "string" && RELAY_TOOL_NAME.test(message.tool) ? message.tool : "";
   const argumentsValue = message.arguments === undefined ? {} : message.arguments;
   const authorization = normalizeRelayAuthorization(message.authorization);
-  if (!id || !tool || !isPlainRecord(argumentsValue) || !authorization) return { ok: false, id };
+  const timeoutMs = message.timeout_ms;
+  if (!id || !tool || !isPlainRecord(argumentsValue) || !authorization
+      || typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs)
+      || timeoutMs < 1000 || timeoutMs > relayContract.maximumRelayToolTimeoutMs) return { ok: false, id };
   return {
     ok: true,
     id,
     tool,
     arguments: argumentsValue,
     authorization,
-    timeoutMs: clampInteger(message.timeout_ms, 60_000, 1000, 610_000),
+    timeoutMs,
   };
 }
 
@@ -88,10 +63,11 @@ function handleRelayData(runtime, data, relayContext = {}) {
 function normalizeRelayAuthorization(value) {
   if (!isPlainRecord(value)) return null;
   const accountId = typeof value.account_id === "string" && /^acct_[A-Za-z0-9_-]{20,96}$/.test(value.account_id) ? value.account_id : "";
-  const accountVersion = Number(value.account_version);
+  const accountVersion = value.account_version;
   const clientId = typeof value.client_id === "string" && /^mcp_client_[A-Za-z0-9_-]{43}$/.test(value.client_id) ? value.client_id : "";
+  const familyId = typeof value.family_id === "string" && /^mcp_family_[A-Za-z0-9_-]{43}$/.test(value.family_id) ? value.family_id : "";
   let role;
-  try { role = normalizeAccountRole(value.role); } catch { return null; }
-  if (!accountId || !clientId || !Number.isInteger(accountVersion) || accountVersion < 1) return null;
-  return Object.freeze({ account_id: accountId, account_version: accountVersion, client_id: clientId, role });
+  try { role = typeof value.role === "string" ? normalizeAccountRole(value.role) : null; } catch { return null; }
+  if (!accountId || !clientId || !familyId || !role || !Number.isSafeInteger(accountVersion) || accountVersion < 1) return null;
+  return Object.freeze({ account_id: accountId, account_version: accountVersion, client_id: clientId, family_id: familyId, role });
 }

package/src/local/runtime-reporting.mjs

@@ -4,12 +4,18 @@ import {
   POLICY_PROFILES, SERVER_NAME,
 } from "./tools.mjs";
 import { executionGuardrailsSnapshot } from "./execution-limits.mjs";
+import {
+  hiddenGlobalActivity, hiddenInFlightActivity, publicDeviceRootStatus, publicSecurityAudit, runtimeActivityVisible,
+} from "./runtime-activity-projection.mjs";
+
+const MAX_PROJECT_OVERVIEW_TOP_LEVEL_ENTRIES = 40;
 
 export function buildRuntimeInfo({
   workspace,
   displayPath,
   policy,
   toolNames,
+  daemonToolNames = toolNames,
   capabilityObserver,
   observability,
   callRegistry,
@@ -19,7 +25,12 @@ export function buildRuntimeInfo({
   processTracker,
   processSessionManager,
   managedJobManager,
+  securityAudit = null,
+  deviceRootStatus = null,
+  context = {},
 }) {
+  const globalActivityVisible = runtimeActivityVisible(context);
+  const inFlightCalls = callRegistry.snapshot();
   return {
     name: SERVER_NAME,
     protocol_version: MCP_PROTOCOL_VERSION,
@@ -42,7 +53,8 @@ export function buildRuntimeInfo({
     },
     tool_delivery: {
       full_profile_scope: "local-daemon-and-relay-advertisement",
-      daemon_advertised_tool_count: toolNames.length + 1,
+      effective_tool_count: toolNames.length + 1,
+      daemon_advertised_tool_count: daemonToolNames.length + 1,
       host_exposed_tools_known_to_server: false,
       host_may_expose_subset: true,
     },
@@ -54,21 +66,23 @@ export function buildRuntimeInfo({
       per_tool_events: "structured-debug-events",
       default_logs_include_tool_failures: false,
       tool_arguments_or_results_logged: false,
-      capability_routing: capabilityObserver.snapshot(),
-      tool_calls: observability.snapshot(),
-      in_flight_calls: callRegistry.snapshot(),
+      capability_routing: globalActivityVisible ? capabilityObserver.snapshot() : hiddenGlobalActivity(),
+      tool_calls: globalActivityVisible ? observability.snapshot() : hiddenGlobalActivity(),
+      in_flight_calls: globalActivityVisible ? inFlightCalls : hiddenInFlightActivity(inFlightCalls),
     },
     runtime: {
       environment: policy.minimalEnv ? "isolated-minimal" : "full-parent",
       lifecycle: lifecycle.snapshot(),
       relay: relayStatus(),
       runtime_dir: policy.exposeAbsolutePaths ? runtimeDir : "<private-runtime-dir>",
-      processes: processTracker.snapshot(),
+      processes: globalActivityVisible ? processTracker.snapshot() : hiddenGlobalActivity(),
       execution_guardrails: executionGuardrailsSnapshot(),
-      process_sessions: processSessionManager.status(),
-      managed_jobs: managedJobManager.status(),
-      local_resources: managedJobManager.resourceInfo(),
+      process_sessions: processSessionManager.status(context),
+      managed_jobs: managedJobManager.status(context),
+      local_resources: managedJobManager.resourceInfo(context),
     },
+    ...(securityAudit ? { security_audit: publicSecurityAudit(securityAudit, globalActivityVisible) } : {}),
+    trust: { device_root: publicDeviceRootStatus(deviceRootStatus, globalActivityVisible) },
   };
 }
 
@@ -77,30 +91,32 @@ export async function buildProjectOverview({
   displayPath,
   policy,
   toolNames,
+  daemonPolicy = policy,
+  daemonToolNames = toolNames,
   capabilityObserver,
   listTopLevel,
-  runProcess,
+  resolveGitRoot,
   safeErrorMessage,
   throwIfCancelled,
 }, context = {}) {
   throwIfCancelled(context);
-  const top = await listTopLevel(context).catch((error) => ({ error: safeErrorMessage(error), entries: [] }));
-  const git = await runProcess(
-    "git",
-    ["-c", "core.fsmonitor=false", "-C", workspace, "rev-parse", "--show-toplevel"],
-    10_000,
-    true,
-    512 * 1024,
-    context,
-  );
+  const topPromise = listTopLevel(context).catch((error) => ({ error: safeErrorMessage(error), entries: [] }));
+  const gitPromise = resolveGitRoot(context);
+  const [top, gitRoot] = await Promise.all([topPromise, gitPromise]);
+  const topEntries = Array.isArray(top.entries) ? top.entries : [];
+  const topLevel = topEntries.slice(0, MAX_PROJECT_OVERVIEW_TOP_LEVEL_ENTRIES);
   return {
     workspace: displayPath(workspace),
     workspaceName: policy.exposeAbsolutePaths ? basename(workspace) : "workspace",
-    gitRoot: git.code === 0 ? displayPath(git.stdout.trim()) : "",
+    gitRoot: gitRoot ? displayPath(gitRoot) : "",
     policy,
     tools: ["server_info", ...toolNames],
-    capabilityRouting: capabilityObserver.snapshot(),
-    topLevel: top.entries || [],
+    daemonPolicy,
+    daemonTools: ["server_info", ...daemonToolNames],
+    capabilityRouting: runtimeActivityVisible(context) ? capabilityObserver.snapshot() : hiddenGlobalActivity(),
+    topLevel,
+    topLevelTotal: topEntries.length,
+    topLevelTruncated: Boolean(top.truncated || topEntries.length > topLevel.length),
   };
 }
 

package/src/local/runtime-resource-service.mjs

@@ -0,0 +1,77 @@
+import { resolve } from "node:path";
+import { inspectResourceFile } from "./managed-job-plan.mjs";
+import { generateRegisteredSshKey } from "./resource-operations.mjs";
+import { expandHome } from "./state.mjs";
+import { stateRootFromProfileStatePath } from "./runtime-paths.mjs";
+
+const MAX_BROWSER_RESOURCE_BYTES = 1024 * 1024;
+
+export class RuntimeResourceService {
+  constructor({ workspace, resourceStatePath = "", currentResources, authorizeTool }) {
+    this.workspace = resolve(workspace);
+    this.resourceStatePath = resourceStatePath ? resolve(resourceStatePath) : "";
+    this.currentResources = currentResources;
+    this.authorizeTool = authorizeTool;
+  }
+
+  readBinary(name) {
+    const registry = this.currentResources();
+    const resource = Object.hasOwn(registry, name) ? registry[name] : null;
+    if (!resource) throw new Error(`unknown local resource: ${name}`);
+    const inspected = inspectResourceFile(resource.path, {
+      allowInsecurePermissions: resource.allowInsecurePermissions === true,
+      includeContent: true,
+    });
+    if (inspected.size > MAX_BROWSER_RESOURCE_BYTES) {
+      throw new Error("local resource exceeds 1 MiB browser injection limit");
+    }
+    return {
+      buffer: inspected.content,
+      path: inspected.path,
+      size: inspected.size,
+    };
+  }
+
+  readText(name) {
+    const { buffer } = this.readBinary(name);
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    } catch {
+      throw new Error(`local resource is not valid UTF-8 text: ${name}`);
+    }
+  }
+
+  async generateSshKey(args = {}) {
+    this.authorizeTool("generate_ssh_key_resource");
+    if (!this.resourceStatePath) throw new Error("local resource state is unavailable in this runtime");
+    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 target = args.path
+      ? resolve(expandHome(String(args.path)))
+      : resolve(home, ".ssh", `machine-mcp-${args.name}-ed25519`);
+    const key = await generateRegisteredSshKey({
+      workspace: this.workspace,
+      stateDir: stateRootFromProfileStatePath(this.resourceStatePath),
+      name: args.name,
+      targetPath: target,
+      comment: args.comment || `machine-mcp:${args.name}`,
+    });
+    const exposePaths = args.expose_paths === true;
+    return {
+      name: key.name,
+      created: key.created,
+      registered: key.registered,
+      fingerprint: key.fingerprint,
+      key_type: key.keyType,
+      private_mode: key.privateMode,
+      public_mode: key.publicMode,
+      private_key_content_exposed: key.privateKeyContentExposed,
+      available_to_new_jobs_immediately: key.availableToNewJobsImmediately,
+      paths_exposed: exposePaths,
+      ...(exposePaths ? {
+        private_key_path: resolve(key.privateKeyPath),
+        public_key_path: resolve(key.publicKeyPath),
+      } : {}),
+    };
+  }
+}

package/src/local/runtime-tool-handlers.mjs

@@ -1,8 +1,8 @@
 import { clampInteger } from "./numbers.mjs";
 
 const RUNTIME_TOOL_HANDLERS = Object.freeze({
-  server_info: (runtime) => runtime.runtimeInfo(),
-  project_overview: (runtime, _args, context) => runtime.projectOverview(context),
+  server_info: (runtime, args, context) => runtime.serverInfo(args, context),
+  project_overview: (runtime, args, context) => runtime.projectOverview(args, context),
   session_bootstrap: (runtime, args, context) => runtime.sessionBootstrap(args, context),
   agent_context: (runtime, args, context) => runtime.agentContextManager.agentContext(args, context),
   resolve_task_capabilities: (runtime, args, context) => runtime.resolveTaskCapabilities(args, context),
@@ -14,6 +14,8 @@ const RUNTIME_TOOL_HANDLERS = Object.freeze({
   open_local_application: (runtime, args, context) => runtime.appAutomationManager.openApplication(args, context),
   inspect_local_application: (runtime, args, context) => runtime.appAutomationManager.inspectApplication(args, context),
   operate_local_application: (runtime, args, context) => runtime.appAutomationManager.operateApplication(args, context),
+  computer_observe: (runtime, args, context) => runtime.computerUseManager.observe(args, context),
+  computer_act: (runtime, args, context) => runtime.computerUseManager.act(args, context),
   browser_status: (runtime, _args, context) => runtime.browserBridgeManager.status(context),
   pair_browser_extension: (runtime, args, context) => runtime.browserBridgeManager.pair(args, context),
   browser_list_tabs: (runtime, args, context) => runtime.browserBridgeManager.listTabs(args, context),
@@ -25,7 +27,7 @@ const RUNTIME_TOOL_HANDLERS = Object.freeze({
   browser_fill_form: (runtime, args, context) => runtime.browserBridgeManager.fillForm(args, context),
   browser_screenshot: (runtime, args, context) => runtime.browserBridgeManager.screenshot(args, context),
   browser_upload_files: (runtime, args, context) => runtime.browserBridgeManager.uploadFiles(args, context),
-  list_roots: (runtime) => runtime.listRoots(),
+  list_roots: (runtime, _args, context) => runtime.listRoots(context),
   list_dir: (runtime, args, context) => runtime.listDir(args.path || ".", context),
   list_files: (runtime, args, context) => runtime.listFiles(args.path || ".", clampInteger(args.max_files, 1000, 1, 10000), context),
   read_file: (runtime, args, context) => runtime.readFile(args, context),
@@ -38,20 +40,21 @@ const RUNTIME_TOOL_HANDLERS = Object.freeze({
   git_diff: (runtime, args, context) => runtime.gitDiff(args, context),
   git_log: (runtime, args, context) => runtime.gitLog(args, context),
   git_show: (runtime, args, context) => runtime.gitShow(args, context),
+  git_commit: (runtime, args, context) => runtime.gitCommit(args, context),
   diagnose_runtime: (runtime, _args, context) => runtime.diagnoseRuntime(context),
-  list_local_resources: (runtime) => runtime.managedJobManager.listResources(),
+  list_local_resources: (runtime, _args, context) => runtime.managedJobManager.listResources(context),
   generate_ssh_key_resource: (runtime, args, context) => runtime.generateSshKeyResource(args, context),
-  stage_job: (runtime, args) => runtime.managedJobManager.stage(args),
-  start_job: (runtime, args) => runtime.managedJobManager.start(args),
-  list_jobs: (runtime, args) => runtime.managedJobManager.list(args),
-  read_job: (runtime, args) => runtime.managedJobManager.read(args),
-  cancel_job: (runtime, args) => runtime.managedJobManager.cancel(args),
+  stage_job: (runtime, args, context) => runtime.managedJobManager.stage(args, context),
+  start_job: (runtime, args, context) => runtime.managedJobManager.start(args, context),
+  list_jobs: (runtime, args, context) => runtime.managedJobManager.list(args, context),
+  read_job: (runtime, args, context) => runtime.managedJobManager.read(args, context),
+  cancel_job: (runtime, args, context) => runtime.managedJobManager.cancel(args, context),
   run_process: (runtime, args, context) => runtime.runDirectProcess(args, context),
   start_process: (runtime, args, context) => runtime.processSessionManager.start(args, context),
   read_process: (runtime, args, context) => runtime.processSessionManager.read(args, context),
   write_process: (runtime, args, context) => runtime.processSessionManager.write(args, context),
   kill_process: (runtime, args, context) => runtime.processSessionManager.kill(args, context),
-  exec_command: (runtime, args, context) => runtime.execCommand(args.command, clampInteger(args.timeout_seconds, 120, 1, 600), context),
+  exec_command: (runtime, args, context) => runtime.execCommand(args, context),
 });
 
 export function runtimeToolHandlerNames() {