@amaster.ai/employee-runtime-connector 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/amaster-runtime.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
-import { dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { basename, dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.1-beta.2";
+const CONNECTOR_VERSION = "0.1.1-beta.21";
 
 const CAPABILITIES = [
   "remote_registration",
@@ -52,8 +53,8 @@ const CONFIG_KEY_MAP = new Map([
   ["pi_coding_agent_dir", "PI_CODING_AGENT_DIR"],
   ["pi_agent_home", "PI_AGENT_HOME"],
   ["pi_agent_node", "PI_AGENT_NODE"],
-  ["pi_agent_runner_mode", "AMASTER_PI_AGENT_RUNNER_MODE"],
-  ["pi_agent_system_data_dir", "AMASTER_PI_AGENT_SYSTEM_DATA_DIR"],
+  ["runner_kind", "AMASTER_RUNTIME_RUNNER_KIND"],
+  ["desktop_platform_system_data_dir", "AMASTER_RUNTIME_DESKTOP_PLATFORM_SYSTEM_DATA_DIR"],
   ["heartbeat_log_mode", "AMASTER_HEARTBEAT_LOG_MODE"],
 ]);
 
@@ -81,8 +82,8 @@ const ENV_ORDER = [
   "PI_CODING_AGENT_DIR",
   "PI_AGENT_HOME",
   "PI_AGENT_NODE",
-  "AMASTER_PI_AGENT_RUNNER_MODE",
-  "AMASTER_PI_AGENT_SYSTEM_DATA_DIR",
+  "AMASTER_RUNTIME_RUNNER_KIND",
+  "AMASTER_RUNTIME_DESKTOP_PLATFORM_SYSTEM_DATA_DIR",
   "AMASTER_HEARTBEAT_LOG_MODE",
 ];
 
@@ -364,6 +365,58 @@ function runningStatePid(state, config) {
   return pidRunning(pid) ? pid : null;
 }
 
+function processCommandLine(pid) {
+  try {
+    if (process.platform === "linux") {
+      return readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\0", " ").trim() || null;
+    }
+    if (process.platform === "win32") {
+      const result = spawnSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `(Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}').CommandLine`,
+        ],
+        { encoding: "utf8", windowsHide: true, timeout: 2_000 },
+      );
+      return result.status === 0 ? result.stdout.trim() || null : null;
+    }
+    const result = spawnSync("ps", ["-ww", "-p", String(pid), "-o", "command="], {
+      encoding: "utf8",
+      timeout: 2_000,
+    });
+    return result.status === 0 ? result.stdout.trim() || null : null;
+  } catch {
+    return null;
+  }
+}
+
+function recordedDaemonIdentity(pidInfo, state, config) {
+  const pid = Number(pidInfo?.pid);
+  if (!pidRunning(pid)) return { status: "not_running", pid };
+  const commandLine = processCommandLine(pid);
+  // An unavailable OS probe is not proof that the PID belongs to another
+  // process. Keep the PID file intact and refuse start/stop so the CLI cannot
+  // trade signal safety for a duplicate daemon.
+  if (!commandLine) return { status: "unverifiable", pid };
+  const processToken = typeof pidInfo?.processToken === "string" ? pidInfo.processToken.trim() : "";
+  const expectedScriptPath = resolve(daemonScriptPath());
+  if (processToken) {
+    // The random token is the primary identity across dev/installed/symlink
+    // layouts. The daemon basename and token flag keep an unrelated process
+    // that merely contains the token text from matching.
+    const matchesTokenIdentity = commandLine.includes("--runtime-process-token")
+      && commandLine.includes(processToken)
+      && (commandLine.includes(expectedScriptPath) || commandLine.includes(basename(expectedScriptPath)));
+    return { status: matchesTokenIdentity ? "matched" : "mismatched", pid };
+  }
+  const matchesLegacyIdentity = commandLine.includes(expectedScriptPath)
+    && runningStatePid(state, config) === pid;
+  return { status: matchesLegacyIdentity ? "matched" : "mismatched", pid };
+}
+
 function daemonScriptPath() {
   const candidates = [
     join(scriptDir, "amaster-runtime-daemon.mjs"),
@@ -404,8 +457,8 @@ function printConfig(config) {
     ["pi_coding_agent_dir", merged.PI_CODING_AGENT_DIR || "(default)"],
     ["pi_agent_home", merged.PI_AGENT_HOME || "(default)"],
     ["pi_agent_node", merged.PI_AGENT_NODE || "(default)"],
-    ["pi_agent_runner_mode", merged.AMASTER_PI_AGENT_RUNNER_MODE || "(disabled)"],
-    ["pi_agent_system_data_dir", merged.AMASTER_PI_AGENT_SYSTEM_DATA_DIR ? "(configured)" : "(not configured)"],
+    ["runner_kind", merged.AMASTER_RUNTIME_RUNNER_KIND || "cloud_managed"],
+    ["desktop_platform_system_data_dir", merged.AMASTER_RUNTIME_DESKTOP_PLATFORM_SYSTEM_DATA_DIR ? "(configured)" : "(not configured)"],
     ["heartbeat_log_mode", merged.AMASTER_HEARTBEAT_LOG_MODE || "(compact)"],
     ["network_domains", merged.AMASTER_NETWORK_DOMAINS],
     ["capabilities", merged.AMASTER_CAPABILITIES],
@@ -875,10 +928,18 @@ function commandDaemon(argv) {
   if (action === "restart") commandStop({ quiet: true });
 
   const current = readPidInfo();
-  if (current?.pid && pidRunning(current.pid) && flags.force !== "true") {
-    process.stdout.write(`AMaster runtime daemon already running pid=${current.pid}\n`);
+  const currentIdentity = recordedDaemonIdentity(current, readState(config), withDefaults(config));
+  if (currentIdentity.status === "unverifiable") {
+    throw new Error(
+      `Cannot safely start AMaster runtime daemon: pid ${currentIdentity.pid} is live but the process identity probe was unavailable. `
+      + "The PID file was retained; restore the platform process probe or stop the supervised process explicitly before retrying.",
+    );
+  }
+  if (currentIdentity.status === "matched" && flags.force !== "true") {
+    process.stdout.write(`AMaster runtime daemon already running pid=${currentIdentity.pid}\n`);
     return;
   }
+  if (currentIdentity.status === "matched") commandStop({ quiet: true });
 
   if (flags.foreground === "true") {
     spawnDaemonForeground(["start"]);
@@ -887,7 +948,13 @@ function commandDaemon(argv) {
 
   mkdirSync(configDir, { recursive: true });
   const fd = openSync(logFile, "a");
-  const child = spawn(process.execPath, [daemonScriptPath(), "start"], {
+  const processToken = randomUUID();
+  const child = spawn(process.execPath, [
+    daemonScriptPath(),
+    "start",
+    "--runtime-process-token",
+    processToken,
+  ], {
     cwd: scriptDir,
     detached: true,
     env: {
@@ -900,6 +967,7 @@ function commandDaemon(argv) {
   closeSync(fd);
   writePidInfo({
     pid: child.pid,
+    processToken,
     startedAt: new Date().toISOString(),
     serverUrl: withDefaults(config).AMASTER_EMPLOYEE_SERVER_URL,
     logFile,
@@ -912,12 +980,14 @@ function commandStatus() {
   const config = withDefaults(readConfig());
   const pidInfo = readPidInfo();
   const state = readState(config);
-  const foregroundPid = runningStatePid(state, config);
-  const runningPid = pidInfo?.pid && pidRunning(pidInfo.pid) ? pidInfo.pid : foregroundPid;
+  const foregroundPid = pidInfo?.pid ? null : runningStatePid(state, config);
+  const recordedIdentity = recordedDaemonIdentity(pidInfo, state, config);
+  const runningPid = recordedIdentity.status === "matched" ? recordedIdentity.pid : foregroundPid;
   process.stdout.write("AMaster runtime daemon\n");
-  process.stdout.write(`status: ${runningPid ? "running" : "stopped"}\n`);
+  process.stdout.write(`status: ${runningPid ? "running" : recordedIdentity.status === "unverifiable" ? "unknown" : "stopped"}\n`);
   if (runningPid) process.stdout.write(`pid: ${runningPid}\n`);
-  else if (pidInfo?.pid) process.stdout.write(`pid: ${pidInfo.pid}\n`);
+  else if (recordedIdentity.status === "unverifiable") process.stdout.write(`unverified_pid: ${recordedIdentity.pid}\n`);
+  else if (pidInfo?.pid) process.stdout.write(`stale_pid: ${pidInfo.pid}\n`);
   process.stdout.write(`server_url: ${config.AMASTER_EMPLOYEE_SERVER_URL}\n`);
   process.stdout.write(`device_name: ${config.AMASTER_CONNECTOR_NAME}\n`);
   process.stdout.write(`workspace_bindings: ${config.AMASTER_WORKSPACE_ALLOWLIST}\n`);
@@ -934,6 +1004,8 @@ function commandStatus() {
     process.stdout.write(`stale_managed_workdirs: ${localSummary.staleManagedWorkdirCount ?? 0}\n`);
     process.stdout.write(`result_outbox_pending: ${localSummary.resultOutboxPending ?? 0}\n`);
     process.stdout.write(`result_outbox_invalid: ${localSummary.resultOutboxInvalid ?? 0}\n`);
+    process.stdout.write(`run_completion_pending: ${localSummary.runCompletionPending ?? 0}\n`);
+    process.stdout.write(`run_completion_invalid: ${localSummary.runCompletionInvalid ?? 0}\n`);
     const recentManagedRuns = Array.isArray(localSummary.recentManagedRuns)
       ? localSummary.recentManagedRuns
       : [];
@@ -957,19 +1029,27 @@ function commandStatus() {
 }
 
 function commandStop(opts = {}) {
+  const config = withDefaults(readConfig());
   const pidInfo = readPidInfo();
-  if (!pidInfo?.pid || !pidRunning(pidInfo.pid)) {
+  const recordedIdentity = recordedDaemonIdentity(pidInfo, readState(config), config);
+  if (recordedIdentity.status === "unverifiable") {
+    throw new Error(
+      `Cannot safely stop AMaster runtime daemon: pid ${recordedIdentity.pid} is live but the process identity probe was unavailable. `
+      + "The PID file was retained and no signal was sent.",
+    );
+  }
+  if (recordedIdentity.status !== "matched") {
     if (!opts.quiet) process.stdout.write("AMaster runtime daemon is not running\n");
     rmSync(pidFile, { force: true });
     return;
   }
   try {
-    process.kill(pidInfo.pid, "SIGTERM");
+    process.kill(recordedIdentity.pid, "SIGTERM");
   } catch {
     // Process may exit between the status check and SIGTERM.
   }
   rmSync(pidFile, { force: true });
-  if (!opts.quiet) process.stdout.write(`AMaster runtime daemon stopped pid=${pidInfo.pid}\n`);
+  if (!opts.quiet) process.stdout.write(`AMaster runtime daemon stopped pid=${recordedIdentity.pid}\n`);
 }
 
 function passthroughDaemon(command, argv = []) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.1-beta.2",
+  "version": "0.1.1-beta.21",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",