@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/{transport-stdio-CyPldczm.js → transport-stdio-BGjHoYLr.js}

@@ -1,13 +1,17 @@
 import { n as normalizeCodexAppServerArgs } from "./launch-args-RXQwn8zV.js";
-import { readFile, readdir } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
-import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { z } from "zod";
-import { execFile, spawn } from "node:child_process";
+import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
+import { readFile, readdir } from "node:fs/promises";
 import { once } from "node:events";
+import { execFile, spawn } from "node:child_process";
 import { setImmediate } from "node:timers/promises";
 import { finished } from "node:stream/promises";
 //#region extensions/codex/src/app-server/transport-process-snapshot.ts
+/** A zombie leader can still own running threads, reported by the ps-style l flag. */
+function isDeadProcessState(state) {
+	return state.startsWith("Z") && !state.includes("l");
+}
 const PROCESS_COLUMNS = "pid=,ppid=,pgid=,stat=,lstart=";
 const MAX_PROCESS_CONTAINMENT_MS$1 = 2e3;
 const PROCESS_INSPECTION_MAX_BYTES = 8388608;
@@ -178,13 +182,17 @@ async function readLinuxProcesses(selected, deadline) {
 			const pgid = Number(fields[2]);
 			const startTicks = fields[19];
 			if (commEnd < 0 || ![ppid, pgid].every(Number.isSafeInteger) || selected !== void 0 && (pgid <= 0 || ppid < 0) || !/^\d+$/.test(startTicks ?? "")) throw new ProcessInspectionError("unavailable");
-			if (pgid > 0) rows.push({
-				pid: Number(entry),
-				ppid,
-				pgid,
-				state: fields[0],
-				startedAt: `${bootId}:${startTicks}`
-			});
+			if (pgid > 0) {
+				const threads = Number(fields[17]);
+				if (!/^[1-9]\d*$/.test(fields[17] ?? "") || !Number.isSafeInteger(threads)) throw new ProcessInspectionError("unavailable");
+				rows.push({
+					pid: Number(entry),
+					ppid,
+					pgid,
+					state: `${fields[0]}${threads > 1 ? "l" : ""}`,
+					startedAt: `${bootId}:${startTicks}`
+				});
+			}
 		}
 		if (Date.now() >= deadline) throw new ProcessInspectionError("deadline");
 		return rows;
