machine-bridge-mcp 0.11.0 → 0.12.0

package/src/local/daemon-process.mjs

@@ -0,0 +1,199 @@
+import path from "node:path";
+import process from "node:process";
+import {
+  acquireDaemonLock,
+  daemonLockPathForState,
+  readDaemonLockOwner,
+  resolveWorkspace,
+} from "./state.mjs";
+import { inspectProcessInstance, isPidAlive, processCommandLine, splitProcessCommandLine } from "./process-identity.mjs";
+
+const DEFAULT_TAKEOVER_TIMEOUT_MS = 15_000;
+const DEFAULT_TAKEOVER_POLL_MS = 100;
+
+export async function acquireDaemonLockWithTakeover(state, options = {}) {
+  const ownerMetadata = options.ownerMetadata || {};
+  let lock = acquireDaemonLock(state, ownerMetadata);
+  if (lock.acquired || !options.takeOverServiceOwner) return lock;
+
+  const stopped = await stopWorkspaceServiceDaemon(state, {
+    owner: lock.owner,
+    timeoutMs: options.timeoutMs,
+    pollMs: options.pollMs,
+    logger: options.logger,
+    reason: "foreground startup",
+  });
+  if (!stopped.verified_service_daemon) return lock;
+  if (!stopped.ok) {
+    const pid = stopped.pid ? `pid ${stopped.pid}` : "unknown pid";
+    throw new Error(`background daemon did not release the workspace within ${Math.ceil(stopped.timeout_ms / 1000)} seconds (${pid}); run \`machine-mcp service stop\`, verify \`machine-mcp service status\`, and retry`);
+  }
+
+  lock = acquireDaemonLock(state, ownerMetadata);
+  if (lock.acquired) options.logger?.info?.("background daemon stopped; foreground startup is taking over the workspace");
+  return lock;
+}
+
+export async function stopWorkspaceServiceDaemon(state, options = {}) {
+  const timeoutMs = boundedPositiveInt(options.timeoutMs, DEFAULT_TAKEOVER_TIMEOUT_MS);
+  const pollMs = boundedPositiveInt(options.pollMs, DEFAULT_TAKEOVER_POLL_MS);
+  const logger = options.logger || { info() {}, warn() {} };
+  const deadline = Date.now() + timeoutMs;
+  const signalled = new Set();
+  let owner = options.owner || readDaemonLockOwner(daemonLockPathForState(state));
+  let verified = false;
+  let lastOwner = owner;
+
+  while (true) {
+    if (owner?.pid && isPidAlive(owner.pid)) {
+      lastOwner = owner;
+      const identity = inspectWorkspaceDaemonOwner(state, owner);
+      if (!identity.verified_service_daemon) {
+        return {
+          ok: false,
+          found: true,
+          verified_service_daemon: false,
+          reason: identity.reason,
+          timeout_ms: timeoutMs,
+          ...publicDaemonOwner(owner),
+        };
+      }
+      verified = true;
+      if (!signalled.has(Number(owner.pid))) {
+        const purpose = options.reason || "service stop";
+        logger.info?.(`stopping detached background daemon (pid ${owner.pid}) for ${purpose}`);
+        try {
+          process.kill(Number(owner.pid), "SIGTERM");
+        } catch (error) {
+          if (error?.code !== "ESRCH") {
+            return {
+              ok: false,
+              found: true,
+              verified_service_daemon: true,
+              reason: "signal_failed",
+              timeout_ms: timeoutMs,
+              ...publicDaemonOwner(owner),
+            };
+          }
+        }
+        signalled.add(Number(owner.pid));
+      }
+    }
+
+    const liveSignalled = [...signalled].filter((pid) => isPidAlive(pid));
+    const currentOwnerAlive = Boolean(owner?.pid && isPidAlive(owner.pid));
+    if (!currentOwnerAlive && liveSignalled.length === 0) break;
+
+    if (Date.now() >= deadline) {
+      logger.warn?.(`detached background daemon did not stop within ${Math.ceil(timeoutMs / 1000)} seconds`);
+      const remainingPid = Number(owner?.pid) || liveSignalled[0] || null;
+      return {
+        ok: false,
+        found: true,
+        stopped: false,
+        verified_service_daemon: verified,
+        reason: "timeout",
+        timeout_ms: timeoutMs,
+        pid: remainingPid,
+        mode: publicDaemonMode(lastOwner),
+        version: typeof lastOwner?.version === "string" ? lastOwner.version : "unknown",
+      };
+    }
+    await sleep(Math.min(pollMs, Math.max(1, deadline - Date.now())));
+    owner = readDaemonLockOwner(daemonLockPathForState(state));
+  }
+
+  // Reclaim a stale lock only through the normal token-aware primitive.
+  const staleCleanup = acquireDaemonLock(state, { mode: "service" });
+  if (staleCleanup.acquired) staleCleanup.release();
+  return {
+    ok: true,
+    found: verified,
+    stopped: verified,
+    verified_service_daemon: verified,
+    reason: verified ? "stopped" : "not_running",
+    timeout_ms: timeoutMs,
+    ...(lastOwner ? publicDaemonOwner(lastOwner) : {}),
+  };
+}
+
+export function inspectWorkspaceDaemon(state) {
+  const owner = readDaemonLockOwner(daemonLockPathForState(state));
+  if (!owner) return { present: false, alive: false, verified_service_daemon: false };
+  const alive = Boolean(owner.pid && isPidAlive(owner.pid));
+  const identity = alive
+    ? inspectWorkspaceDaemonOwner(state, owner)
+    : { verified_service_daemon: false, reason: "stale_lock" };
+  return {
+    present: true,
+    alive,
+    verified_service_daemon: identity.verified_service_daemon,
+    identity_reason: identity.reason,
+    ...publicDaemonOwner(owner),
+  };
+}
+
+function inspectWorkspaceDaemonOwner(state, owner) {
+  if (!owner || owner.purpose !== "daemon") return { verified_service_daemon: false, reason: "invalid_lock_owner" };
+  const pid = Number(owner.pid);
+  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return { verified_service_daemon: false, reason: "invalid_pid" };
+  const processIdentity = inspectProcessInstance(owner);
+  if (!processIdentity.current) return { verified_service_daemon: false, reason: processIdentity.reason };
+  if (!sameCanonicalPath(owner.workspace, state.workspace.path)) return { verified_service_daemon: false, reason: "workspace_mismatch" };
+  if (owner.mode === "foreground") return { verified_service_daemon: false, reason: "foreground_daemon" };
+
+  const command = processCommandLine(pid);
+  if (!command) {
+    return { verified_service_daemon: false, reason: owner.mode === "service" ? "service_identity_unavailable" : "legacy_identity_unavailable" };
+  }
+  const argv = splitProcessCommandLine(command);
+  const entryName = path.basename(String(owner.entryScript || "machine-mcp"));
+  const workspaceArg = commandFlagValue(argv, "--workspace");
+  const stateRootArg = commandFlagValue(argv, "--state-dir");
+  const entryMatches = argv.some((value) => {
+    const name = path.basename(value);
+    return name === entryName || name === "machine-mcp" || name === "machine-mcp.mjs";
+  });
+  const matches = argv.includes("--daemon-only")
+    && sameCanonicalPath(workspaceArg, state.workspace.path)
+    && sameCanonicalPath(stateRootArg, state.paths.stateRoot)
+    && entryMatches;
+  return { verified_service_daemon: matches, reason: matches ? "service_command" : "command_mismatch" };
+}
+
+function commandFlagValue(argv, name) {
+  const index = argv.indexOf(name);
+  return index >= 0 && index + 1 < argv.length ? argv[index + 1] : "";
+}
+
+function sameCanonicalPath(left, right) {
+  if (typeof left !== "string" || typeof right !== "string") return false;
+  try {
+    const a = resolveWorkspace(left);
+    const b = resolveWorkspace(right);
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  } catch {
+    return false;
+  }
+}
+
+function publicDaemonOwner(owner) {
+  return {
+    pid: Number(owner?.pid) || null,
+    mode: publicDaemonMode(owner),
+    version: typeof owner?.version === "string" ? owner.version : "unknown",
+  };
+}
+
+function publicDaemonMode(owner) {
+  return owner?.mode === "service" || owner?.mode === "foreground" ? owner.mode : "legacy";
+}
+
+function boundedPositiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.max(1, parsed) : fallback;
+}
+
+function sleep(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}

