@oh-my-pi/pi-coding-agent 13.14.2 → 13.15.2

package/src/tools/gemini-image.ts

@@ -287,7 +287,7 @@ async function loadImageFromUrl(imageUrl: string, signal?: AbortSignal): Promise
 		throw new Error(`Image download failed (${response.status}): ${rawText}`);
 	}
 	const contentType = response.headers.get("content-type")?.split(";")[0];
-	if (!contentType || !contentType.startsWith("image/")) {
+	if (!contentType?.startsWith("image/")) {
 		throw new Error(`Unsupported image type from URL: ${imageUrl}`);
 	}
 	const buffer = await response.bytes();

package/src/tools/resolve.ts

@@ -54,7 +54,7 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 	): Promise<AgentToolResult<ResolveToolDetails>> {
 		return untilAborted(signal, async () => {
 			const store = this.session.pendingActionStore;
-			if (!store || !store.hasPending) {
+			if (!store?.hasPending) {
 				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
 			}
 

package/src/utils/child-process.ts

@@ -0,0 +1,88 @@
+import type { ChildProcess } from "node:child_process";
+
+const EXIT_STDIO_GRACE_MS = 100;
+
+/**
+ * Wait for a child process to terminate without hanging on inherited stdio handles.
+ *
+ * Daemonized descendants can inherit the child's stdout/stderr pipe handles. In that
+ * case the child emits `exit`, but `close` can hang forever even though the original
+ * process is already gone. We wait briefly for stdio to end, then forcibly stop
+ * tracking the inherited handles.
+ */
+export function waitForChildProcess(child: ChildProcess): Promise<number | null> {
+	const { promise, resolve, reject } = Promise.withResolvers<number | null>();
+
+	let settled = false;
+	let exited = false;
+	let exitCode: number | null = null;
+	let postExitTimer: NodeJS.Timeout | undefined;
+	let stdoutEnded = child.stdout === null;
+	let stderrEnded = child.stderr === null;
+
+	const cleanup = () => {
+		if (postExitTimer) {
+			clearTimeout(postExitTimer);
+			postExitTimer = undefined;
+		}
+		child.removeListener("error", onError);
+		child.removeListener("exit", onExit);
+		child.removeListener("close", onClose);
+		child.stdout?.removeListener("end", onStdoutEnd);
+		child.stderr?.removeListener("end", onStderrEnd);
+	};
+
+	const finalize = (code: number | null) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		child.stdout?.destroy();
+		child.stderr?.destroy();
+		resolve(code);
+	};
+
+	const maybeFinalizeAfterExit = () => {
+		if (!exited || settled) return;
+		if (stdoutEnded && stderrEnded) {
+			finalize(exitCode);
+		}
+	};
+
+	const onStdoutEnd = () => {
+		stdoutEnded = true;
+		maybeFinalizeAfterExit();
+	};
+
+	const onStderrEnd = () => {
+		stderrEnded = true;
+		maybeFinalizeAfterExit();
+	};
+
+	const onError = (err: Error) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		reject(err);
+	};
+
+	const onExit = (code: number | null) => {
+		exited = true;
+		exitCode = code;
+		maybeFinalizeAfterExit();
+		if (!settled) {
+			postExitTimer = setTimeout(() => finalize(code), EXIT_STDIO_GRACE_MS);
+		}
+	};
+
+	const onClose = (code: number | null) => {
+		finalize(code);
+	};
+
+	child.stdout?.once("end", onStdoutEnd);
+	child.stderr?.once("end", onStderrEnd);
+	child.once("error", onError);
+	child.once("exit", onExit);
+	child.once("close", onClose);
+
+	return promise;
+}