@@ -197,14 +205,10 @@ async function readLinuxProcesses(selected, deadline) {
 const MAX_CONTAINED_PROCESSES = 512;
 const MAX_PROCESS_CONTAINMENT_MS = 2e3;
 const MAX_PROCESS_QUIESCE_PASSES = 16;
-async function terminateCodexAppServerDescendants(child) {
-	const contained = await containDescendants(child);
-	return contained === "exited" ? contained : contained?.resume;
-}
-/** A durable spawn fact, never a command-line match, selects the orphan root. */
+/** Discharges the registered root obligation, including an already-obsolete PID. */
 async function terminateCodexAppServerOrphan(expected) {
 	const deadline = Date.now() + MAX_PROCESS_CONTAINMENT_MS;
-	const result = await containDescendants({
+	const result = await terminateCodexAppServerDescendants({
 		pid: expected.pid,
 		kill: (signal) => signalProcess(expected.pid, signal ?? "SIGTERM")
 	}, expected, deadline);
@@ -219,7 +223,7 @@ async function terminateCodexAppServerOrphan(expected) {
 			const snapshot = await readCodexAppServerProcessSnapshot(deadline).catch(() => void 0);
 			if (!snapshot?.some((row) => row.pid === process.pid)) return false;
 			const current = snapshot.find((row) => row.pid === expected.pid);
-			if (!current || !hasSameIdentity(current, expected) || current.state.startsWith("Z")) {
+			if (!current || !hasSameIdentity(current, expected) || isDeadProcessState(current.state)) {
 				gone = true;
 				return true;
 			}
@@ -233,15 +237,15 @@ async function terminateCodexAppServerOrphan(expected) {
 		if (contained && !gone) await signalSameRoot(contained.root, "SIGCONT", Date.now() + MAX_PROCESS_CONTAINMENT_MS);
 	}
 }
-async function containDescendants(child, expected, deadline = Date.now() + MAX_PROCESS_CONTAINMENT_MS) {
+async function terminateCodexAppServerDescendants(child, expected, deadline = Date.now() + MAX_PROCESS_CONTAINMENT_MS) {
 	const rootPid = child.pid;
 	if (hasExited(child)) return "exited";
 	if (process.platform === "win32" || !rootPid || !child.kill) return;
 	const snapshot = await readCodexAppServerProcessSnapshot(deadline).catch(() => void 0);
 	if (!snapshot || Date.now() >= deadline) return;
 	const root = snapshot.find((row) => row.pid === rootPid);
-	if (!expected && (!root || root.state.startsWith("Z"))) return "exited";
-	if (!root || !(expected ? isSameLiveProcess(root, expected) : root.ppid === process.pid) || root.state.startsWith("Z")) return;
+	if (!expected && (!root || isDeadProcessState(root.state))) return "exited";
+	if (!root || !(expected ? isSameLiveProcess(root, expected) : root.ppid === process.pid) || isDeadProcessState(root.state)) return;
 	const initialDescendants = collectDescendants(snapshot, [rootPid]);
 	if (initialDescendants.length > MAX_CONTAINED_PROCESSES) return;
 	const stoppedDescendants = /* @__PURE__ */ new Map();
@@ -252,10 +256,25 @@ async function containDescendants(child, expected, deadline = Date.now() + MAX_P
 		if (!descendants) return;
 		for (const descendant of descendants.toReversed()) {
 			if (Date.now() >= deadline) return;
-			if (!descendant.state.startsWith("Z")) {
+			if (!isDeadProcessState(descendant.state)) {
 				if (!await signalSameProcess(descendant, "SIGKILL", deadline) || Date.now() >= deadline) return;
 			}
 		}
+		const remaining = new Map(descendants.map((row) => [row.pid, row]));
+		while (remaining.size > 0) {
+			const terminationSnapshot = await readCodexAppServerProcessSnapshot(deadline, [root.pid, ...remaining.keys()]).catch(() => void 0);
+			if (!terminationSnapshot || Date.now() >= deadline) return;
+			const currentRoot = terminationSnapshot.find((row) => row.pid === root.pid);
+			if (!currentRoot || !isSameLiveRoot(currentRoot, root, true)) return;
+			const currentByPid = new Map(terminationSnapshot.map((row) => [row.pid, row]));
+			for (const [pid, retained] of remaining) {
+				const current = currentByPid.get(pid);
+				if (!current || !hasSameIdentity(current, retained) || isDeadProcessState(current.state)) remaining.delete(pid);
+			}
+			if (remaining.size > 0) await new Promise((resolve) => {
+				setTimeout(resolve, 20);
+			});
+		}
 		resumeRootOnUnwind = false;
 		let resumed = false;
 		return {
@@ -355,7 +374,7 @@ function collectDescendants(snapshot, rootPids) {
 	return descendants;
 }
 function isStoppedState(state) {
-	return state.startsWith("T") || state.startsWith("t") || state.startsWith("Z");
+	return state.startsWith("T") || state.startsWith("t") || isDeadProcessState(state);
 }
 function isQuiescedState(state) {
 	return isStoppedState(state) || isUninterruptibleState(state);
@@ -364,7 +383,7 @@ function isUninterruptibleState(state) {
 	return state.startsWith("D") || state.startsWith("U");
 }
 function isSameLiveProcess(current, expected) {
-	return current.pgid === expected.pgid && !current.state.startsWith("Z") && hasSameIdentity(current, expected);
+	return current.pgid === expected.pgid && !isDeadProcessState(current.state) && hasSameIdentity(current, expected);
 }
 function isSameLiveRoot(current, expected, requireStopped = false) {
 	return current.ppid === expected.ppid && (!requireStopped || isQuiescedState(current.state)) && isSameLiveProcess(current, expected);
@@ -407,6 +426,7 @@ function signalProcess(pid, signal) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/transport-process-registration.ts
+const PROCESS_REGISTRATION_INSPECTION_MS = 1e4;
 const processIdentity = z.object({
 	pid: z.number().int().positive().safe(),
 	pgid: z.number().int().positive().safe(),
@@ -428,17 +448,17 @@ async function openProcessRegistrationStore() {
 		overflowPolicy: "reject-new"
 	});
 }
-async function reapRegisteredCodexAppServerOrphans(requestedDeadline) {
+async function reapRegisteredCodexAppServerOrphans() {
 	const store = await openProcessRegistrationStore();
-	const deadline = requestedDeadline ?? Date.now() + 1e4;
+	const deadline = Date.now() + PROCESS_REGISTRATION_INSPECTION_MS;
 	for (const entry of store.entries()) {
 		if (Date.now() >= deadline) throw new Error("Codex orphan cleanup exceeded its startup budget. Retry to finish cleanup.");
 		const registration = registrationSchema.parse(entry.value);
-		const snapshot = await readCodexAppServerProcessSnapshot(void 0, [registration.parent.pid, registration.child.pid]);
+		const snapshot = await readCodexAppServerProcessSnapshot(deadline, [registration.parent.pid, registration.child.pid]);
 		const parent = snapshot.find((row) => row.pid === registration.parent.pid);
-		if (parent?.startedAt === registration.parent.startedAt && !parent.state.startsWith("Z")) continue;
+		if (parent?.startedAt === registration.parent.startedAt && !isDeadProcessState(parent.state)) continue;
 		const child = snapshot.find((row) => row.pid === registration.child.pid);
-		if (registration.child.commandFingerprint !== void 0 && child?.startedAt === registration.child.startedAt && !child.state.startsWith("Z")) {
+		if (registration.child.commandFingerprint !== void 0 && child?.startedAt === registration.child.startedAt && !isDeadProcessState(child.state)) {
 			let command;
 			try {
 				command = await readCodexAppServerProcessCommand(child, deadline);
@@ -479,11 +499,12 @@ async function prepareCodexAppServerProcessRegistration() {
 	return async (child) => {
 		await once(child, "spawn");
 		if (!child.pid) throw new ProcessInspectionError("unavailable");
-		const snapshot = await readCodexAppServerProcessSnapshot(void 0, [child.pid]);
+		const deadline = Date.now() + PROCESS_REGISTRATION_INSPECTION_MS;
+		const snapshot = await readCodexAppServerProcessSnapshot(deadline, [child.pid]);
 		const parent = snapshot.find((row) => row.pid === process.pid);
 		const spawned = snapshot.find((row) => row.pid === child.pid);
 		if (!parent || !spawned || spawned.ppid !== process.pid) throw new Error("Cannot register the Codex child process: its direct-parent identity is unavailable. Retry.");
-		const command = await readCodexAppServerProcessCommand(spawned, Date.now() + 2e3);
+		const command = await readCodexAppServerProcessCommand(spawned, deadline);
 		if (child.exitCode !== null || child.signalCode !== null) throw new Error("Cannot register the Codex child process command: the child exited during inspection. Retry.");
 		const key = randomUUID();
 		store.register(key, {
@@ -518,38 +539,43 @@ function closeCodexAppServerTransport(child, options = {}) {
 function beginCodexAppServerTransportClose(child, options) {
 	const current = CODEX_APP_SERVER_TRANSPORT_CLOSES.get(child);
 	if (current) return current;
+	let forced = false;
+	const forceKill = () => {
+		forced = true;
+		signalCodexAppServerTransport(child, "SIGKILL");
+	};
 	const closure = {
 		closing: (async () => {
-			if (hasCodexAppServerTransportExited(child)) return true;
+			if (hasCodexAppServerTransportExited(child)) return "natural";
 			if (process.platform === "win32" || !child.pid || !child.kill) {
-				finishCodexAppServerTransportClose(child, options);
-				return false;
+				finishCodexAppServerTransportClose(child, options, forceKill);
+				return "uncertain";
 			}
-			let resumeRoot;
+			let contained;
 			try {
-				const contained = await terminateCodexAppServerDescendants(child);
-				if (contained === "exited") return true;
-				resumeRoot = contained;
+				contained = await terminateCodexAppServerDescendants(child);
 			} catch {
-				resumeRoot = void 0;
+				contained = void 0;
 			}
+			if (contained === "exited") return "natural";
 			try {
-				finishCodexAppServerTransportClose(child, options, resumeRoot);
+				finishCodexAppServerTransportClose(child, options, forceKill, contained?.resume);
 			} catch {
-				signalCodexAppServerTransport(child, "SIGKILL");
+				forceKill();
 			}
-			return false;
+			return contained ? "contained" : "uncertain";
 		})(),
-		naturalExit: false
+		naturalExit: false,
+		wasForced: () => forced
 	};
 	CODEX_APP_SERVER_TRANSPORT_CLOSES.set(child, closure);
 	return closure;
 }
-function finishCodexAppServerTransportClose(child, options, resumeRoot) {
+function finishCodexAppServerTransportClose(child, options, killTransport, resumeRoot) {
 	const forceKillDelayMs = options.forceKillDelayMs ?? 1e3;
 	const forceKill = setTimeout(() => {
 		if (hasCodexAppServerTransportExited(child)) return;
-		signalCodexAppServerTransport(child, "SIGKILL");
+		killTransport();
 	}, Math.max(1, forceKillDelayMs));
 	forceKill.unref?.();
 	child.once("exit", () => {
@@ -570,18 +596,24 @@ function finishCodexAppServerTransportClose(child, options, resumeRoot) {
 	child.stderr.unref?.();
 	child.stdin.unref?.();
 }
-/** Closes a transport and waits briefly for an exit event. */
+/** Reports physical settlement separately from confirmed process cleanup. */
 async function closeCodexAppServerTransportAndWait(child, options = {}) {
 	const drained = options.drainStdio ? Promise.all([child.stdout, child.stderr].map((stream) => finished(stream, { cleanup: true }))).then(() => true, () => false) : void 0;
 	const closure = beginCodexAppServerTransportClose(child, options);
-	const naturalExit = await closure.closing;
+	const containment = await closure.closing;
 	const settled = await waitForCodexAppServerTransportExit(child, options.exitTimeoutMs ?? 2e3, drained);
-	closure.naturalExit = naturalExit && settled;
+	closure.naturalExit = containment === "natural" && settled;
 	if (options.drainStdio) {
 		child.stdout.destroy?.();
 		child.stderr.destroy?.();
 	}
-	return settled;
+	return settled ? {
+		exited: true,
+		cleanup: containment === "contained" && !closure.wasForced() && child.signalCode == null ? "closed" : "uncertain"
+	} : {
+		exited: false,
+		cleanup: "uncertain"
+	};
 }
 function hasCodexAppServerTransportExited(child) {
 	return child.exitCode !== null && child.exitCode !== void 0 ? true : child.signalCode !== null && child.signalCode !== void 0;