package/src/local/exclusive-file.mjs

@@ -0,0 +1,94 @@
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  closeSync,
+  fsyncSync,
+  linkSync,
+  lstatSync,
+  openSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { replaceFileSync } from "./atomic-fs.mjs";
+import { readBoundedRegularFileSync } from "./secure-file.mjs";
+
+export function createExclusiveFileSync(target, content, options = {}) {
+  const mode = Number.isInteger(options.mode) ? options.mode : 0o600;
+  const temporary = join(dirname(target), `.${basename(target)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+  let fd;
+  let linked = false;
+  try {
+    fd = openSync(temporary, "wx", mode);
+    writeFileSync(fd, content);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    linkSync(temporary, target);
+    linked = true;
+    try { chmodSync(target, mode); } catch {}
+    return { created: true, path: target };
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch {}
+    try { unlinkSync(temporary); } catch {}
+    if (!linked && options.cleanupTargetOnFailure === true) {
+      try { unlinkSync(target); } catch {}
+    }
+  }
+}
+
+export function replaceFileAtomicallySync(target, content, options = {}) {
+  const mode = Number.isInteger(options.mode) ? options.mode : 0o600;
+  const temporary = join(dirname(target), `.${basename(target)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+  let fd;
+  try {
+    fd = openSync(temporary, "wx", mode);
+    writeFileSync(fd, content);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    replaceFileSync(temporary, target);
+    try { chmodSync(target, mode); } catch {}
+    return { replaced: true, path: target };
+  } catch (error) {
+    if (fd !== undefined) try { closeSync(fd); } catch {}
+    try { unlinkSync(temporary); } catch {}
+    throw error;
+  }
+}
+
+export function removeOwnedJsonFileSync(target, expected = {}, options = {}) {
+  const maxBytes = Number.isInteger(options.maxBytes) ? options.maxBytes : 4096;
+  const snapshot = ownedJsonSnapshot(target, maxBytes);
+  if (!snapshot || !matchesExpected(snapshot.value, expected)) return false;
+  let current;
+  try { current = lstatSync(target); } catch (error) { return error?.code === "ENOENT"; }
+  if (current.isSymbolicLink() || !current.isFile() || !sameIdentity(snapshot.info, current)) return false;
+  const currentSnapshot = ownedJsonSnapshot(target, maxBytes);
+  if (!currentSnapshot || !sameIdentity(snapshot.info, currentSnapshot.info) || !matchesExpected(currentSnapshot.value, expected)) return false;
+  try { unlinkSync(target); return true; } catch (error) { return error?.code === "ENOENT"; }
+}
+
+function ownedJsonSnapshot(target, maxBytes) {
+  let info;
+  try { info = lstatSync(target); } catch (error) { if (error?.code === "ENOENT") return null; throw error; }
+  if (info.isSymbolicLink() || !info.isFile()) return null;
+  try {
+    const value = JSON.parse(readBoundedRegularFileSync(target, maxBytes).toString("utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    return { value, info };
+  } catch {
+    return null;
+  }
+}
+
+function matchesExpected(value, expected) {
+  return Object.entries(expected).every(([key, expectedValue]) => value?.[key] === expectedValue);
+}
+
+function sameIdentity(left, right) {
+  return Number(left.dev) === Number(right.dev)
+    && Number(left.ino) === Number(right.ino)
+    && Number(left.size) === Number(right.size)
+    && Number(left.mtimeMs) === Number(right.mtimeMs);
+}

package/src/local/job-runner.mjs

@@ -1,10 +1,11 @@
 import { spawn } from "node:child_process";
-import { createHash, randomBytes } from "node:crypto";
-import { chmodSync, closeSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
 import { executionEnv } from "./shell.mjs";
 import { terminateProcessTree } from "./process-sessions.mjs";
-import { replaceFileSync } from "./atomic-fs.mjs";
+import { createExclusiveFileSync, removeOwnedJsonFileSync, replaceFileAtomicallySync } from "./exclusive-file.mjs";
+import { currentProcessStartTimeMs } from "./process-identity.mjs";
 import { readBoundedRegularFileSync } from "./secure-file.mjs";
 
 const RESOURCE_TOKEN = /\{\{resource:([a-z][a-z0-9._-]{0,63})\}\}/g;
@@ -22,6 +23,8 @@ if (!jobDirInput) throw new Error("--job-dir is required");
 const jobDir = resolve(jobDirInput);
 if (!JOB_ID.test(basename(jobDir))) throw new Error("--job-dir must name a managed job directory");
 const recover = options.recover === true;
+const recoveryLockToken = typeof process.env.MBM_RECOVERY_LOCK_TOKEN === "string" ? process.env.MBM_RECOVERY_LOCK_TOKEN : "";
+delete process.env.MBM_RECOVERY_LOCK_TOKEN;
 const planFile = join(jobDir, "plan.json");
 const statusFile = join(jobDir, "status.json");
 const resultFile = join(jobDir, "result.json");
@@ -30,6 +33,7 @@ const runtimeDir = join(jobDir, "runtime");
 const resourcesDir = join(runtimeDir, "resources");
 const temporaryFilesDir = join(runtimeDir, "files");
 const runnerPidFile = join(jobDir, "runner.pid");
+const RUNNER_PROCESS_STARTED_AT = new Date(currentProcessStartTimeMs()).toISOString();
 
 class JobCancelledError extends Error {
   constructor() {
@@ -49,7 +53,7 @@ for (const signal of ["SIGTERM", "SIGINT"]) {
 
 const initial = readJson(statusFile, MAX_STATUS_BYTES);
 assertLaunchState(initial);
-writeFileSync(runnerPidFile, `${process.pid}\n`, { mode: 0o600, flag: "wx" });
+createExclusiveFileSync(runnerPidFile, `${JSON.stringify({ pid: process.pid, processStartedAt: RUNNER_PROCESS_STARTED_AT })}\n`, { mode: 0o600 });
 if (recover) rmSync(join(jobDir, "recovery.lock"), { force: true });
 try {
   const plan = readJson(planFile, 1024 * 1024);
@@ -59,10 +63,22 @@ try {
   recordFatalRunnerError(error);
 }
 
+async function releaseRecoveryClaim() {
+  if (!/^[a-f0-9]{32}$/.test(recoveryLockToken)) throw new Error("recovery runner is missing its ownership token");
+  const file = join(jobDir, "recovery.lock");
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (removeOwnedJsonFileSync(file, { pid: process.pid, token: recoveryLockToken })) return;
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 10));
+  }
+  throw new Error("recovery runner could not verify ownership of the recovery lock");
+}
+
 async function main(plan, initial) {
   const status = {
     ...initial,
     runner_pid: process.pid,
+    runner_process_started_at: RUNNER_PROCESS_STARTED_AT,
     started_at: initial.started_at || new Date().toISOString(),
     updated_at: new Date().toISOString(),
     status: recover ? "cleaning" : "running",
@@ -182,6 +198,7 @@ function recordFatalRunnerError(error) {
       current_phase: null,
       current_step: null,
       runner_pid: process.pid,
+      runner_process_started_at: RUNNER_PROCESS_STARTED_AT,
       updated_at: now,
       finished_at: now,
       error_class: result.error_class,
@@ -259,7 +276,6 @@ function spawnStep(argv, { cwd, env, input, timeoutMs, cancellationAware, captur
       timedOut = true;
       terminateProcessTree(child, "SIGTERM");
       killTimer = setTimeout(() => terminateProcessTree(child, "SIGKILL"), 2000);
-      killTimer.unref?.();
     }, timeoutMs);
     timer.unref?.();
     const cancellationPoll = setInterval(() => {
@@ -300,12 +316,14 @@ function spawnStep(argv, { cwd, env, input, timeoutMs, cancellationAware, captur
       if (closed) return;
       closed = true;
       clearTimeout(timer);
-      if (killTimer) clearTimeout(killTimer);
+      if (killTimer && !timedOut) clearTimeout(killTimer);
       clearInterval(cancellationPoll);
       activeChild = null;
       activeChildCancellationAware = false;
-      if (cancellationEscalation) clearTimeout(cancellationEscalation);
-      cancellationEscalation = null;
+      if (cancellationEscalation && !isCancellationRequested()) {
+        clearTimeout(cancellationEscalation);
+        cancellationEscalation = null;
+      }
       callback();
     }
   });
@@ -440,7 +458,7 @@ function redactOutput(buffer, context) {
 }
 
 function updateStatus(status, changes) {
-  Object.assign(status, changes, { runner_pid: process.pid, updated_at: new Date().toISOString() });
+  Object.assign(status, changes, { runner_pid: process.pid, runner_process_started_at: RUNNER_PROCESS_STARTED_AT, updated_at: new Date().toISOString() });
   writeJson(statusFile, status, MAX_STATUS_BYTES);
 }
 
@@ -451,9 +469,9 @@ function requestCancellation() {
   terminateProcessTree(child, "SIGTERM");
   if (cancellationEscalation) return;
   cancellationEscalation = setTimeout(() => {
-    if (activeChild === child && activeChildCancellationAware) terminateProcessTree(child, "SIGKILL");
+    terminateProcessTree(child, "SIGKILL");
+    cancellationEscalation = null;
   }, 2000);
-  cancellationEscalation.unref?.();
 }
 
 function isCancellationRequested() {
@@ -474,12 +492,10 @@ function appendLimited(current, chunk, limit, budget) {
 }
 
 function writeJson(file, value, maxBytes) {
-  const text = `${JSON.stringify(value, null, 2)}\n`;
+  const text = `${JSON.stringify(value, null, 2)}
+`;
   if (Buffer.byteLength(text) > maxBytes) throw new Error(`job JSON exceeds ${maxBytes} bytes`);
-  const temp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-  writeFileSync(temp, text, { mode: 0o600, flag: "wx" });
-  replaceFileSync(temp, file);
-  chmodSync(file, 0o600);
+  replaceFileAtomicallySync(file, text, { mode: 0o600 });
 }
 
 function readJson(file, maxBytes) {

package/src/local/log.mjs

@@ -22,8 +22,15 @@ const BEARER_VALUE = /\bBearer\s+[A-Za-z0-9._~+\/-]+=*\b/gi;
 const EMAIL_VALUE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
 const AWS_ACCESS_KEY = /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g;
 const GITHUB_TOKEN = /\bgh[pousr]_[A-Za-z0-9_]{30,}\b/g;
+const GITLAB_TOKEN = /\bglpat-[A-Za-z0-9_-]{20,}\b/g;
+const NPM_TOKEN = /\bnpm_[A-Za-z0-9]{30,}\b/g;
+const SLACK_TOKEN = /\bxox[aboprs]-[A-Za-z0-9-]{10,}\b/g;
+const GOOGLE_API_KEY = /\bAIza[A-Za-z0-9_-]{30,}\b/g;
+const PAYMENT_API_KEY = /\b(?:sk|rk|pk)_live_[A-Za-z0-9]{16,}\b/g;
+const JWT_VALUE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
+const URL_CREDENTIALS = /https?:\/\/[^\s/@:"'<>]+:[^\s/@"'<>]+@[^\s/"'<>]+/gi;
 const API_SECRET = /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g;
-const PRIVATE_KEY_HEADER = /-----BEGIN\s+(?:OPENSSH|RSA|EC|DSA)\s+PRIVATE\s+KEY-----/g;
+const PRIVATE_KEY_HEADER = /-----BEGIN\s+(?:(?:OPENSSH|RSA|EC|DSA)\s+|ENCRYPTED\s+)?PRIVATE\s+KEY-----/g;
 const HOME_PATHS = [...new Set([process.env.HOME, process.env.USERPROFILE, safeHomeDirectory()].filter(value => typeof value === "string" && value.length > 1))]
   .sort((left, right) => right.length - left.length);
 
@@ -54,6 +61,7 @@ export function createLogger(options = {}) {
     error(message, fields) { write(process.stderr, "error", "[error]", COLORS.red, message, fields); },
     debug(message, fields) { write(process.stderr, "debug", "[debug]", COLORS.gray, message, fields); },
     plain(message = "") { if (!quiet) process.stdout.write(`${String(message)}\n`); },
+    safePlain(message = "") { if (!quiet) process.stdout.write(`${sanitizeLogText(message, MAX_LOG_MESSAGE_CHARS)}\n`); },
     json(value) { process.stdout.write(`${JSON.stringify(value, null, 2)}\n`); },
   };
 }
@@ -123,6 +131,13 @@ export function sanitizeLogText(value, maxChars = MAX_LOG_MESSAGE_CHARS) {
     .replace(BEARER_VALUE, "Bearer <redacted>")
     .replace(AWS_ACCESS_KEY, "<redacted-cloud-key>")
     .replace(GITHUB_TOKEN, "<redacted-access-token>")
+    .replace(GITLAB_TOKEN, "<redacted-access-token>")
+    .replace(NPM_TOKEN, "<redacted-access-token>")
+    .replace(SLACK_TOKEN, "<redacted-access-token>")
+    .replace(GOOGLE_API_KEY, "<redacted-cloud-key>")
+    .replace(PAYMENT_API_KEY, "<redacted-api-secret>")
+    .replace(JWT_VALUE, "<redacted-bearer-token>")
+    .replace(URL_CREDENTIALS, "<redacted-credential-url>")
     .replace(API_SECRET, "<redacted-api-secret>")
     .replace(PRIVATE_KEY_HEADER, "<redacted-private-key-header>")
     .replace(EMAIL_VALUE, "<redacted-email>");