@oh-my-pi/pi-coding-agent 16.4.8 → 16.5.0

package/src/launch/client.ts

@@ -0,0 +1,344 @@
+import * as fs from "node:fs/promises";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isEexist, isEnoent, postmortem } from "@oh-my-pi/pi-utils";
+import { resolveWorkerSpawnCmd, workerEnvFromParent } from "../subprocess/worker-client";
+import { daemonBrokerEndpoint, daemonRuntimeDir } from "./paths";
+import {
+	DAEMON_BROKER_WORKER_ARG,
+	DAEMON_IDLE_GRACE_ENV,
+	DAEMON_PROJECT_DIR_ENV,
+	DAEMON_RUNTIME_DIR_ENV,
+	type DaemonOperation,
+	type DaemonRpcResult,
+	type DaemonWireResponse,
+	parseDaemonRpcResult,
+	parseDaemonWireResponse,
+} from "./protocol";
+
+const CONNECT_TIMEOUT_MS = 10_000;
+const CONNECT_RETRY_MS = 50;
+const TOKEN_FILE = "broker.token";
+
+interface PendingRequest {
+	operation: DaemonOperation;
+	resolve: (result: DaemonRpcResult) => void;
+	reject: (error: Error) => void;
+	timer: NodeJS.Timeout;
+	removeAbort?: () => void;
+}
+
+/** Broker location and lifecycle overrides used by smoke tests and isolated consumers. */
+export interface DaemonBrokerClientOptions {
+	/** Runtime directory override; defaults to the project-scoped config path. */
+	runtimeDir?: string;
+	/** Last-client shutdown grace override in milliseconds. */
+	idleGraceMs?: number;
+}
+
+/** Persistent per-process connection to one project's daemon broker. */
+export interface DaemonBrokerClient {
+	readonly projectDir: string;
+	request(operation: DaemonOperation, signal?: AbortSignal): Promise<DaemonRpcResult>;
+	close(): void;
+}
+
+async function canonicalProjectDir(projectDir: string): Promise<string> {
+	const resolved = path.resolve(projectDir);
+	try {
+		return await fs.realpath(resolved);
+	} catch (error) {
+		if (isEnoent(error)) return resolved;
+		throw error;
+	}
+}
+
+async function readOrCreateToken(runtimeDir: string): Promise<string> {
+	await fs.mkdir(runtimeDir, { recursive: true, mode: 0o700 });
+	const tokenPath = path.join(runtimeDir, TOKEN_FILE);
+	const tokenFile = Bun.file(tokenPath);
+	for (let attempt = 0; attempt < 100; attempt++) {
+		try {
+			const token = (await tokenFile.text()).trim();
+			if (token.length > 0) return token;
+		} catch (error) {
+			if (!isEnoent(error)) throw error;
+		}
+
+		try {
+			const handle = await fs.open(tokenPath, "wx", 0o600);
+			try {
+				const token = crypto.randomUUID().replaceAll("-", "") + crypto.randomUUID().replaceAll("-", "");
+				await handle.writeFile(token, "utf8");
+				return token;
+			} finally {
+				await handle.close();
+			}
+		} catch (error) {
+			if (!isEexist(error)) throw error;
+		}
+		await Bun.sleep(10);
+	}
+	throw new Error(`Timed out initializing daemon broker token in ${runtimeDir}`);
+}
+
+function requestTimeoutMs(operation: DaemonOperation): number {
+	switch (operation.op) {
+		case "start":
+			return (operation.spec.ready?.timeoutMs ?? CONNECT_TIMEOUT_MS) + 5_000;
+		case "wait":
+		case "logs":
+		case "stop":
+			return operation.timeoutMs + 5_000;
+		default:
+			return 30_000;
+	}
+}
+
+function openSocket(endpoint: string, timeoutMs: number): Promise<net.Socket> {
+	const { promise, resolve, reject } = Promise.withResolvers<net.Socket>();
+	const socket = net.createConnection({ path: endpoint });
+	const timer = setTimeout(() => {
+		socket.destroy();
+		reject(new Error(`Timed out connecting to daemon broker at ${endpoint}`));
+	}, timeoutMs);
+	const cleanup = (): void => {
+		clearTimeout(timer);
+		socket.off("connect", onConnect);
+		socket.off("error", onError);
+	};
+	const onConnect = (): void => {
+		cleanup();
+		resolve(socket);
+	};
+	const onError = (error: Error): void => {
+		cleanup();
+		socket.destroy();
+		reject(error);
+	};
+	socket.once("connect", onConnect);
+	socket.once("error", onError);
+	return promise;
+}
+
+class SocketDaemonClient implements DaemonBrokerClient {
+	readonly projectDir: string;
+	readonly #runtimeDir: string;
+	readonly #endpoint: string;
+	readonly #token: string;
+	readonly #idleGraceMs: number | undefined;
+	readonly #pending = new Map<string, PendingRequest>();
+	#socket: net.Socket | undefined;
+	#connectPromise: Promise<void> | undefined;
+	#buffer = "";
+	#closed = false;
+
+	constructor(projectDir: string, runtimeDir: string, token: string, options: DaemonBrokerClientOptions) {
+		this.projectDir = projectDir;
+		this.#runtimeDir = runtimeDir;
+		this.#endpoint = daemonBrokerEndpoint(projectDir, runtimeDir);
+		this.#token = token;
+		this.#idleGraceMs = options.idleGraceMs;
+	}
+
+	async request(operation: DaemonOperation, signal?: AbortSignal): Promise<DaemonRpcResult> {
+		if (this.#closed) throw new Error("Daemon broker client is closed");
+		if (signal?.aborted) throw new Error("Daemon broker request aborted");
+		await this.#connect();
+		const socket = this.#socket;
+		if (!socket || socket.destroyed) throw new Error("Daemon broker socket is unavailable");
+
+		const id = crypto.randomUUID();
+		const { promise, resolve, reject } = Promise.withResolvers<DaemonRpcResult>();
+		const timer = setTimeout(() => {
+			const pending = this.#pending.get(id);
+			if (!pending) return;
+			this.#pending.delete(id);
+			pending.removeAbort?.();
+			reject(new Error(`Daemon ${operation.op} request timed out`));
+		}, requestTimeoutMs(operation));
+		const pending: PendingRequest = { operation, resolve, reject, timer };
+		if (signal) {
+			const abort = (): void => {
+				if (!this.#pending.delete(id)) return;
+				clearTimeout(timer);
+				reject(new Error("Daemon broker request aborted"));
+			};
+			signal.addEventListener("abort", abort, { once: true });
+			pending.removeAbort = () => signal.removeEventListener("abort", abort);
+		}
+		this.#pending.set(id, pending);
+		socket.write(`${JSON.stringify({ id, token: this.#token, operation })}\n`);
+		return promise;
+	}
+
+	close(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#socket?.destroy();
+		this.#socket = undefined;
+		this.#rejectPending(new Error("Daemon broker client closed"));
+	}
+
+	async #connect(): Promise<void> {
+		if (this.#socket && !this.#socket.destroyed) return;
+		if (this.#connectPromise) return this.#connectPromise;
+		this.#connectPromise = this.#connectOnce();
+		try {
+			await this.#connectPromise;
+		} finally {
+			this.#connectPromise = undefined;
+		}
+	}
+
+	async #connectOnce(): Promise<void> {
+		try {
+			this.#bindSocket(await openSocket(this.#endpoint, 250));
+			return;
+		} catch {
+			// No live broker. Multiple clients may race to spawn; the broker's PID
+			// lease selects one winner before any candidate touches the socket.
+		}
+		this.#spawnBroker();
+		const deadline = Date.now() + CONNECT_TIMEOUT_MS;
+		let lastError: Error | undefined;
+		while (Date.now() < deadline) {
+			try {
+				this.#bindSocket(await openSocket(this.#endpoint, 250));
+				return;
+			} catch (error) {
+				lastError = error instanceof Error ? error : new Error(String(error));
+				await Bun.sleep(CONNECT_RETRY_MS);
+			}
+		}
+		throw new Error(`Failed to start daemon broker: ${lastError?.message ?? "socket unavailable"}`);
+	}
+
+	#spawnBroker(): void {
+		const spawn = resolveWorkerSpawnCmd(DAEMON_BROKER_WORKER_ARG);
+		const overlay: Record<string, string> = {
+			[DAEMON_PROJECT_DIR_ENV]: this.projectDir,
+			[DAEMON_RUNTIME_DIR_ENV]: this.#runtimeDir,
+		};
+		if (this.#idleGraceMs !== undefined) overlay[DAEMON_IDLE_GRACE_ENV] = String(this.#idleGraceMs);
+		const child = Bun.spawn(spawn.cmd, {
+			cwd: spawn.cwd,
+			env: workerEnvFromParent(overlay),
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "ignore",
+			detached: true,
+		});
+		child.unref();
+	}
+
+	#bindSocket(socket: net.Socket): void {
+		this.#socket = socket;
+		this.#buffer = "";
+		socket.setEncoding("utf8");
+		socket.on("data", chunk => this.#onData(chunk));
+		socket.on("error", () => {
+			// The close handler rejects pending requests with one stable error.
+		});
+		socket.on("close", () => {
+			if (this.#socket === socket) this.#socket = undefined;
+			this.#rejectPending(new Error("Daemon broker connection closed"));
+		});
+	}
+
+	#onData(chunk: string | Buffer): void {
+		this.#buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+		for (;;) {
+			const newline = this.#buffer.indexOf("\n");
+			if (newline < 0) return;
+			const line = this.#buffer.slice(0, newline);
+			this.#buffer = this.#buffer.slice(newline + 1);
+			if (line.length === 0) continue;
+			let response: DaemonWireResponse;
+			try {
+				const decoded: unknown = JSON.parse(line);
+				response = parseDaemonWireResponse(decoded);
+			} catch (error) {
+				this.#rejectPending(error instanceof Error ? error : new Error(String(error)));
+				continue;
+			}
+			const pending = this.#pending.get(response.id);
+			if (!pending) continue;
+			this.#pending.delete(response.id);
+			clearTimeout(pending.timer);
+			pending.removeAbort?.();
+			if (!response.ok) {
+				pending.reject(new Error(response.error));
+				continue;
+			}
+			try {
+				pending.resolve(parseDaemonRpcResult(pending.operation, response.result));
+			} catch (error) {
+				pending.reject(error instanceof Error ? error : new Error(String(error)));
+			}
+		}
+	}
+
+	#rejectPending(error: Error): void {
+		for (const pending of this.#pending.values()) {
+			clearTimeout(pending.timer);
+			pending.removeAbort?.();
+			pending.reject(error);
+		}
+		this.#pending.clear();
+	}
+}
+
+const sharedClients = new Map<string, Promise<DaemonBrokerClient>>();
+let cancelExitCleanup: (() => void) | undefined;
+
+/** Create an independent socket connection to one project's shared daemon broker. */
+export async function createDaemonBrokerClient(
+	projectDir: string,
+	options: DaemonBrokerClientOptions = {},
+): Promise<DaemonBrokerClient> {
+	const canonical = await canonicalProjectDir(projectDir);
+	const runtimeDir = options.runtimeDir ?? daemonRuntimeDir(canonical);
+	const token = await readOrCreateToken(runtimeDir);
+	return new SocketDaemonClient(canonical, runtimeDir, token, options);
+}
+
+/** Get the process-shared daemon broker client for one canonical project directory. */
+export async function daemonClientForProject(projectDir: string): Promise<DaemonBrokerClient> {
+	const canonical = await canonicalProjectDir(projectDir);
+	let pending = sharedClients.get(canonical);
+	if (!pending) {
+		pending = createDaemonBrokerClient(canonical);
+		sharedClients.set(canonical, pending);
+		if (!cancelExitCleanup) {
+			cancelExitCleanup = postmortem.register("daemon-broker-clients", () => closeDaemonClients());
+		}
+	}
+	return pending;
+}
+
+/** Close every project broker connection held by this omp process. */
+export async function closeDaemonClients(): Promise<void> {
+	const pending = [...sharedClients.values()];
+	sharedClients.clear();
+	for (const client of await Promise.all(pending)) client.close();
+	cancelExitCleanup?.();
+	cancelExitCleanup = undefined;
+}
+
+/** Exercise worker-host broker startup and authenticated RPC for distribution smoke tests. */
+export async function smokeTestDaemonBroker(): Promise<void> {
+	const projectDir = await fs.mkdtemp(path.join(os.tmpdir(), "omp-daemon-smoke-project-"));
+	const runtimeDir = await fs.mkdtemp(path.join(os.tmpdir(), "omp-daemon-smoke-run-"));
+	const client = await createDaemonBrokerClient(projectDir, { runtimeDir, idleGraceMs: 5_000 });
+	try {
+		const ping = await client.request({ op: "ping" });
+		if (ping.op !== "ping" || ping.projectDir !== client.projectDir) throw new Error("daemon broker ping mismatch");
+		await client.request({ op: "shutdown" });
+	} finally {
+		client.close();
+		await fs.rm(projectDir, { recursive: true, force: true });
+		await fs.rm(runtimeDir, { recursive: true, force: true });
+	}
+}

