@agent-device/proxy 0.21.23 → 0.21.24

package/dist/errors.mjs

@@ -123,12 +123,18 @@ const KNOWN_APP_ERROR_CODES = [
 	"REPAIR_COMMIT_FAILED",
 	"UNKNOWN"
 ];
-var AppError = class extends Error {
+const APP_ERROR_BRAND = Symbol.for("agent-device.AppError");
+var AppError = class AppError extends Error {
+	static [Symbol.hasInstance](value) {
+		if (this !== AppError) return Function.prototype[Symbol.hasInstance].call(this, value);
+		return typeof value === "object" && value !== null && value[APP_ERROR_BRAND] === true;
+	}
 	code;
 	details;
 	cause;
 	constructor(code, message, details, cause) {
 		super(message);
+		Object.defineProperty(this, APP_ERROR_BRAND, { value: true });
 		this.code = code;
 		this.details = details;
 		this.cause = cause;

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { r as normalizeError, t as AppError } from "./errors.mjs";
 import crypto, { randomUUID } from "node:crypto";
 import http from "node:http";
+import "node:path";
 //#region ../host-kit/src/internal/transport.ts
 /**
 * Compares two secret strings in constant time. Hashing both inputs first

package/dist/process.mjs

@@ -1,8 +1,8 @@
 import { i as redactDiagnosticData, n as createRequestCanceledError, t as AppError } from "./errors.mjs";
 import crypto from "node:crypto";
+import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs";
-import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -355,13 +355,6 @@ function createStdinError(executable, cmd, args, cause) {
 		args
 	}, cause instanceof Error ? cause : void 0);
 }
-function createCommandCanceledError(executable, cmd, args) {
-	return createRequestCanceledError({
-		cmd,
-		args,
-		executable
-	});
-}
 function createTimeoutError(executable, cmd, args, timeoutMs, exitCode, stdout, stderr) {
 	return new AppError("COMMAND_FAILED", `${executable} timed out after ${timeoutMs}ms`, {
 		cmd,
@@ -408,10 +401,18 @@ function execFailureDetails(result, extra) {
 	};
 }
 function spawnRejectionError(abort, executable, cmd, args, err) {
-	return abort.didAbort ? createCommandCanceledError(executable, cmd, args) : createSpawnError(executable, cmd, args, err);
+	return abort.didAbort ? createRequestCanceledError({
+		cmd,
+		args,
+		executable
+	}) : createSpawnError(executable, cmd, args, err);
 }
 function commandCloseFailure(abort, executable, cmd, args, exitCode, allowFailure, stdout, stderr) {
-	if (abort.didAbort) return createCommandCanceledError(executable, cmd, args);
+	if (abort.didAbort) return createRequestCanceledError({
+		cmd,
+		args,
+		executable
+	});
 	if (exitCode !== 0 && !allowFailure) return createExitError(executable, cmd, args, exitCode, stdout, stderr);
 	return null;
 }
@@ -518,14 +519,34 @@ function isEpipeError(error) {
 	return error instanceof Error && "code" in error && error.code === "EPIPE";
 }
 //#endregion
-//#region ../host-kit/src/internal/timeouts.ts
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+//#region ../host-kit/src/internal/retry.ts
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) {
+			resolve();
+			return;
+		}
+		let settled = false;
+		const finish = () => {
+			if (settled) return;
+			settled = true;
+			if (signal) signal.removeEventListener("abort", onAbort);
+			resolve();
+		};
+		const timer = setTimeout(finish, ms);
+		function onAbort() {
+			clearTimeout(timer);
+			finish();
+		}
+		if (signal) signal.addEventListener("abort", onAbort, { once: true });
+	});
 }
 //#endregion
 //#region ../host-kit/src/internal/host-process.ts
 const PS_TIMEOUT_MS = 1e3;
-const HOST_PS_COMMAND = process.platform === "win32" ? "ps" : "/bin/ps";
+const HOST_PS_COMMAND = "/bin/ps";
+const WINDOWS_PS_TIMEOUT_MS = 2e3;
+const WINDOWS_PROCESS_TOOL = "powershell.exe";
 function hostEnvironment() {
 	return process.env;
 }
@@ -571,10 +592,12 @@ function isProcessGroupAlive(pid) {
 /**
 * Reads who owns a pid, off the event loop, with a budget the caller names. The three fields
 * are read concurrently so a loaded host pays one budget for the set rather than one per
-* field. Use this rather than the synchronous probes when the answer decides whether a
-* process is signaled: waiting is reversible and signaling the wrong process is not.
+* field; on Windows one CIM query answers the whole set. Use this rather than the synchronous
+* probes when the answer decides whether a process is signaled: waiting is reversible and
+* signaling the wrong process is not.
 */
 async function readProcessIdentityFacts(pid, timeoutMs = PS_TIMEOUT_MS) {
+	if (isWindowsHostPlatform()) return await readWindowsProcessIdentityFacts(pid, timeoutMs);
 	const [startTime, command, state] = await Promise.all([
 		readProcessFieldAsync(pid, "lstart=", timeoutMs),
 		readProcessFieldAsync(pid, "command=", timeoutMs),
@@ -593,14 +616,25 @@ function readProcessCommand(pid) {
 	return readProcessField(pid, "command=");
 }
 function isProcessZombie(pid) {
+	if (isWindowsHostPlatform()) return false;
 	return readProcessField(pid, "state=")?.startsWith("Z") ?? false;
 }
 function readHostProcessIdentityObservations(pids) {
 	const observations = /* @__PURE__ */ new Map();
 	const selected = uniquePositivePids(pids);
 	if (selected.length === 0) return observations;
+	if (isWindowsHostPlatform()) {
+		for (const row of readWindowsProcessRows(selected, WINDOWS_PS_TIMEOUT_MS)) {
+			if (row.startTime === null) continue;
+			observations.set(row.pid, {
+				state: "R",
+				startTime: row.startTime
+			});
+		}
+		return observations;
+	}
 	try {
-		const result = runCmdSync("ps", [
+		const result = runCmdSync(HOST_PS_COMMAND, [
 			"-p",
 			selected.join(","),
 			"-o",
@@ -625,6 +659,7 @@ function readHostProcessIdentityObservations(pids) {
 }
 function readProcessField(pid, field) {
 	if (!Number.isInteger(pid) || pid <= 0) return null;
+	if (isWindowsHostPlatform()) return readWindowsProcessField(pid, field);
 	try {
 		return processFieldValue(runCmdSync(HOST_PS_COMMAND, [
 			"-p",
@@ -660,24 +695,122 @@ function processFieldValue(result) {
 	const value = result.stdout.trim();
 	return value.length > 0 ? value : null;
 }
-function parseHostProcessList(stdout) {
-	const processes = [];
-	for (const line of stdout.split("\n")) {
-		const match = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/.exec(line);
+/**
+* Walks process-table stdout line by line, keeping rows whose first two
+* capture groups are a positive pid and an optional positive ppid. Every
+* process-table format (POSIX `ps`, Windows CIM) feeds its own row pattern
+* and row builder through this single walk.
+*/
+function parseProcessTableRows(stdout, rowPattern, build) {
+	const rows = [];
+	for (const line of stdout.replace(/^\uFEFF/, "").split("\n")) {
+		const match = rowPattern.exec(line);
 		if (!match) continue;
 		const pid = Number.parseInt(match[1], 10);
-		const ppid = Number.parseInt(match[2], 10);
-		const command = match[3];
 		if (!Number.isInteger(pid) || pid <= 0) continue;
-		processes.push({
-			pid,
-			ppid: Number.isInteger(ppid) && ppid > 0 ? ppid : void 0,
-			command
+		const ppid = Number.parseInt(match[2], 10);
+		rows.push(build(match, pid, Number.isInteger(ppid) && ppid > 0 ? ppid : void 0));
+	}
+	return rows;
+}
+function parseHostProcessList(stdout) {
+	return parseProcessTableRows(stdout, /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/, (match, pid, ppid) => ({
+		pid,
+		ppid,
+		command: match[3]
+	}));
+}
+function isWindowsHostPlatform() {
+	return hostPlatform() === "win32";
+}
+const WINDOWS_PROCESS_ROW_BODY = " | ForEach-Object { $birth = if ($_.CreationDate) { $_.CreationDate.ToUniversalTime().ToString('yyyyMMddHHmmssfffffff', [System.Globalization.CultureInfo]::InvariantCulture) } else { '' }; '{0}|{1}|{2}|{3}' -f $_.ProcessId, $_.ParentProcessId, $birth," + String.raw` ($_.CommandLine -replace '[\r\n]+', ' ') }`;
+function windowsProcessQueryArgs(pids) {
+	return [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		`[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; ${pids.length > 0 ? `Get-CimInstance -ClassName Win32_Process -Filter '${pids.map((pid) => `ProcessId=${pid}`).join(" OR ")}'` : "Get-CimInstance -ClassName Win32_Process"}${WINDOWS_PROCESS_ROW_BODY}`
+	];
+}
+function parseWindowsProcessRows(stdout) {
+	return parseProcessTableRows(stdout, /^(\d+)\|(\d+)\|([^|]*)\|(.*)\r?$/, (match, pid, ppid) => ({
+		pid,
+		...ppid !== void 0 ? { ppid } : {},
+		startTime: match[3].length > 0 ? match[3] : null,
+		command: match[4].length > 0 ? match[4] : null
+	}));
+}
+function readWindowsProcessRows(pids, timeoutMs) {
+	try {
+		const result = runCmdSync(WINDOWS_PROCESS_TOOL, windowsProcessQueryArgs(pids), {
+			allowFailure: true,
+			timeoutMs
 		});
+		if (result.exitCode !== 0) return [];
+		return parseWindowsProcessRows(result.stdout);
+	} catch {
+		return [];
+	}
+}
+function readWindowsProcessField(pid, field) {
+	const row = readWindowsProcessRows([pid], WINDOWS_PS_TIMEOUT_MS).find((candidate) => candidate.pid === pid);
+	if (!row) return null;
+	if (field === "lstart=") return row.startTime;
+	if (field === "command=") return row.command;
+	return "R";
+}
+function windowsBudgetMs(timeoutMs) {
+	return Math.max(timeoutMs, WINDOWS_PS_TIMEOUT_MS);
+}
+async function readWindowsProcessIdentityFacts(pid, timeoutMs) {
+	if (!Number.isInteger(pid) || pid <= 0) return {
+		startTime: null,
+		command: null,
+		zombie: null
+	};
+	try {
+		const result = await runCmd(WINDOWS_PROCESS_TOOL, windowsProcessQueryArgs([pid]), {
+			allowFailure: true,
+			timeoutMs: windowsBudgetMs(timeoutMs)
+		});
+		if (result.exitCode !== 0) return {
+			startTime: null,
+			command: null,
+			zombie: null
+		};
+		const row = parseWindowsProcessRows(result.stdout).find((candidate) => candidate.pid === pid);
+		if (!row) return {
+			startTime: null,
+			command: null,
+			zombie: null
+		};
+		return {
+			startTime: row.startTime,
+			command: row.command,
+			zombie: false
+		};
+	} catch {
+		return {
+			startTime: null,
+			command: null,
+			zombie: null
+		};
 	}
-	return processes;
+}
+async function listWindowsHostProcesses(options) {
+	const result = await (options.runCommand ?? runCmd)(WINDOWS_PROCESS_TOOL, windowsProcessQueryArgs([]), {
+		allowFailure: true,
+		timeoutMs: windowsBudgetMs(options.timeoutMs)
+	});
+	if (result.exitCode !== 0) return [];
+	return parseWindowsProcessRows(result.stdout).map((row) => ({
+		pid: row.pid,
+		...row.ppid !== void 0 ? { ppid: row.ppid } : {},
+		command: row.command ?? ""
+	}));
 }
 async function listHostProcesses(options) {
+	if (isWindowsHostPlatform()) return await listWindowsHostProcesses(options);
 	const result = await (options.runCommand ?? runCmd)(options.runCommand ? "ps" : HOST_PS_COMMAND, [
 		"-ax",
 		"-o",
@@ -864,14 +997,16 @@ function appendReapOutcome(summary, record, outcome, retained) {
 	retained.push(record);
 }
 async function reapOwnedProcess(record, policy) {
-	const initial = inspectOwnedProcess(record);
+	const initial = await inspectOwnedProcess(record);
 	if (initial !== void 0) return initial;
 	signalBestEffort(record.pid, initialSignalFor(record));
 	return await escalateOwnedProcess(record, policy);
 }
-function inspectOwnedProcess(record) {
-	if (record.pid === process.pid || !isProcessAlive(record.pid) || isProcessZombie(record.pid)) return "missing";
-	return matchesRecord(record) ? void 0 : "ownership-lost";
+async function inspectOwnedProcess(record) {
+	if (record.pid === process.pid || !isProcessAlive(record.pid)) return "missing";
+	const facts = await readProcessIdentityFacts(record.pid);
+	if (facts.zombie) return "missing";
+	return matchesFacts(record, facts) ? void 0 : "ownership-lost";
 }
 function initialSignalFor(record) {
 	return record.purpose === "simctl-screen-recording" ? "SIGINT" : "SIGTERM";
@@ -885,11 +1020,13 @@ async function escalateOwnedProcess(record, policy) {
 }
 async function waitForOwnedProcessExit(record, timeoutMs) {
 	await waitForProcessExit(record.pid, timeoutMs);
-	if (!isProcessAlive(record.pid) || isProcessZombie(record.pid)) return "exited";
-	return matchesRecord(record) ? "owned-alive" : "ownership-lost";
+	if (!isProcessAlive(record.pid)) return "exited";
+	const facts = await readProcessIdentityFacts(record.pid);
+	if (facts.zombie) return "exited";
+	return matchesFacts(record, facts) ? "owned-alive" : "ownership-lost";
 }
-function matchesRecord(record) {
-	return readProcessStartTime(record.pid) === record.startTime && readProcessCommand(record.pid) === record.command;
+function matchesFacts(record, facts) {
+	return facts.startTime === record.startTime && facts.command === record.command;
 }
 function signalBestEffort(pid, signal) {
 	try {
@@ -1120,19 +1257,47 @@ function ownerIdentityDiffers(left, right) {
 * owner as recycled would let a waiter steal a held resource.
 */
 function classifyOwnerLiveness(params) {
-	return classifyOwnerLivenessFromObservation(params);
+	const guarded = guardOwnerPid(params.owner);
+	if (guarded) return guarded;
+	return classifyLiveOwnerFromObservation(params, readHostProcessIdentityObservations([params.owner.pid]).get(params.owner.pid) ?? null);
 }
 function classifyOwnerLivenessFromObservation(params, observation) {
-	const { owner, stateDir } = params;
+	const guarded = guardOwnerPid(params.owner);
+	if (guarded) return guarded;
+	return classifyLiveOwnerFromObservation(params, observation);
+}
+/** The verdicts provable from the pid alone; undefined means the caller may probe on. */
+function guardOwnerPid(owner) {
 	if (!isProcessPid(owner.pid)) return "unknown";
 	if (!isProcessAlive(owner.pid)) return "owner-process-dead";
-	if (observation !== void 0 ? observation?.state.startsWith("Z") : isProcessZombie(owner.pid)) return "owner-process-dead";
-	if (owner.startTime) {
-		const currentStartTime = observation !== void 0 ? observation?.startTime ?? null : readProcessStartTime(owner.pid);
-		if (currentStartTime !== null && currentStartTime !== owner.startTime) return "owner-process-reused";
-	}
+}
+/** Judges an owner the caller has established as a live, valid pid; probes no liveness. */
+function classifyLiveOwnerFromObservation(params, observation) {
+	const { owner, stateDir } = params;
+	if (hostSaysZombie(owner, observation)) return "owner-process-dead";
+	if (owner.startTime && provesPidReused(owner, observation)) return "owner-process-reused";
 	return stateDir ? classifyOwnerStateDirectory(stateDir) : "live";
 }
+/**
+* Whether the host calls this owner a zombie. An `undefined` observation means
+* no snapshot was taken and the field probe answers; a `null` observation is a
+* completed snapshot that did not list the pid, which is unknown evidence and
+* never a zombie claim.
+*/
+function hostSaysZombie(owner, observation) {
+	if (observation === void 0) return isProcessZombie(owner.pid);
+	return observation?.state.startsWith("Z") ?? false;
+}
+/**
+* Whether the recorded birth time proves the pid changed hands. Only a
+* readable current start time that differs from the record proves reuse; an
+* `undefined` observation falls back to the field probe, and a host that did
+* not answer is unknown evidence, never proof.
+*/
+function provesPidReused(owner, observation) {
+	const currentStartTime = observation === void 0 ? readProcessStartTime(owner.pid) : observation?.startTime ?? null;
+	return currentStartTime !== null && currentStartTime !== owner.startTime;
+}
 function classifyOwnerStateDirectory(stateDir) {
 	try {
 		fs.statSync(stateDir);

package/dist/version.mjs

@@ -1,5 +1,5 @@
-import fs from "node:fs";
 import path from "node:path";
+import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region ../host-kit/src/internal/project-root.ts
 function resolveAgentDeviceProjectRoot(startDirectory) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-device/proxy",
-  "version": "0.21.23",
+  "version": "0.21.24",
   "type": "module",
   "description": "Transport-neutral authenticating proxy in front of an agent-device daemon.",
   "license": "MIT",