@agent-device/proxy 0.21.29-nightly.20261019.75 → 0.21.29

package/dist/process.mjs

@@ -1,11 +1,31 @@
 import { i as redactDiagnosticData, n as createRequestCanceledError, t as AppError } from "./errors.mjs";
-import crypto from "node:crypto";
+import crypto, { randomUUID } from "node:crypto";
 import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import os from "node:os";
+//#region ../kernel/src/source-value.ts
+const BOOLEAN_TRUE_VALUES = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+const BOOLEAN_FALSE_VALUES = /* @__PURE__ */ new Set([
+	"0",
+	"false",
+	"no",
+	"off"
+]);
+function parseBooleanLiteral(value) {
+	const normalized = value.trim().toLowerCase();
+	if (BOOLEAN_TRUE_VALUES.has(normalized)) return true;
+	if (BOOLEAN_FALSE_VALUES.has(normalized)) return false;
+}
+//#endregion
 //#region ../host-kit/src/internal/diagnostics.ts
 const diagnosticsStorage = new AsyncLocalStorage();
 function updateDiagnosticsScope(options) {
@@ -52,6 +72,40 @@ function emitDiagnostic(event) {
 		if (scope.debug && !scope.logPath && !scope.traceLogPath) process.stderr.write(`[agent-device][diag] ${fileLine}`);
 	} catch {}
 }
+function flushDiagnosticsToSessionFile(options = {}) {
+	const scope = diagnosticsStorage.getStore();
+	if (!scope) return null;
+	if (!options.force && !scope.debug && !scope.flushOnSuccess) return null;
+	if (scope.events.length === 0) return null;
+	const values = sortedScopeSensitiveValues(scope);
+	try {
+		const logPath = scope.logPath ?? scope.flushedLogPath;
+		if (logPath) {
+			const pendingEvents = scope.events.slice(scope.liveWrittenEventCount);
+			if (pendingEvents.length > 0) appendDiagnosticLine(scope, logPath, `${pendingEvents.map((entry) => JSON.stringify(replaceSensitiveValues(entry, values))).join("\n")}\n`);
+			const logRecord = scope.logRecord;
+			scope.events = [];
+			scope.liveWrittenEventCount = 0;
+			return {
+				path: logPath,
+				...logRecord ? { ref: logRecord } : {}
+			};
+		}
+		const sessionDir = sanitizePathPart(scope.session ?? "default");
+		const dayDir = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const baseDir = path.join(os.homedir(), ".agent-device", "logs", sessionDir, dayDir);
+		fs.mkdirSync(baseDir, { recursive: true });
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-");
+		const filePath = path.join(baseDir, `${timestamp}-${scope.diagnosticId}.ndjson`);
+		const lines = scope.events.map((entry) => JSON.stringify(replaceSensitiveValues(entry, values)));
+		fs.writeFileSync(filePath, `${lines.join("\n")}\n`);
+		scope.flushedLogPath = filePath;
+		scope.events = [];
+		return { path: filePath };
+	} catch {
+		return null;
+	}
+}
 /** Longest-first so an overlapping shorter literal cannot truncate a longer one. */
 function sortedScopeSensitiveValues(scope) {
 	scope.sortedSensitiveValues ??= [...scope.sensitiveValues].sort((left, right) => right.length - left.length);
@@ -66,6 +120,9 @@ function replaceSensitiveValues(value, sensitiveValues) {
 	if (!value || typeof value !== "object") return value;
 	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, replaceSensitiveValues(entry, sensitiveValues)]));
 }
