machine-bridge-mcp 0.11.1 → 0.12.0

package/src/local/process-identity.mjs

@@ -0,0 +1,143 @@
+import { spawnSync } from "node:child_process";
+import { performance } from "node:perf_hooks";
+
+const COMMAND_TIMEOUT_MS = 3000;
+const COMMAND_OUTPUT_BYTES = 256 * 1024;
+const START_TIME_TOLERANCE_MS = 15_000;
+
+export function isPidAlive(pid) {
+  const parsed = normalizePid(pid);
+  if (!parsed) return false;
+  try {
+    process.kill(parsed, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+export function currentProcessStartTimeMs() {
+  const value = Number(performance.timeOrigin);
+  return Number.isFinite(value) && value > 0 ? value : Date.now();
+}
+
+export function processStartTimeMs(pid) {
+  const parsed = normalizePid(pid);
+  if (!parsed) return null;
+  if (parsed === process.pid) return currentProcessStartTimeMs();
+  if (process.platform === "win32") {
+    const command = `(Get-CimInstance Win32_Process -Filter "ProcessId = ${parsed}").CreationDate.ToUniversalTime().ToString('o')`;
+    const result = runBounded("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command]);
+    return result.ok ? parseTime(result.stdout) : null;
+  }
+  const result = runBounded("ps", ["-p", String(parsed), "-o", "lstart="]);
+  return result.ok ? parseTime(result.stdout) : null;
+}
+
+export function processCommandLine(pid) {
+  const parsed = normalizePid(pid);
+  if (!parsed) return "";
+  if (process.platform === "win32") {
+    const command = `(Get-CimInstance Win32_Process -Filter "ProcessId = ${parsed}").CommandLine`;
+    const result = runBounded("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command]);
+    return result.ok ? result.stdout.trim() : "";
+  }
+  const result = runBounded("ps", ["-ww", "-p", String(parsed), "-o", "command="]);
+  return result.ok ? result.stdout.trim() : "";
+}
+
+export function splitProcessCommandLine(value) {
+  const args = [];
+  let current = "";
+  let quote = "";
+  const text = String(value || "");
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (quote) {
+      if (character === quote) quote = "";
+      else if (character === "\\" && quote === '"' && ['"', "\\"].includes(text[index + 1])) {
+        current += text[index + 1];
+        index += 1;
+      } else current += character;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (/\s/.test(character)) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    if (character === "\\" && /[\s'"\\]/.test(text[index + 1] || "")) {
+      current += text[index + 1];
+      index += 1;
+      continue;
+    }
+    current += character;
+  }
+  if (current) args.push(current);
+  return args;
+}
+
+export function inspectProcessInstance(owner, options = {}) {
+  const pid = normalizePid(owner?.pid);
+  if (!pid) return { current: false, alive: false, reclaimable: true, reason: "invalid_pid", pid: null };
+  const alive = (options.isAlive || isPidAlive)(pid);
+  if (!alive) return { current: false, alive: false, reclaimable: true, reason: "not_running", pid };
+
+  const now = Number.isFinite(options.now) ? Number(options.now) : Date.now();
+  const lockStartedAt = parseTime(owner?.startedAt);
+  if (!lockStartedAt) return { current: false, alive: true, reclaimable: false, reason: "invalid_lock_timestamp", pid };
+  if (lockStartedAt > now + START_TIME_TOLERANCE_MS) return { current: false, alive: true, reclaimable: false, reason: "future_lock_timestamp", pid };
+
+  const observedStart = (options.getProcessStartTime || processStartTimeMs)(pid);
+  const recordedStart = parseTime(owner?.processStartedAt);
+  if (Number.isFinite(observedStart) && observedStart > 0) {
+    if (recordedStart && Math.abs(observedStart - recordedStart) > START_TIME_TOLERANCE_MS) {
+      return { current: false, alive: true, reclaimable: true, reason: "pid_reused", pid, process_started_at: observedStart };
+    }
+    if (!recordedStart && lockStartedAt + START_TIME_TOLERANCE_MS < observedStart) {
+      return { current: false, alive: true, reclaimable: true, reason: "pid_reused", pid, process_started_at: observedStart };
+    }
+  }
+  const maxAgeMs = Number(options.maxAgeMs);
+  if (Number.isFinite(maxAgeMs) && maxAgeMs > 0 && now - lockStartedAt > maxAgeMs) {
+    return { current: false, alive: true, reclaimable: false, reason: "lock_expired", pid, age_ms: now - lockStartedAt };
+  }
+  return {
+    current: true,
+    alive: true,
+    reclaimable: false,
+    reason: "current_process",
+    pid,
+    age_ms: Math.max(0, now - lockStartedAt),
+    process_started_at: Number.isFinite(observedStart) ? observedStart : null,
+  };
+}
+
+function runBounded(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: COMMAND_TIMEOUT_MS,
+    maxBuffer: COMMAND_OUTPUT_BYTES,
+    windowsHide: true,
+    env: process.platform === "win32" ? process.env : { ...process.env, LC_ALL: "C", LANG: "C" },
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  return { ok: !result.error && result.status === 0, stdout: String(result.stdout || "") };
+}
+
+function normalizePid(value) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function parseTime(value) {
+  if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : null;
+  const parsed = Date.parse(String(value || "").trim());
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}

package/src/local/resource-operations.mjs

@@ -3,15 +3,14 @@ import { rm } from "node:fs/promises";
 import { resolve } from "node:path";
 import { inspectResourceFile, validateResourceName } from "./managed-jobs.mjs";
 import { generateSshKeyPair } from "./ssh-key.mjs";
-import { acquireStartupLock, loadState, saveState } from "./state.mjs";
+import { acquireStartupLockWithWait, loadState, saveState } from "./state.mjs";
 
 export async function generateRegisteredSshKey({ workspace, stateDir, name: rawName, targetPath, comment = "" }) {
   const name = validateResourceName(rawName);
   if (typeof targetPath !== "string" || !targetPath.trim()) throw new Error("SSH private key target path is required");
   const target = resolve(targetPath);
   const state = loadState(workspace, { stateDir });
-  const lock = acquireStartupLock(state);
-  if (!lock.acquired) throw new Error("another state-changing operation is already running for this workspace");
+  const lock = await acquireStartupLockWithWait(state, { operation: "generate-ssh-key" });
   let key = null;
   try {
     state.resources ||= {};

package/src/local/runtime.mjs

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { constants as fsConstants, mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
 import { chmod, link, lstat, mkdir, open, opendir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path, { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -108,6 +108,7 @@ export class LocalRuntime {
       policy: this.policy,
       resources,
       resourceStatePath,
+      stateRoot: browserStateRoot,
       logger: this.logger,
       recover: recoverJobs,
     });
@@ -1101,7 +1102,8 @@ function assertContainedPath(root, target) {
 }
 
 async function readBoundedFile(filePath, maxBytes, label) {
-  const handle = await open(filePath, "r");
+  const flags = Number(fsConstants.O_RDONLY) | Number(fsConstants.O_NOFOLLOW || 0);
+  const handle = await open(filePath, flags);
   try {
     const info = await handle.stat();
     if (!info.isFile()) throw new Error(`${label} is not a regular file`);

package/src/local/service-lifecycle.mjs

@@ -0,0 +1,56 @@
+export async function stopAndRemoveAutostart({
+  states = [],
+  stateRoot,
+  logger = console,
+  reason = "service uninstall",
+  stopAutostart,
+  uninstallAutostart,
+  stopWorkspaceServiceDaemon,
+} = {}) {
+  assertFunction(stopAutostart, "stopAutostart");
+  assertFunction(uninstallAutostart, "uninstallAutostart");
+  assertFunction(stopWorkspaceServiceDaemon, "stopWorkspaceServiceDaemon");
+
+  const platformStop = await stopAutostart({ logger });
+  if (platformStop?.ok !== true) {
+    return {
+      ok: false,
+      removed: false,
+      reason: "platform_stop_failed",
+      platform_stop: platformStop,
+      workspace_daemons: [],
+      removal: null,
+    };
+  }
+
+  const workspaceDaemons = [];
+  for (const state of states) {
+    const result = await stopWorkspaceServiceDaemon(state, { logger, reason });
+    workspaceDaemons.push({ workspace: state?.workspace?.path || null, ...result });
+    if (result.found && !result.ok) {
+      return {
+        ok: false,
+        removed: false,
+        reason: "workspace_daemon_stop_failed",
+        platform_stop: platformStop,
+        workspace_daemons: workspaceDaemons,
+        removal: null,
+      };
+    }
+  }
+
+  const removal = await uninstallAutostart({ stateRoot, logger });
+  const removed = removal?.ok === true;
+  return {
+    ok: removed,
+    removed,
+    reason: removed ? "removed" : "platform_remove_failed",
+    platform_stop: platformStop,
+    workspace_daemons: workspaceDaemons,
+    removal,
+  };
+}
+
+function assertFunction(value, name) {
+  if (typeof value !== "function") throw new Error(`${name} is required`);
+}

package/src/local/service.mjs

@@ -1,9 +1,9 @@
-import { chmodSync, closeSync, constants as fsConstants, existsSync, fstatSync, ftruncateSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { chmodSync, closeSync, constants as fsConstants, existsSync, fstatSync, ftruncateSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, rmSync, statSync, writeSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { run } from "./shell.mjs";
 import { ensureOwnerOnlyDir, expandHome, ownerOnlyFile } from "./state.mjs";
-import { replaceFileSync } from "./atomic-fs.mjs";
+import { replaceFileAtomicallySync } from "./exclusive-file.mjs";
 import { readBoundedRegularFileSync } from "./secure-file.mjs";
 
 const LABEL = "dev.machine-bridge-mcp.daemon";
@@ -40,17 +40,34 @@ export async function autostartStatus({ logger = console } = {}) {
 
 export async function startAutostart({ logger = console } = {}) {
   if (process.platform === "darwin") return startLaunchd(logger);
-  if (process.platform === "win32") return serviceRun("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
-  return serviceRun("systemctl", ["--user", "start", "machine-bridge-mcp.service"]);
+  if (process.platform === "win32") {
+    return normalizeServiceCommandResult("schtasks", await serviceRun("schtasks", ["/Run", "/TN", WINDOWS_TASK]));
+  }
+  return normalizeServiceCommandResult("systemd", await serviceRun("systemctl", ["--user", "start", "machine-bridge-mcp.service"]));
 }
 
 export async function stopAutostart({ logger = console } = {}) {
   if (process.platform === "darwin") return stopLaunchd(logger);
-  if (process.platform === "win32") return serviceRun("schtasks", ["/End", "/TN", WINDOWS_TASK]);
-  return serviceRun("systemctl", ["--user", "stop", "machine-bridge-mcp.service"]);
+  if (process.platform === "win32") {
+    return normalizeServiceCommandResult("schtasks", await serviceRun("schtasks", ["/End", "/TN", WINDOWS_TASK]), { allowAlreadyStopped: true });
+  }
+  return normalizeServiceCommandResult("systemd", await serviceRun("systemctl", ["--user", "stop", "machine-bridge-mcp.service"]), { allowAlreadyStopped: true });
 }
 
 
+
+export function normalizeServiceCommandResult(provider, result, { allowAlreadyStopped = false } = {}) {
+  const detail = `${result?.stdout || ""}
+${result?.stderr || ""}`;
+  const alreadyStopped = allowAlreadyStopped && /(?:not loaded|not found|does not exist|cannot find|not running|inactive)/i.test(detail);
+  return {
+    ...result,
+    ok: result?.code === 0 || alreadyStopped,
+    provider,
+    already_stopped: alreadyStopped,
+  };
+}
+
 export function trimAutostartLogs(stateRoot, options = {}) {
   const root = expandHome(stateRoot);
   const maxBytes = Number.isFinite(Number(options.maxBytes)) ? Math.max(1024, Number(options.maxBytes)) : 2 * 1024 * 1024;
@@ -233,15 +250,8 @@ function writePrivateServiceFile(file, content) {
     const info = lstatSync(file);
     if (info.isSymbolicLink() || !info.isFile()) throw new Error("autostart configuration path must be a regular non-symbolic-link file");
   }
-  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    writeFileSync(temporary, content, { mode: 0o600, flag: "wx" });
-    replaceFileSync(temporary, file);
-    ownerOnlyFile(file);
-  } catch (error) {
-    try { rmSync(temporary, { force: true }); } catch {}
-    throw error;
-  }
+  replaceFileAtomicallySync(file, content, { mode: 0o600 });
+  ownerOnlyFile(file);
 }
 
 function launchdPlistPath() {
@@ -379,17 +389,28 @@ async function installSystemd(spec, logger) {
   const reload = await serviceRun("systemctl", ["--user", "daemon-reload"]);
   const enable = await serviceRun("systemctl", ["--user", "enable", "machine-bridge-mcp.service"]);
   const linger = await serviceRun("loginctl", ["enable-linger", os.userInfo().username]);
-  logger.info?.("Autostart installed.");
-  return { ok: reload.code === 0 && enable.code === 0, provider: "systemd", path: servicePath, reload, enable, linger };
+  const ok = reload.code === 0 && enable.code === 0;
+  if (ok) logger.info?.("Autostart installed.");
+  else logger.warn?.("Autostart installation failed; the service definition was kept for diagnosis.");
+  return { ok, provider: "systemd", path: servicePath, reload, enable, linger };
 }
 
 async function uninstallSystemd(logger) {
-  await serviceRun("systemctl", ["--user", "disable", "--now", "machine-bridge-mcp.service"]);
   const servicePath = systemdPath();
+  const disable = await serviceRun("systemctl", ["--user", "disable", "--now", "machine-bridge-mcp.service"]);
+  const activeCheck = await serviceRun("systemctl", ["--user", "is-active", "machine-bridge-mcp.service"]);
+  const active = activeCheck.code === 0;
+  if (active) {
+    logger.warn?.("systemd service is still active; its definition was not removed.");
+    return { ok: false, provider: "systemd", path: servicePath, disable, active_check: activeCheck, active: true };
+  }
   if (existsSync(servicePath)) rmSync(servicePath, { force: true });
-  await serviceRun("systemctl", ["--user", "daemon-reload"]);
-  logger.info?.("Autostart removed.");
-  return { ok: true, provider: "systemd", path: servicePath };
+  const reload = await serviceRun("systemctl", ["--user", "daemon-reload"]);
+  const ok = reload.code === 0 && (disable.code === 0 || /not loaded|not found|does not exist/i.test(`${disable.stdout}
+${disable.stderr}`));
+  if (ok) logger.info?.("Autostart removed.");
+  else logger.warn?.("Autostart removal reported an error.");
+  return { ok, provider: "systemd", path: servicePath, disable, active_check: activeCheck, reload, active: false };
 }
 
 async function statusSystemd() {
@@ -421,14 +442,21 @@ WantedBy=default.target
 async function installWindowsTask(spec, logger) {
   const command = windowsCommand(spec);
   const result = await serviceRun("schtasks", ["/Create", "/TN", WINDOWS_TASK, "/SC", "ONLOGON", "/TR", command, "/F"]);
-  logger.info?.("Windows Scheduled Task installed for logon");
-  return { ok: result.code === 0, provider: "schtasks", task: WINDOWS_TASK, result };
+  const ok = result.code === 0;
+  if (ok) logger.info?.("Windows Scheduled Task installed for logon");
+  else logger.warn?.("Windows Scheduled Task installation failed");
+  return { ok, provider: "schtasks", task: WINDOWS_TASK, result };
 }
 
 async function uninstallWindowsTask(logger) {
+  const end = await serviceRun("schtasks", ["/End", "/TN", WINDOWS_TASK]);
   const result = await serviceRun("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
-  logger.info?.("Windows Scheduled Task removed");
-  return { ok: result.code === 0 || /cannot find/i.test(result.stderr), provider: "schtasks", task: WINDOWS_TASK, result };
+  const missing = /cannot find|not exist|not found/i.test(`${result.stdout}
+${result.stderr}`);
+  const ok = result.code === 0 || missing;
+  if (ok) logger.info?.("Windows Scheduled Task removed");
+  else logger.warn?.("Windows Scheduled Task removal failed");
+  return { ok, provider: "schtasks", task: WINDOWS_TASK, end, result };
 }
 
 async function statusWindowsTask() {

package/src/local/shell.mjs

@@ -12,6 +12,7 @@ export function run(command, args = [], options = {}) {
       env: options.env || process.env,
       stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit",
       shell: false,
+      detached: process.platform !== "win32",
       windowsHide: true,
     });
     let stdout = "";
@@ -26,9 +27,8 @@ export function run(command, args = [], options = {}) {
     if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
       timer = setTimeout(() => {
         timedOut = true;
-        try { child.kill("SIGTERM"); } catch {}
-        killTimer = setTimeout(() => { try { child.kill("SIGKILL"); } catch {} }, 2000);
-        killTimer.unref?.();
+        terminateCommandTree(child, false);
+        killTimer = setTimeout(() => terminateCommandTree(child, true), 2000);
       }, timeoutMs);
       timer.unref?.();
     }
@@ -36,7 +36,7 @@ export function run(command, args = [], options = {}) {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
-      if (killTimer) clearTimeout(killTimer);
+      if (killTimer && !timedOut) clearTimeout(killTimer);
       callback();
     };
     if (capture) {
@@ -73,6 +73,25 @@ export function run(command, args = [], options = {}) {
   });
 }
 
+
+function terminateCommandTree(child, force) {
+  if (!child?.pid) return;
+  if (process.platform === "win32") {
+    try {
+      const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", ...(force ? ["/F"] : [])], {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+      killer.unref();
+      return;
+    } catch {}
+  }
+  const signal = force ? "SIGKILL" : "SIGTERM";
+  try { process.kill(-child.pid, signal); } catch {
+    try { child.kill(signal); } catch {}
+  }
+}
+
 function appendLimited(current, chunk, max) {
   const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk ?? ""));
   const budget = Math.max(0, max - Buffer.byteLength(current));