@amaster.ai/employee-runtime-connector 0.1.1-beta.7 → 0.1.1-beta.8

package/dist/amaster-runtime-daemon.mjs

@@ -7277,6 +7277,14 @@ function runtimeStatusOutboxDir(config) {
     AMASTER_DAEMON_STATE_FILE: statePath
   })), "result-outbox");
 }
+function runtimeStatusRunCompletionDir(config) {
+  const explicit = config.AMASTER_RUN_COMPLETION_STATE_DIR ?? config.runCompletionStateDir;
+  if (typeof explicit === "string" && explicit.trim()) return resolve6(explicit);
+  const statePath = config.AMASTER_DAEMON_STATE_FILE ?? config.daemonStateFile;
+  return join10(dirname6(stateFilePath({
+    AMASTER_DAEMON_STATE_FILE: statePath
+  })), "run-completion-state");
+}
 function countRuntimeStatusJsonEntries(dir) {
   if (!existsSync9(dir)) return 0;
   return runtimeStatusDirectoryEntries(dir).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).length;
@@ -7311,6 +7319,8 @@ function summarizeRuntimeLocalState(input) {
   }
   const pendingOutboxDir = runtimeStatusOutboxDir(config);
   const invalidOutboxDir = join10(pendingOutboxDir, "invalid");
+  const pendingRunCompletionDir = runtimeStatusRunCompletionDir(config);
+  const invalidRunCompletionDir = join10(pendingRunCompletionDir, "invalid");
   return {
     managedWorkspacesRoot: root,
     managedWorkdirCount: workdirs.length,
@@ -7320,7 +7330,9 @@ function summarizeRuntimeLocalState(input) {
     newestTouchedAt: newestTouchedTime === null ? null : new Date(newestTouchedTime).toISOString(),
     recentManagedRuns: recentManagedRuns.sort((left, right) => right.sortTime - left.sortTime || left.manifestPath.localeCompare(right.manifestPath)).slice(0, input.recentManagedRunLimit ?? 5).map(({ sortTime: _sortTime, ...entry }) => entry),
     resultOutboxPending: countRuntimeStatusJsonEntries(pendingOutboxDir),
-    resultOutboxInvalid: countRuntimeStatusJsonEntries(invalidOutboxDir)
+    resultOutboxInvalid: countRuntimeStatusJsonEntries(invalidOutboxDir),
+    runCompletionPending: countRuntimeStatusJsonEntries(pendingRunCompletionDir),
+    runCompletionInvalid: countRuntimeStatusJsonEntries(invalidRunCompletionDir)
   };
 }
 
@@ -9197,7 +9209,7 @@ function assertSourceAcquisitionRuntimeAuthority({
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.7";
+var CONNECTOR_VERSION = "0.1.1-beta.8";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SOURCE_ACQUISITION_CAPABILITY = "source_acquisition_v1";
 var SOURCE_ACQUISITION_PROFILE_VERSION = "source_acquisition_v1";
@@ -9433,6 +9445,9 @@ function resultOutboxFailedRunCommands(config) {
   }
   return entries;
 }
+function activeRunCommandCountsAsActive(entry) {
+  return readString(entry?.phase) !== "result_outbox_failed" && readString(entry?.evidenceDeliveryStatus) !== "failed";
+}
 function clearDeliveredResultOutboxCommand(config, entry) {
   const commandId = readString(entry?.commandId);
   if (commandId) pendingResultOutboxRunCommands.delete(commandId);
@@ -9860,6 +9875,7 @@ function buildHeartbeatPayload(config, options = {}) {
     activeRunCommandById.set(commandId ?? `pending-${activeRunCommandById.size}`, entry);
   }
   const activeRunCommandList = Array.from(activeRunCommandById.values()).map((entry) => buildActiveRunCommandStatus(config, entry));
+  const activeRunCount = activeRunCommandList.filter(activeRunCommandCountsAsActive).length;
   const executorReadiness = buildExecutorReadiness(config);
   const platformCredential = piAgentLocalPlatformCredentialStatus(config);
   const headedBrowserAuth = browserCapabilityStatus(config, "headed_browser_auth");
@@ -9882,7 +9898,7 @@ function buildHeartbeatPayload(config, options = {}) {
       ...heartbeatMode === "diagnostic" ? { heartbeatMode: "diagnostic" } : {},
       ...diagnosticSource ? { diagnosticSource } : {},
       ...orphanCheck === "startup" ? { orphanCheck: "startup" } : {},
-      activeRuns: activeRunCommandList.length,
+      activeRuns: activeRunCount,
       ...activeRunCommandList.length > 0 ? { activeRunCommands: activeRunCommandList } : {},
       pollIntervalSeconds: config.pollIntervalSeconds,
       orphanReaperIntervalSeconds: config.orphanReaperIntervalSeconds,
@@ -14594,7 +14610,8 @@ function statusSummary(config) {
   process.stdout.write(`${JSON.stringify(summarizeRuntimeLocalState({
     config: {
       ...config,
-      AMASTER_DAEMON_STATE_FILE: stateFilePath(process.env)
+      AMASTER_DAEMON_STATE_FILE: stateFilePath(process.env),
+      AMASTER_RUN_COMPLETION_STATE_DIR: process.env.AMASTER_RUN_COMPLETION_STATE_DIR
     }
   }), null, 2)}
 `);

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.7";
+const CONNECTOR_VERSION = "0.1.1-beta.8";
 
 const CAPABILITIES = [
   "remote_registration",
@@ -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"),
@@ -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.7",
+  "version": "0.1.1-beta.8",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",