+function sanitizePathPart(value) {
+	return value.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+}
 function appendDiagnosticLine(scope, logPath, line) {
 	const dir = path.dirname(logPath);
 	if (!scope.ensuredDirectories.has(dir)) {
@@ -75,28 +132,41 @@ function appendDiagnosticLine(scope, logPath, line) {
 	fs.appendFileSync(logPath, line, "utf8");
 }
 //#endregion
-//#region ../kernel/src/source-value.ts
-const BOOLEAN_TRUE_VALUES = /* @__PURE__ */ new Set([
-	"1",
-	"true",
-	"yes",
-	"on"
-]);
-const BOOLEAN_FALSE_VALUES = /* @__PURE__ */ new Set([
-	"0",
-	"false",
-	"no",
-	"off"
-]);
-function parseBooleanLiteral(value) {
-	const normalized = value.trim().toLowerCase();
-	if (BOOLEAN_TRUE_VALUES.has(normalized)) return true;
-	if (BOOLEAN_FALSE_VALUES.has(normalized)) return false;
+//#region ../host-kit/src/internal/exec-trace.ts
+function createExecTraceContext(cmd, timeoutMs, hostEnv) {
+	const envTraceEnabled = parseBooleanLiteral(hostEnv?.AGENT_DEVICE_EXEC_TRACE ?? "") === true;
+	const meta = getDiagnosticsMeta();
+	if (!meta.debug && !envTraceEnabled) return { emit: () => {} };
+	if (envTraceEnabled && !meta.flushOnSuccess) updateDiagnosticsScope({ flushOnSuccess: true });
+	const started = performance.now();
+	const execId = randomUUID();
+	let pid;
+	let settlementEmitted = false;
+	const command = path.basename(cmd);
+	const emit = AsyncLocalStorage.bind((event, data = {}) => {
+		pid = data.pid ?? pid;
+		emitDiagnostic({
+			level: "debug",
+			phase: "exec_command",
+			durationMs: performance.now() - started,
+			data: {
+				execId,
+				command,
+				event,
+				pid,
+				timeoutMs,
+				...data
+			}
+		});
+		if (event === "settled") settlementEmitted = true;
+		if (envTraceEnabled && (event === "settled" || event === "close" && settlementEmitted)) flushDiagnosticsToSessionFile();
+	});
+	emit("spawn_start");
+	return { emit };
 }
 //#endregion
 //#region ../host-kit/src/internal/exec.ts
 const BARE_COMMAND_RE = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
-const EXEC_DIAGNOSTIC_ARG_LIMIT = 6;
 const commandExecutorOverrideScope = new AsyncLocalStorage();
 async function withoutCommandExecutorOverride(fn) {
 	return await commandExecutorOverrideScope.run(void 0, fn);
@@ -143,7 +213,7 @@ function coerceExecResult(result) {
 }
 function runSpawnedCommand(cmd, args, options = {}) {
 	const executable = normalizeExecutableCommand(cmd);
-	const execTrace = createExecTraceContext();
+	const execTrace = createExecTraceContext(cmd, normalizeTimeoutMs(options.timeoutMs), commandHostScope.getStore()?.host.env);
 	return new Promise((resolve, reject) => {
 		const child = spawn(executable, args, {
 			cwd: options.cwd,
@@ -157,6 +227,7 @@ function runSpawnedCommand(cmd, args, options = {}) {
 			windowsHide: true,
 			shell: false
 		});
+		child.once("spawn", () => execTrace.emit("spawn", { pid: child.pid }));
 		options.onSpawn?.(child);
 		let stdout = "";
 		const stdoutChunks = options.binaryStdout && options.captureOutput !== false ? [] : void 0;
@@ -165,20 +236,20 @@ function runSpawnedCommand(cmd, args, options = {}) {
 		const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
 		let timeoutHandle = null;
 		let settled = false;
-		function finish() {
+		function finish(reason) {
 			if (settled) return false;
 			settled = true;
 			if (timeoutHandle) clearTimeout(timeoutHandle);
 			abort.dispose();
 			destroyCommandStreams(child);
-			execTrace.emitForegroundCompletion(cmd, args);
+			execTrace.emit("settled", { reason });
 			return true;
 		}
-		function fail(error) {
-			if (finish()) reject(error);
+		function fail(error, reason) {
+			if (finish(reason)) reject(error);
 		}
 		function settle(code) {
-			if (!finish()) return;
+			if (!finish(abort.didAbort ? "abort" : didTimeout ? "timeout" : (code ?? 1) !== 0 && !options.allowFailure ? "exit_failure" : "success")) return;
 			const finalExitCode = code ?? 1;
 			if (!abort.didAbort && didTimeout && timeoutMs) {
 				reject(createTimeoutError(executable, cmd, args, timeoutMs, finalExitCode, stdout, stderr));
@@ -200,8 +271,12 @@ function runSpawnedCommand(cmd, args, options = {}) {
 			killProcessTree: () => killProcessTree(child, options),
 			settle
 		});
-		const abort = watchCommandAbort(options, settlement.requestKill);
+		const abort = watchCommandAbort(options, () => {
+			execTrace.emit("abort");
+			settlement.requestKill();
+		});
 		timeoutHandle = timeoutMs ? setTimeout(() => {
+			execTrace.emit("deadline");
 			didTimeout = true;
 			settlement.requestKill();
 		}, timeoutMs) : null;
@@ -210,7 +285,7 @@ function runSpawnedCommand(cmd, args, options = {}) {
 		writeChildStdin(child, options.stdin).catch((error) => {
 			if (abort.didAbort || didTimeout) return;
 			if (isEpipeError(error)) return;
-			fail(createStdinError(executable, cmd, args, error));
+			fail(createStdinError(executable, cmd, args, error), "stdin_error");
 			killProcessTree(child, options);
 		});
 		child.stdout.on("data", (chunk) => {
@@ -228,10 +303,23 @@ function runSpawnedCommand(cmd, args, options = {}) {
 			options.onStderrChunk?.(text);
 		});
 		child.on("error", (err) => {
-			fail(spawnRejectionError(abort, executable, cmd, args, err));
+			execTrace.emit("error");
+			fail(spawnRejectionError(abort, executable, cmd, args, err), "spawn_error");
+		});
+		child.once("exit", (code, signal) => {
+			execTrace.emit("exit", {
+				exitCode: code,
+				signal
+			});
+			settlement.recordExit(code);
+		});
+		child.once("close", (code, signal) => {
+			execTrace.emit("close", {
+				exitCode: code,
+				signal
+			});
+			settle(code);
 		});
-		child.once("exit", settlement.recordExit);
-		child.once("close", settle);
 	});
 }
 function runCmdSync(cmd, args, options = {}) {
@@ -273,64 +361,6 @@ function runCmdSync(cmd, args, options = {}) {
 		stdoutBuffer
 	};
 }
-function createExecTraceContext() {
-	const diagnosticsMeta = getDiagnosticsMeta();
-	const diagnosticsDebugEnabled = diagnosticsMeta.debug === true;
-	const envTraceEnabled = parseBooleanLiteral(commandHostScope.getStore()?.host.env.AGENT_DEVICE_EXEC_TRACE ?? "") === true;
-	if (!diagnosticsDebugEnabled && !envTraceEnabled) return createDisabledExecTraceContext();
-	if (envTraceEnabled && diagnosticsMeta.flushOnSuccess !== true) updateDiagnosticsScope({ flushOnSuccess: true });
-	const startedAtMs = Date.now();
-	let completionEmitted = false;
-	return {
-		emitForegroundCompletion: (cmd, args) => {
-			if (completionEmitted) return;
-			completionEmitted = true;
-			emitExecCommandDiagnostic({
-				cmd,
-				args,
-				startedAtMs
-			});
-		},
-		emitBackgroundSpawn: (cmd, args) => {
-			emitExecCommandDiagnostic({
-				cmd,
-				args,
-				data: { event: "spawn" }
-			});
-		},
-		emitBackgroundCompletion: (cmd, args, event) => {
-			if (completionEmitted) return;
-			completionEmitted = true;
-			emitExecCommandDiagnostic({
-				cmd,
-				args,
-				startedAtMs,
-				data: { event }
-			});
-		}
-	};
-}
-function createDisabledExecTraceContext() {
-	return {
-		emitForegroundCompletion: () => {},
-		emitBackgroundSpawn: () => {},
-		emitBackgroundCompletion: () => {}
-	};
-}
-function emitExecCommandDiagnostic(params) {
-	const argsPrefix = params.args.slice(0, EXEC_DIAGNOSTIC_ARG_LIMIT);
-	emitDiagnostic({
-		level: "debug",
-		phase: "exec_command",
-		durationMs: params.startedAtMs === void 0 ? void 0 : Math.max(0, Date.now() - params.startedAtMs),
-		data: {
-			command: params.cmd,
-			argsPrefix,
-			...params.args.length > argsPrefix.length ? { omittedArgCount: params.args.length - argsPrefix.length } : {},
-			...params.data ?? {}
-		}
-	});
-}
 function normalizeExecutableCommand(cmd) {
 	const candidate = normalizeExecutableLookup(cmd);
 	if (!candidate) throw new AppError("INVALID_ARGS", `Invalid executable command: ${JSON.stringify(cmd)}`, {

package/package.json

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