machine-bridge-mcp 0.11.0 → 0.12.0

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,21 +250,26 @@ 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() {
   return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
 }
 
+export function launchdServiceTarget(uid = process.getuid?.()) {
+  const parsed = Number(uid);
+  if (!Number.isInteger(parsed) || parsed < 0) throw new Error("launchd requires a numeric user id");
+  return `gui/${parsed}/${LABEL}`;
+}
+
+function launchdDomainTarget(uid = process.getuid?.()) {
+  const parsed = Number(uid);
+  if (!Number.isInteger(parsed) || parsed < 0) throw new Error("launchd requires a numeric user id");
+  return `gui/${parsed}`;
+}
+
 async function installLaunchd(spec, logger) {
   const plistPath = launchdPlistPath();
   mkdirSync(path.dirname(plistPath), { recursive: true });
@@ -259,34 +281,73 @@ async function installLaunchd(spec, logger) {
 
 async function startLaunchd(logger) {
   const plistPath = launchdPlistPath();
-  const target = `gui/${process.getuid?.() ?? ""}`;
+  const target = launchdDomainTarget();
   if (!existsSync(plistPath)) return { ok: false, error: "launchd plist not installed" };
-  await serviceRun("launchctl", ["bootout", target, plistPath]);
+  const stopped = await stopLaunchd({ info() {}, warn() {} });
+  if (!stopped.ok) return { ok: false, provider: "launchd", stop: stopped };
   const boot = await serviceRun("launchctl", ["bootstrap", target, plistPath]);
   const kick = await serviceRun("launchctl", ["kickstart", "-k", `${target}/${LABEL}`]);
-  logger.info?.("launchd service started");
-  return { ok: boot.code === 0 || kick.code === 0, bootstrap: boot, kickstart: kick };
+  const ok = boot.code === 0 || kick.code === 0;
+  if (ok) logger.info?.("launchd service started");
+  else logger.warn?.("launchd service failed to start");
+  return { ok, provider: "launchd", bootstrap: boot, kickstart: kick };
 }
 
 async function stopLaunchd(logger) {
   const plistPath = launchdPlistPath();
-  const target = `gui/${process.getuid?.() ?? ""}`;
-  const result = await serviceRun("launchctl", ["bootout", target, plistPath]);
-  logger.info?.("launchd service stopped");
-  return result;
+  const domainTarget = launchdDomainTarget();
+  const serviceTarget = launchdServiceTarget();
+  const before = await statusLaunchd();
+  if (!before.active) {
+    logger.info?.("launchd service is not loaded");
+    return {
+      ok: true,
+      provider: "launchd",
+      installed: existsSync(plistPath),
+      active_before: false,
+      active: false,
+      already_stopped: true,
+      code: 0,
+      stdout: "",
+      stderr: "",
+    };
+  }
+
+  const byServiceTarget = await serviceRun("launchctl", ["bootout", serviceTarget]);
+  const byPlist = byServiceTarget.code === 0
+    ? null
+    : await serviceRun("launchctl", ["bootout", domainTarget, plistPath]);
+  const after = await statusLaunchd();
+  const rawResult = byPlist || byServiceTarget;
+  const ok = !after.active;
+  if (ok) logger.info?.("launchd service stopped");
+  else logger.warn?.("launchd service is still active after the stop request");
+  return {
+    ...rawResult,
+    ok,
+    provider: "launchd",
+    installed: existsSync(plistPath),
+    active_before: true,
+    active: after.active,
+    already_stopped: false,
+    code: ok ? 0 : rawResult.code,
+    bootout_service_target: byServiceTarget,
+    ...(byPlist ? { bootout_plist_fallback: byPlist } : {}),
+  };
 }
 
 async function uninstallLaunchd(logger) {
-  await stopLaunchd(logger).catch(() => {});
+  const stopped = await stopLaunchd(logger);
   const plistPath = launchdPlistPath();
+  if (!stopped.ok) return { ok: false, provider: "launchd", path: plistPath, stop: stopped };
   if (existsSync(plistPath)) rmSync(plistPath, { force: true });
   logger.info?.("Autostart removed.");
-  return { ok: true, provider: "launchd", path: plistPath };
+  return { ok: true, provider: "launchd", path: plistPath, stop: stopped };
 }
 
 async function statusLaunchd() {
   const plistPath = launchdPlistPath();
-  const target = `gui/${process.getuid?.() ?? ""}/${LABEL}`;
+  const target = launchdServiceTarget();
   const result = await serviceRun("launchctl", ["print", target]);
   return { ok: existsSync(plistPath), provider: "launchd", installed: existsSync(plistPath), path: plistPath, active: result.code === 0, detail: result.stdout || result.stderr };
 }
@@ -328,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() {
@@ -370,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));