machine-bridge-mcp 1.2.8 → 1.2.10

package/src/local/runtime.mjs

@@ -1,12 +1,12 @@
-import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { realpathSync, rmSync } from "node:fs";
 import { lstat, realpath, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { isRelayReadyContext, RelayConnection } from "./relay-connection.mjs";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { isRelayReadyContext } from "./relay-connection.mjs";
 import { ProcessSessionManager } from "./process-sessions.mjs";
 import { MAX_CONCURRENT_TOOL_CALLS } from "./execution-limits.mjs";
 export { MAX_COMMAND_BYTES } from "./process-contract.mjs";
-import { MCP_SUPPORTED_PROTOCOL_VERSIONS, normalizePolicy, PolicyGate, SERVER_NAME } from "./tools.mjs";
+import { normalizePolicy, PolicyGate } from "./tools.mjs";
 import { publicError } from "./errors.mjs";
 import { ProcessTracker } from "./process-tracker.mjs";
 import { CallRegistry } from "./call-registry.mjs";
@@ -26,75 +26,23 @@ import { AppAutomationManager } from "./app-automation.mjs";
 import { BrowserBridgeManager } from "./browser-bridge.mjs";
 import { CapabilityObserver } from "./capability-observer.mjs";
 import { readBoundedRegularFileSync } from "./secure-file.mjs";
-import { clampInteger } from "./numbers.mjs";
 import { isPlainRecord } from "./records.mjs";
-import { AccountAccessGate, normalizeAccountRole } from "./account-access.mjs";
+import { AccountAccessGate } from "./account-access.mjs";
 import { buildProjectOverview, buildRuntimeInfo } from "./runtime-reporting.mjs";
 import { diagnoseRuntime as runRuntimeDiagnostics } from "./runtime-diagnostics.mjs";
+import { bindRuntimeToolHandlers, runtimeToolHandlerNames as registeredRuntimeToolHandlerNames } from "./runtime-tool-handlers.mjs";
+import { createRuntimeRelayConnection, normalizeRelayResumeCalls, normalizeRelayToolCall } from "./runtime-relay.mjs";
+import { RelayCallRecovery } from "./relay-call-recovery.mjs";
+import { assertContainedPath, createRuntimeDir, redactRuntimeErrorMessage, stateRootFromProfileStatePath } from "./runtime-paths.mjs";
 import {
   resolveTaskCapabilities as resolveRuntimeTaskCapabilities,
   sessionBootstrap as buildRuntimeSessionBootstrap,
 } from "./runtime-capabilities.mjs";
 
-const MAX_WS_MESSAGE_BYTES = 8 * 1024 * 1024;
 const SLOW_TOOL_CALL_MS = 30_000;
 
-const RUNTIME_TOOL_HANDLERS = Object.freeze({
-  server_info: (runtime) => runtime.runtimeInfo(),
-  project_overview: (runtime, _args, context) => runtime.projectOverview(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),
-  list_local_skills: (runtime, args, context) => runtime.agentContextManager.listLocalSkills(args, context),
-  load_local_skill: (runtime, args, context) => runtime.agentContextManager.loadLocalSkill(args, context),
-  list_local_commands: (runtime, args, context) => runtime.agentContextManager.listLocalCommands(args, context),
-  run_local_command: (runtime, args, context) => runtime.runLocalCommand(args, context),
-  list_local_applications: (runtime, args, context) => runtime.appAutomationManager.listApplications(args, context),
-  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),
-  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),
-  browser_manage_tabs: (runtime, args, context) => runtime.browserBridgeManager.manageTabs(args, context),
-  browser_wait: (runtime, args, context) => runtime.browserBridgeManager.wait(args, context),
-  browser_get_source: (runtime, args, context) => runtime.browserBridgeManager.getSource(args, context),
-  browser_inspect_page: (runtime, args, context) => runtime.browserBridgeManager.inspectPage(args, context),
-  browser_action: (runtime, args, context) => runtime.browserBridgeManager.act(args, context),
-  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_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),
-  view_image: (runtime, args, context) => runtime.viewImage(args, context),
-  write_file: (runtime, args, context) => runtime.writeFile(args, context),
-  edit_file: (runtime, args, context) => runtime.editFile(args, context),
-  apply_patch: (runtime, args, context) => runtime.applyPatch(args, context),
-  search_text: (runtime, args, context) => runtime.searchText(args, context),
-  git_status: (runtime, args, context) => runtime.gitStatus(args, context),
-  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),
-  diagnose_runtime: (runtime, _args, context) => runtime.diagnoseRuntime(context),
-  list_local_resources: (runtime) => runtime.managedJobManager.listResources(),
-  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),
-  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),
-});
-
 export function runtimeToolHandlerNames() {
-  return Object.keys(RUNTIME_TOOL_HANDLERS);
+  return registeredRuntimeToolHandlerNames();
 }
 
 export class LocalRuntime {
@@ -113,8 +61,10 @@ export class LocalRuntime {
     this.processTracker = new ProcessTracker();
     this.lifecycle = new LifecycleController("local runtime");
     this.observability = new RuntimeObservability();
+    this.relayInstanceId = `daemon_${randomBytes(18).toString("base64url")}`;
     this.activeRelayCalls = new Set();
     this.suppressedRelayResults = new Map();
+    this.relayResumeSessionId = 0;
     this.callRegistry = new CallRegistry({
       maximum: MAX_CONCURRENT_TOOL_CALLS,
       onCancel: (record) => {
@@ -215,10 +165,7 @@ export class LocalRuntime {
       logger: this.logger,
     });
     this.toolExecutor = new ToolExecutor({
-      handlers: Object.fromEntries(Object.entries(RUNTIME_TOOL_HANDLERS).map(([name, handler]) => [
-        name,
-        (args, context) => handler(this, args, context),
-      ])),
+      handlers: bindRuntimeToolHandlers(this),
       policyGate: this.policyGate,
       accountAccessGate: this.accountAccessGate,
       callRegistry: this.callRegistry,
@@ -227,11 +174,17 @@ export class LocalRuntime {
       safeMessage: (error, args) => this.safeErrorMessage(error, args),
       slowMs: SLOW_TOOL_CALL_MS,
     });
-    this.relay = createRelayConnection(this, {
-      workerUrl: remoteWorkerUrl,
-      secret: remoteSecret,
-      expectedVersion: expectedRelayVersion,
-      onFatal,
+    this.relay = createRuntimeRelayConnection(this, {
+      workerUrl: remoteWorkerUrl, secret: remoteSecret, expectedVersion: expectedRelayVersion, onFatal,
+    });
+    this.relayCallRecovery = new RelayCallRecovery({
+      logger: this.logger,
+      send: (value) => this.send(value),
+      isRecoverable: () => Boolean(this.relay && !this.relay.status?.().closed),
+      activeCallIds: () => this.activeRelayCalls,
+      suppressCall: (callId, reason) => this.suppressedRelayResults.set(callId, reason),
+      cancelOrigin: (reason) => this.callRegistry.cancelOrigin("relay", reason),
+      terminate: () => this.terminateActiveProcesses("SIGTERM", true),
     });
   }
 
@@ -276,6 +229,7 @@ export class LocalRuntime {
     if (!this.lifecycle.beginStop()) return;
     try {
       this.relay?.stop();
+      this.relayCallRecovery.stop();
       this.callRegistry.cancelAll("runtime stopped");
       this.terminateActiveProcesses("SIGKILL");
       this.processSessionManager.clear();
@@ -300,7 +254,7 @@ export class LocalRuntime {
       this.handleRelayProtocolViolation("invalid_server_message");
       return;
     }
-    if (this.handleRelayControlMessage(message)) return;
+    if (this.handleRelayControlMessage(message, relayContext)) return;
     if (message.type === "relay_probe") {
       if (isRelayReadyContext(relayContext, this.relay)) return this.handleRelayProtocolViolation("unexpected_relay_probe");
       this.handleRelayProbe(message, relayContext);
@@ -308,20 +262,38 @@ export class LocalRuntime {
     }
     if (message.type !== "tool_call") return this.handleRelayProtocolViolation("unexpected_server_message_type");
     if (!isRelayReadyContext(relayContext, this.relay)) return this.handleRelayProtocolViolation("tool_call_before_ready");
-    await this.handleRelayToolCall(message, relayContext);
+    await this.handleRelayToolCall(message);
   }
 
-  handleRelayControlMessage(message) {
+  handleRelayControlMessage(message, relayContext = {}) {
     if (message.type === "welcome") {
       this.relay?.observeWelcome(message);
       return true;
     }
     if (message.type === "hello_ack") {
+      this.relayResumeSessionId = 0;
       this.relay?.acknowledge(message);
       return true;
     }
+    if (message.type === "resume_calls") {
+      const sessionId = Number(relayContext.sessionId) || 0;
+      const resume = normalizeRelayResumeCalls(message);
+      if (!resume.ok || !sessionId || relayContext.authenticated !== true || relayContext.ready === true) {
+        this.handleRelayProtocolViolation("invalid_resume_calls");
+        return true;
+      }
+      this.reconcileRelayCalls(resume.ids);
+      this.relayResumeSessionId = sessionId;
+      return true;
+    }
     if (message.type === "ready_ack") {
+      const sessionId = Number(relayContext.sessionId) || 0;
+      if (!sessionId || sessionId !== this.relayResumeSessionId) {
+        this.handleRelayProtocolViolation("resume_calls_required");
+        return true;
+      }
       this.relay?.confirmReady(message);
+      this.relayResumeSessionId = 0;
       return true;
     }
     if (message.type === "pong") return true;
@@ -348,12 +320,12 @@ export class LocalRuntime {
     const id = typeof message?.id === "string" && /^probe_[A-Za-z0-9_-]{8,240}$/.test(message.id) ? message.id : "";
     const relaySessionId = Number(relayContext.sessionId) || 0;
     if (!id || !relaySessionId) return this.handleRelayProtocolViolation("invalid_relay_probe");
-    this.deliverRelayToolResult({ type: "relay_probe_result", id }, relaySessionId);
+    const outcome = this.relay?.sendForSession?.({ type: "relay_probe_result", id }, relaySessionId);
+    if (!outcome?.ok) this.handleRelayProtocolViolation("relay_probe_delivery_failed");
   }
 
-  async handleRelayToolCall(message, relayContext = {}) {
+  async handleRelayToolCall(message) {
     const envelope = normalizeRelayToolCall(message);
-    const relaySessionId = Number(relayContext.sessionId) || 0;
     if (!envelope.ok) {
       this.logger.warn?.("Received an invalid tool request from the relay; the request was rejected.");
       this.logger.event?.("debug", "relay.tool_call.invalid", {
@@ -364,7 +336,7 @@ export class LocalRuntime {
         id: envelope.id,
         ok: false,
         error: { code: "invalid_request", message: "invalid tool_call envelope", retryable: false },
-      }, relaySessionId);
+      });
       return;
     }
     if (this.activeRelayCalls.has(envelope.id)) {
@@ -392,31 +364,15 @@ export class LocalRuntime {
         }, "Discarded a tool result because the caller was no longer waiting");
         return;
       }
-      this.deliverRelayToolResult(response, relaySessionId);
+      this.deliverRelayToolResult(response);
     } finally {
       this.activeRelayCalls.delete(envelope.id);
       this.suppressedRelayResults.delete(envelope.id);
     }
   }
 
-  deliverRelayToolResult(response, relaySessionId = 0) {
-    const sessionId = Number(relaySessionId) || 0;
-    const outcome = this.relay?.sendForSession
-      ? this.relay.sendForSession(response, sessionId)
-      : (this.send(response) ? { ok: true, reason: "sent" } : { ok: false, reason: "transport_unavailable" });
-    if (outcome?.ok) return true;
-    const reason = String(outcome?.reason || "transport_unavailable");
-    const missingSession = reason === "session_ended" && sessionId <= 0;
-    this.logger.event?.(missingSession ? "error" : "debug", "relay.tool_result.discarded", {
-      call_id: shortCallId(response?.id), reason, relay_session_id: sessionId,
-      active_session_id: Number(this.relay?.currentSessionId?.() || 0),
-    }, missingSession
-      ? "Discarded a tool result because the relay session id was missing from the inbound tool_call context"
-      : reason === "send_failed"
-        ? "Could not send a tool result because the relay transport failed"
-        : "Discarded a tool result because its relay session had ended");
-    if (reason === "send_failed") this.relay?.interrupt?.("relay_transport_error");
-    return false;
+  deliverRelayToolResult(response) {
+    return this.relayCallRecovery.deliver(response);
   }
 
   finishCall(callId) {
@@ -430,18 +386,25 @@ export class LocalRuntime {
 
   cancelRelayCall(callId, suppressionReason = "caller_cancelled") {
     const id = String(callId);
+    const discardedResult = this.relayCallRecovery.discard(id);
     if (this.activeRelayCalls.has(id)) this.suppressedRelayResults.set(id, suppressionReason);
-    return this.cancelCall(id, "remote cancellation");
+    return this.cancelCall(id, "remote cancellation") || discardedResult;
+  }
+
+  reconcileRelayCalls(resumedCallIds) {
+    this.relayCallRecovery.reconcile(
+      resumedCallIds,
+      (callId) => this.cancelRelayCall(callId, "caller_no_longer_waiting"),
+    );
   }
 
   handleRelayDisconnect() {
-    for (const callId of this.activeRelayCalls) this.suppressedRelayResults.set(callId, "relay_disconnected");
-    const cancelled = this.callRegistry.cancelOrigin("relay", "remote relay disconnected");
-    this.terminateActiveProcesses("SIGTERM", true);
-    if (cancelled > 0) {
-      this.logger.event?.("debug", "relay.calls.cancelled_on_disconnect", { cancelled_calls: cancelled },
-        "Cancelled in-flight tool calls after the relay connection ended");
-    }
+    this.relayResumeSessionId = 0;
+    this.relayCallRecovery.disconnected();
+  }
+
+  handleRelayReady() {
+    this.relayCallRecovery.ready();
   }
 
   async executeTool(tool, args, context = {}) {
@@ -662,19 +625,17 @@ export class LocalRuntime {
   }
 
   safeErrorMessage(error, toolArgs = {}) {
-    let message = boundedErrorMessage(error);
-    if (!this.policy.exposeAbsolutePaths) {
-      for (const prefix of equivalentPathPrefixes(this.workspace, this.workspaceInput)) message = replacePathPrefix(message, prefix, ".");
-      for (const prefix of equivalentPathPrefixes(this.runtimeDir)) message = replacePathPrefix(message, prefix, "<runtime>");
-      const home = process.env.HOME || process.env.USERPROFILE;
-      if (home) message = replacePathPrefix(message, resolve(home), "<home>");
-      for (const candidate of collectToolPathCandidates(error, toolArgs, this.workspaceInput)) {
-        const absolute = isAbsolute(candidate) ? resolve(candidate) : resolve(this.workspaceInput, candidate);
-        const replacement = this.displayPath(absolute);
-        for (const prefix of equivalentPathPrefixes(candidate, absolute)) message = replacePathPrefix(message, prefix, replacement);
-      }
-    }
-    return message;
+    const message = boundedErrorMessage(error);
+    if (this.policy.exposeAbsolutePaths) return message;
+    return redactRuntimeErrorMessage(message, {
+      error,
+      toolArgs,
+      workspace: this.workspace,
+      workspaceInput: this.workspaceInput,
+      runtimeDir: this.runtimeDir,
+      home: process.env.HOME || process.env.USERPROFILE || "",
+      displayPath: (value) => this.displayPath(value),
+    });
   }
 
   throwIfCancelled(context = {}) {
@@ -690,129 +651,6 @@ export class LocalRuntime {
   }
 }
 
-function stateRootFromProfileStatePath(statePath) {
-  const absolute = resolve(statePath);
-  if (basename(absolute) !== "state.json") throw new Error("local resource state path is invalid");
-  const profileDir = dirname(absolute);
-  const profilesDir = dirname(profileDir);
-  if (basename(profilesDir) !== "profiles") throw new Error("local resource state path is outside the expected profile layout");
-  return dirname(profilesDir);
-}
-
-function assertContainedPath(root, target) {
-  const rel = relative(root, target);
-  if (rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel))) return;
-  throw new Error("path is outside the configured workspace; restart with --unrestricted-paths to allow it");
-}
-
-function createRuntimeDir() {
-  const root = mkdtempSync(join(tmpdir(), "machine-bridge-mcp-"));
-  for (const name of ["home", "tmp", "cache"]) mkdirSync(join(root, name), { recursive: true, mode: 0o700 });
-  return root;
-}
-
-function createRelayConnection(runtime, { workerUrl, secret, expectedVersion, onFatal }) {
-  if (!workerUrl) return null;
-  return new RelayConnection({
-    workerUrl,
-    secret,
-    logger: runtime.logger,
-    maxPayload: MAX_WS_MESSAGE_BYTES,
-    expectedServer: SERVER_NAME,
-    expectedVersion: String(expectedVersion || ""),
-    helloMessage: () => ({
-      type: "hello",
-      tools: runtime.tools(),
-      policy: runtime.policy,
-      protocol_versions: MCP_SUPPORTED_PROTOCOL_VERSIONS,
-    }),
-    onMessage: (data, relayContext) => handleRelayData(runtime, data, relayContext),
-    onDisconnect: () => runtime.handleRelayDisconnect(),
-    onSuperseded: () => {
-      runtime.terminateActiveProcesses("SIGKILL");
-      runtime.processSessionManager.clear();
-      runtime.onSuperseded?.();
-    },
-    onFatal: (error) => {
-      runtime.terminateActiveProcesses("SIGKILL");
-      runtime.processSessionManager.clear();
-      onFatal?.(error);
-    },
-  });
-}
-
-
-function handleRelayData(runtime, data, relayContext = {}) {
-  const raw = typeof data === "string" ? data : Buffer.from(data).toString("utf8");
-  if (Buffer.byteLength(raw) > MAX_WS_MESSAGE_BYTES) {
-    runtime.handleRelayProtocolViolation("server_message_too_large");
-    return;
-  }
-  return runtime.handleMessage(raw, relayContext);
-}
-
-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 argumentsValue = message.arguments === undefined ? {} : message.arguments;
-  const authorization = normalizeRelayAuthorization(message.authorization);
-  if (!id || !tool || !isPlainRecord(argumentsValue) || !authorization) return { ok: false, id };
-  return {
-    ok: true,
-    id,
-    tool,
-    arguments: argumentsValue,
-    authorization,
-    timeoutMs: clampInteger(message.timeout_ms, 60_000, 1000, 610_000),
-  };
-}
-
-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);
-  let role;
-  try { role = normalizeAccountRole(value.role); } catch { return null; }
-  if (!accountId || !Number.isInteger(accountVersion) || accountVersion < 1) return null;
-  return Object.freeze({ account_id: accountId, account_version: accountVersion, role });
-}
-
-function collectToolPathCandidates(error, toolArgs, workspace) {
-  const candidates = new Set();
-  for (const value of [error?.path, error?.dest]) if (typeof value === "string" && value) candidates.add(value);
-  const visit = (value, key = "", depth = 0) => {
-    if (depth > 5 || value === null || value === undefined) return;
-    if (typeof value === "string") {
-      if (/(?:^|[_-])(?:path|cwd|workspace|root|directory|dir)(?:$|[_-])/i.test(key) && value && !value.includes("\0")) candidates.add(value);
-      return;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value.slice(0, 64)) visit(item, key, depth + 1);
-      return;
-    }
-    if (typeof value !== "object") return;
-    for (const [childKey, child] of Object.entries(value).slice(0, 128)) visit(child, childKey, depth + 1);
-  };
-  visit(toolArgs);
-  candidates.delete(workspace);
-  return [...candidates].sort((left, right) => right.length - left.length);
-}
-
-function equivalentPathPrefixes(...values) {
-  const prefixes = new Set(values.filter(Boolean).map((value) => String(value)));
-  for (const value of [...prefixes]) {
-    if (value.startsWith("/private/")) prefixes.add(value.slice("/private".length));
-    else if (value.startsWith("/") && ["/var/", "/tmp/", "/etc/"].some((prefix) => value.startsWith(prefix))) prefixes.add(`/private${value}`);
-  }
-  return [...prefixes].sort((left, right) => right.length - left.length);
-}
-
-function replacePathPrefix(message, pathValue, replacement) {
-  if (!pathValue) return message;
-  const normalized = String(pathValue);
-  return message.split(normalized).join(replacement);
-}
-
 function shortCallId(value) {
   return String(value || "").slice(0, 20);
 }

package/src/local/windows-launcher.mjs

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { replaceFileAtomicallySync } from "./exclusive-file.mjs";
+
+const WINDOWS_LAUNCHER = "service-launcher.cmd";
+const WINDOWS_TASK_COMMAND_MAX_CHARS = 262;
+
+export function windowsLauncherPath(stateRoot) {
+  return path.join(path.resolve(String(stateRoot)), WINDOWS_LAUNCHER);
+}
+
+export function writeWindowsLauncher(spec) {
+  const launcherPath = windowsLauncherPath(spec.stateRoot);
+  const content = windowsLauncherContent(spec);
+  replaceFileAtomicallySync(launcherPath, content, { mode: 0o600 });
+  return { path: launcherPath, content };
+}
+
+export function windowsLauncherContent(spec) {
+  const command = [spec.node, ...(spec.daemonArgs || [])].map(windowsBatchArgument).join(" ");
+  const stdout = windowsBatchArgument(spec.stdout);
+  const stderr = windowsBatchArgument(spec.stderr);
+  return [
+    "@echo off",
+    "setlocal DisableDelayedExpansion",
+    ":restart",
+    `${command} 1>>${stdout} 2>>${stderr}`,
+    'set "mbm_exit=%ERRORLEVEL%"',
+    'if "%mbm_exit%"=="0" exit /b 0',
+    '"%SystemRoot%\\System32\\timeout.exe" /t 5 /nobreak >nul 2>&1',
+    "goto restart",
+    "",
+  ].join("\r\n");
+}
+
+export function windowsTaskAction(launcherPath) {
+  const action = String(launcherPath);
+  if (action.includes("\0") || /[\r\n]/.test(action)) throw new Error("Windows autostart launcher path contains a prohibited control character");
+  if (!path.isAbsolute(action) && !path.win32.isAbsolute(action)) throw new Error("Windows autostart launcher path must be absolute");
+  if (action.includes("%")) throw new Error("Windows autostart launcher path must not contain a percent sign because Task Scheduler may expand it as an environment variable");
+  if (action.length > WINDOWS_TASK_COMMAND_MAX_CHARS) {
+    throw new Error(`Windows autostart action exceeds the ${WINDOWS_TASK_COMMAND_MAX_CHARS}-character Task Scheduler limit; use the default state directory or a shorter --state-dir`);
+  }
+  return action;
+}
+
+export function windowsCommandLineArgument(value) {
+  const text = String(value);
+  if (text.includes("\0")) throw new Error("Windows command-line argument contains a NUL byte");
+  if (/[\r\n]/.test(text)) throw new Error("Windows command-line argument contains a line break");
+  const escapedQuotes = text.replace(/(\\*)"/g, (_match, slashes) => `${slashes}${slashes}\\"`);
+  const escapedTrailingSlashes = escapedQuotes.replace(/(\\+)$/, slashes => `${slashes}${slashes}`);
+  return `"${escapedTrailingSlashes}"`;
+}
+
+export function windowsBatchArgument(value) {
+  return windowsCommandLineArgument(value).replaceAll("%", "%%");
+}

package/src/local/windows-service.mjs

@@ -1,10 +1,13 @@
-import path from "node:path";
-import { replaceFileAtomicallySync } from "./exclusive-file.mjs";
 import { waitForInactiveStatus } from "./service-convergence.mjs";
+import {
+  windowsLauncherPath, windowsTaskAction, writeWindowsLauncher,
+} from "./windows-launcher.mjs";
+export {
+  windowsBatchArgument, windowsCommandLineArgument, windowsLauncherContent,
+  windowsLauncherPath, windowsTaskAction, writeWindowsLauncher,
+} from "./windows-launcher.mjs";
 
 export const WINDOWS_TASK = "MachineBridgeMCP";
-const WINDOWS_LAUNCHER = "service-launcher.cmd";
-const WINDOWS_TASK_COMMAND_MAX_CHARS = 262;
 const WINDOWS_STATUS_SCRIPT = [
   "$task = Get-ScheduledTask -TaskName 'MachineBridgeMCP' -ErrorAction SilentlyContinue;",
   "if ($null -eq $task) { exit 3 };",
@@ -150,58 +153,6 @@ export async function statusWindowsTask(options = {}) {
   };
 }
 
-export function windowsLauncherPath(stateRoot) {
-  return path.join(path.resolve(String(stateRoot)), WINDOWS_LAUNCHER);
-}
-
-export function writeWindowsLauncher(spec) {
-  const launcherPath = windowsLauncherPath(spec.stateRoot);
-  const content = windowsLauncherContent(spec);
-  replaceFileAtomicallySync(launcherPath, content, { mode: 0o600 });
-  return { path: launcherPath, content };
-}
-
-export function windowsLauncherContent(spec) {
-  const command = [spec.node, ...(spec.daemonArgs || [])].map(windowsBatchArgument).join(" ");
-  const stdout = windowsBatchArgument(spec.stdout);
-  const stderr = windowsBatchArgument(spec.stderr);
-  return [
-    "@echo off",
-    "setlocal DisableDelayedExpansion",
-    ":restart",
-    `${command} 1>>${stdout} 2>>${stderr}`,
-    'set "mbm_exit=%ERRORLEVEL%"',
-    'if "%mbm_exit%"=="0" exit /b 0',
-    '"%SystemRoot%\\System32\\timeout.exe" /t 5 /nobreak >nul 2>&1',
-    "goto restart",
-    "",
-  ].join("\r\n");
-}
-
-export function windowsTaskAction(launcherPath) {
-  const action = String(launcherPath);
-  if (action.includes("\0") || /[\r\n]/.test(action)) throw new Error("Windows autostart launcher path contains a prohibited control character");
-  if (!path.isAbsolute(action) && !path.win32.isAbsolute(action)) throw new Error("Windows autostart launcher path must be absolute");
-  if (action.includes("%")) throw new Error("Windows autostart launcher path must not contain a percent sign because Task Scheduler may expand it as an environment variable");
-  if (action.length > WINDOWS_TASK_COMMAND_MAX_CHARS) {
-    throw new Error(`Windows autostart action exceeds the ${WINDOWS_TASK_COMMAND_MAX_CHARS}-character Task Scheduler limit; use the default state directory or a shorter --state-dir`);
-  }
-  return action;
-}
-
-export function windowsCommandLineArgument(value) {
-  const text = String(value);
-  if (text.includes("\0")) throw new Error("Windows command-line argument contains a NUL byte");
-  if (/[\r\n]/.test(text)) throw new Error("Windows command-line argument contains a line break");
-  const escapedQuotes = text.replace(/(\\*)"/g, (_match, slashes) => `${slashes}${slashes}\\"`);
-  const escapedTrailingSlashes = escapedQuotes.replace(/(\\+)$/, slashes => `${slashes}${slashes}`);
-  return `"${escapedTrailingSlashes}"`;
-}
-
-export function windowsBatchArgument(value) {
-  return windowsCommandLineArgument(value).replaceAll("%", "%%");
-}
-
 function completedSince(before, after) {
   return after?.installed === true
     && after.active === false

package/src/worker/daemon-sockets.ts

@@ -7,6 +7,7 @@ export interface DaemonAttachment {
   connectedAt: string;
   lastSeenAt?: string;
   probeId?: string;
+  instanceId?: string;
   policy?: DaemonPolicy;
   tools?: string[];
 }
@@ -29,6 +30,7 @@ export class DaemonSocketRegistry {
       connectedAt: sanitizeMetadataText(candidate.connectedAt, 64) ?? "",
       lastSeenAt: sanitizeMetadataText(candidate.lastSeenAt, 64),
       probeId: sanitizeProbeId(candidate.probeId),
+      instanceId: sanitizeDaemonInstanceId(candidate.instanceId),
       policy,
       tools: sanitizeDaemonTools(candidate.tools, policy),
     };
@@ -54,12 +56,13 @@ export class DaemonSocketRegistry {
     socket.serializeAttachment({ role: "candidate", connectedAt } satisfies DaemonAttachment);
   }
 
-  beginProbe(socket: WebSocket, values: { connectedAt: string; probeId: string; policy: DaemonPolicy; tools: string[] }): void {
+  beginProbe(socket: WebSocket, values: { connectedAt: string; probeId: string; instanceId: string; policy: DaemonPolicy; tools: string[] }): void {
     socket.serializeAttachment({
       role: "probing",
       connectedAt: values.connectedAt,
       lastSeenAt: values.connectedAt,
       probeId: values.probeId,
+      instanceId: values.instanceId,
       policy: values.policy,
       tools: values.tools,
     } satisfies DaemonAttachment);
@@ -89,6 +92,7 @@ export class DaemonSocketRegistry {
       role: "expired",
       connectedAt: attachment.connectedAt,
       lastSeenAt: attachment.lastSeenAt,
+      instanceId: attachment.instanceId,
     } satisfies DaemonAttachment);
   }
 
@@ -105,3 +109,8 @@ function sanitizeProbeId(value: unknown): string | undefined {
   if (typeof value !== "string" || !/^probe_[A-Za-z0-9_-]{8,240}$/.test(value)) return undefined;
   return value;
 }
+
+function sanitizeDaemonInstanceId(value: unknown): string | undefined {
+  if (typeof value !== "string" || !/^daemon_[A-Za-z0-9_-]{16,96}$/.test(value)) return undefined;
+  return value;
+}