package/src/launch/paths.ts

@@ -0,0 +1,17 @@
+import * as path from "node:path";
+import { getConfigRootDir } from "@oh-my-pi/pi-utils";
+
+/** Resolve the private runtime directory shared by omp processes in one project directory. */
+export function daemonRuntimeDir(projectDir: string, configRoot: string = getConfigRootDir()): string {
+	const key = Bun.hash.wyhash(path.resolve(projectDir)).toString(16).padStart(16, "0");
+	return path.join(configRoot, "run", "daemons", key);
+}
+
+/** Resolve the Unix socket or Windows named pipe used by one project broker. */
+export function daemonBrokerEndpoint(projectDir: string, runtimeDir: string): string {
+	if (process.platform === "win32") {
+		const key = Bun.hash.wyhash(path.resolve(projectDir)).toString(16).padStart(16, "0");
+		return `\\\\.\\pipe\\omp-daemon-${key}`;
+	}
+	return path.join(runtimeDir, "broker.sock");
+}

package/src/launch/presence.ts

@@ -0,0 +1,82 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent, postmortem } from "@oh-my-pi/pi-utils";
+import { daemonRuntimeDir } from "./paths";
+
+const CLIENTS_DIR = "clients";
+
+/** Handle keeping one omp process registered in a project daemon scope. */
+export interface DaemonProjectPresence {
+	close(): Promise<void>;
+}
+
+async function canonicalProjectDir(projectDir: string): Promise<string> {
+	const resolved = path.resolve(projectDir);
+	try {
+		return await fs.realpath(resolved);
+	} catch (error) {
+		if (isEnoent(error)) return resolved;
+		throw error;
+	}
+}
+
+/** Register this omp process so project daemons survive while it remains alive. */
+export async function registerDaemonProjectPresence(
+	projectDir: string,
+	runtimeOverride?: string,
+): Promise<DaemonProjectPresence> {
+	const canonical = await canonicalProjectDir(projectDir);
+	const runtimeDir = runtimeOverride ?? daemonRuntimeDir(canonical);
+	const clientsDir = path.join(runtimeDir, CLIENTS_DIR);
+	await fs.mkdir(clientsDir, { recursive: true, mode: 0o700 });
+	const id = `${process.pid}-${crypto.randomUUID()}`;
+	const presencePath = path.join(clientsDir, `${id}.json`);
+	await Bun.write(presencePath, JSON.stringify({ pid: process.pid, id, projectDir: canonical }));
+	await fs.chmod(presencePath, 0o600);
+	let closed = false;
+	const close = async (): Promise<void> => {
+		if (closed) return;
+		closed = true;
+		cancelCleanup();
+		await fs.rm(presencePath, { force: true });
+	};
+	const cancelCleanup = postmortem.register(`daemon-presence:${id}`, () => close());
+	return { close };
+}
+
+/** Return whether a registered omp process in this runtime directory is still alive. */
+export async function hasLiveDaemonProjectPresence(runtimeDir: string): Promise<boolean> {
+	const clientsDir = path.join(runtimeDir, CLIENTS_DIR);
+	let entries: string[];
+	try {
+		entries = await fs.readdir(clientsDir);
+	} catch (error) {
+		if (isEnoent(error)) return false;
+		throw error;
+	}
+	let live = false;
+	for (const entry of entries) {
+		const presencePath = path.join(clientsDir, entry);
+		try {
+			const decoded: unknown = await Bun.file(presencePath).json();
+			if (
+				typeof decoded !== "object" ||
+				decoded === null ||
+				!("pid" in decoded) ||
+				typeof decoded.pid !== "number"
+			) {
+				await fs.rm(presencePath, { force: true });
+				continue;
+			}
+			try {
+				process.kill(decoded.pid, 0);
+				live = true;
+			} catch {
+				await fs.rm(presencePath, { force: true });
+			}
+		} catch (error) {
+			if (!isEnoent(error)) await fs.rm(presencePath, { force: true });
+		}
+	}
+	return live;
+}