zidane 7.2.4 → 8.0.4

package/dist/shell-path-Dqaoow2J.js

@@ -0,0 +1,412 @@
+import { a as errorResponse, o as successResponse, r as createJsonRpcConnection } from "./json-rpc--HXQti1E.js";
+import { D as legacySocketPath, O as probeSocket, c as IpcErrorCode, h as SIGNAL_SEQ_FIELD } from "./settings-keys-Ckf29NeM.js";
+import { d as connectIpcClient, p as createPacedWriter, t as createHostDispatcher } from "./dispatcher-BMlu2BmZ.js";
+import { Buffer } from "node:buffer";
+import { chmodSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { basename, delimiter, dirname } from "node:path";
+import { userInfo } from "node:os";
+import { spawn, spawnSync } from "node:child_process";
+import { createServer } from "node:net";
+import process from "node:process";
+function createRpcPeer(options) {
+	return {
+		ready: false,
+		watching: null,
+		send(signal, seq) {
+			const buffered = options.buffered();
+			const limit = options.highWatermark ?? 8388608;
+			if (buffered > limit) {
+				console.warn(`${options.label} peer buffered ${buffered} bytes (> ${limit}), closing the stuck connection`);
+				options.destroy();
+				return;
+			}
+			try {
+				options.rpc()?.sendNotification("ipc.signal", seq === void 0 ? signal : {
+					...signal,
+					[SIGNAL_SEQ_FIELD]: seq
+				});
+			} catch {}
+		}
+	};
+}
+/** The JSON-RPC handlers that route one peer's requests and notifications to the dispatcher. */
+function dispatcherHandlers(dispatcher, peer) {
+	return {
+		onRequest: async (message) => {
+			const outcome = await dispatcher.handleRequest(message.method, message.params, peer);
+			return outcome.ok ? successResponse(message.id, outcome.result) : errorResponse(message.id, outcome.code, outcome.message, outcome.data);
+		},
+		onNotification: (message) => dispatcher.handleNotification(message.method, message.params, peer)
+	};
+}
+//#endregion
+//#region src/ipc/transports/send-budget.ts
+function isReply(message) {
+	return "id" in message && message.id !== void 0 && message.id !== null && ("result" in message || "error" in message);
+}
+function createPeerSend(target, limits) {
+	const { maxBuffered, maxMessage, log, label } = limits;
+	let replyReserve = 0;
+	let stuck = false;
+	const markStuck = (why) => {
+		if (stuck) return;
+		stuck = true;
+		limits.stuck(why);
+	};
+	const backlog = () => {
+		const buffered = target.buffered();
+		replyReserve = Math.min(replyReserve, buffered);
+		return buffered - replyReserve;
+	};
+	const send = (json, message) => {
+		if (stuck) return;
+		if (!isReply(message)) {
+			if (!target.write(json) || backlog() > maxBuffered) markStuck(`more than ${maxBuffered} bytes of signals unsent`);
+			return;
+		}
+		let text = json;
+		let bytes = Buffer.byteLength(text);
+		if (bytes > maxMessage) {
+			const id = message.id;
+			log(`${label} reply to ${String(id)} is ${bytes} bytes (> ${maxMessage}): answering with an error instead`);
+			text = JSON.stringify(errorResponse(id, IpcErrorCode.ResponseTooLarge, `The reply is over ${maxMessage} bytes: ask for less (a transcript: a smaller page).`, {
+				bytes,
+				maxBytes: maxMessage
+			}));
+			bytes = Buffer.byteLength(text);
+		}
+		if (!target.write(text)) {
+			markStuck("reply dropped by the transport");
+			return;
+		}
+		replyReserve += bytes;
+		if (target.buffered() > maxBuffered + 2 * maxMessage) markStuck(`more than ${maxBuffered + 2 * maxMessage} bytes unsent`);
+	};
+	return {
+		backlog,
+		send,
+		markStuck
+	};
+}
+//#endregion
+//#region src/ipc/daemon/server.ts
+/**
+* Largest reply on the socket by default. Generous: the peer is this user's
+* own window on this machine, and whole-session reads (`sessions.get`) of a
+* long local session with images must keep fitting. The bound is there so
+* one reply cannot grow the write buffer without limit.
+*/
+const SOCKET_MAX_REPLY_BYTES = 268435456;
+async function startIpcDaemon(options) {
+	const { socketPath } = options;
+	const log = options.onLog ?? (() => void 0);
+	const startedAt = Date.now();
+	const appVersion = options.appVersion ?? "dev";
+	const maxBuffered = options.maxBufferedBytes ?? 8388608;
+	const maxMessage = options.maxMessageBytes ?? SOCKET_MAX_REPLY_BYTES;
+	const connections = /* @__PURE__ */ new Set();
+	let idleTimer;
+	let retiring = false;
+	let retireTimer;
+	const shared = options.dispatcher;
+	const dispatcher = shared ?? await createHostDispatcher({
+		...options.createEnvironment ? { createEnvironment: options.createEnvironment } : {},
+		appVersion,
+		startedAt,
+		identity: { kind: "daemon" },
+		lifecycle: {
+			shutdown: () => {
+				close().then(() => options.onIdle?.());
+			},
+			retireWhenIdle,
+			isRetiring: () => retiring
+		}
+	});
+	const host = dispatcher.host;
+	function retireWhenIdle() {
+		if (retiring) return;
+		retiring = true;
+		log("[ipc-daemon] a newer client attached mid-work; retiring once idle");
+		let idlePolls = 0;
+		retireTimer = setInterval(() => {
+			if (host.hasActiveWork()) {
+				idlePolls = 0;
+				return;
+			}
+			idlePolls += 1;
+			if (idlePolls < 2) return;
+			clearInterval(retireTimer);
+			close().then(() => options.onIdle?.());
+		}, 1e3);
+	}
+	function armIdleTimer() {
+		if (shared || !options.idleShutdownMs || !options.onIdle) return;
+		clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => {
+			if (dispatcher.peerCount() > 0) return;
+			if (host.hasActiveWork()) {
+				armIdleTimer();
+				return;
+			}
+			options.onIdle?.();
+		}, options.idleShutdownMs);
+	}
+	function handleConnection(socket) {
+		let connection;
+		const writer = createPacedWriter(socket);
+		const budget = createPeerSend({
+			buffered: writer.buffered,
+			write: (json) => {
+				writer.write(`${json}\n`);
+				return true;
+			}
+		}, {
+			maxBuffered,
+			maxMessage,
+			log,
+			label: "[ipc-daemon]",
+			stuck: (why) => {
+				log(`[ipc-daemon] dropping peer: ${why}`);
+				socket.destroy();
+			}
+		});
+		const peer = createRpcPeer({
+			buffered: budget.backlog,
+			destroy: () => budget.markStuck("not reading"),
+			rpc: () => connection,
+			label: "[ipc-daemon]",
+			highWatermark: maxBuffered
+		});
+		const rpc = createJsonRpcConnection({
+			input: socket,
+			output: socket,
+			send: budget.send,
+			...dispatcherHandlers(dispatcher, peer),
+			onError: (err) => log(`[ipc-daemon] peer error: ${err.message}`)
+		});
+		connection = rpc;
+		const entry = {
+			socket,
+			connection: rpc
+		};
+		connections.add(entry);
+		dispatcher.addPeer(peer);
+		rpc.start();
+		log(`[ipc-daemon] peer connected (${dispatcher.peerCount()} total)`);
+		const drop = () => {
+			if (!connections.delete(entry)) return;
+			rpc.close();
+			dispatcher.removePeer(peer);
+			log(`[ipc-daemon] peer disconnected (${dispatcher.peerCount()} left)`);
+			if (dispatcher.peerCount() === 0) armIdleTimer();
+		};
+		socket.on("close", drop);
+		socket.on("error", drop);
+	}
+	if (existsSync(socketPath)) {
+		if (await probeSocket(socketPath)) throw new Error(`A zidane daemon is already listening on ${socketPath}.`);
+		if (await probeSocket(socketPath)) throw new Error(`A zidane daemon is already listening on ${socketPath}.`);
+		unlinkSync(socketPath);
+	}
+	const socketDir = dirname(socketPath);
+	const dedicatedSocketDir = basename(socketDir) === "daemon" || !existsSync(socketDir);
+	mkdirSync(socketDir, {
+		recursive: true,
+		mode: 448
+	});
+	if (dedicatedSocketDir) try {
+		chmodSync(socketDir, 448);
+	} catch {}
+	const server = createServer(handleConnection);
+	await new Promise((resolvePromise, reject) => {
+		server.once("error", reject);
+		server.listen(socketPath, () => {
+			server.off("error", reject);
+			resolvePromise();
+		});
+	});
+	try {
+		chmodSync(socketPath, 384);
+	} catch {}
+	log(`[ipc-daemon] listening on ${socketPath}`);
+	let ownsSocketFile = true;
+	armIdleTimer();
+	const legacyPath = shared ? null : legacySocketPath(socketPath);
+	if (legacyPath) (async () => {
+		if (!await probeSocket(legacyPath)) return;
+		log(`[ipc-daemon] draining legacy daemon on ${legacyPath}`);
+		try {
+			const survivor = await connectIpcClient({
+				socketPath: legacyPath,
+				appVersion: `${appVersion}/legacy-drain`,
+				drainOnMismatch: true
+			});
+			await survivor.request("daemon.shutdown", {}).catch(() => void 0);
+			survivor.close();
+		} catch {}
+	})();
+	async function doClose() {
+		clearTimeout(idleTimer);
+		clearInterval(retireTimer);
+		if (!shared) await host.drain();
+		const stopped = new Promise((resolvePromise) => {
+			server.close(() => resolvePromise());
+		});
+		for (const { connection, socket } of connections) {
+			connection.close();
+			socket.destroy();
+		}
+		connections.clear();
+		if (!shared) dispatcher.detachAll();
+		await stopped;
+		if (ownsSocketFile) {
+			ownsSocketFile = false;
+			try {
+				unlinkSync(socketPath);
+			} catch {}
+		}
+	}
+	let closePromise = null;
+	function close() {
+		closePromise ??= doClose();
+		return closePromise;
+	}
+	return {
+		socketPath,
+		host,
+		peerCount: () => dispatcher.peerCount(),
+		close
+	};
+}
+//#endregion
+//#region src/ipc/daemon/shell-path.ts
+/**
+* Login-shell PATH for processes not started from a terminal.
+*
+* A Dock/Finder-launched GUI, or a daemon it spawns, inherits launchd's PATH
+* (`/usr/bin:/bin:/usr/sbin:/sbin`), so `node` / `bun` / `yarn` are invisible
+* to agent shell commands. Ask the user's login shell for its PATH and merge
+* it into `process.env.PATH`.
+*
+* Merge, don't replace: a terminal launch may have prepended entries the rc
+* files know nothing about (`nvm use`, direnv, `PATH=... zidane`), and those
+* must survive. Idempotent, so every surface (GUI, daemon) can call it and a
+* daemon spawned by an already-fixed GUI ends up with the same PATH.
+*/
+const DELIMITER = "_ZIDANE_SHELL_ENV_";
+/** A slow rc file costs startup time; a prompting one must never hang the process. */
+const DEFAULT_TIMEOUT_MS = 3e3;
+function defaultShell(env) {
+	try {
+		const { shell } = userInfo();
+		if (shell) return shell;
+	} catch {}
+	return env.SHELL || (process.platform === "darwin" ? "/bin/zsh" : "/bin/sh");
+}
+function parsePath(stdout) {
+	const body = stdout.split(DELIMITER)[1];
+	if (body === void 0) return void 0;
+	const clean = body.replace(/\u001B\[[0-9;]*[A-Z]/gi, "");
+	for (const line of clean.split("\n")) if (line.startsWith("PATH=")) return line.slice(5) || void 0;
+}
+const SHELL_ARGS = ["-ilc", `echo -n "${DELIMITER}"; command env; echo -n "${DELIMITER}"; exit`];
+function shellCandidates(options) {
+	const env = options.env ?? process.env;
+	return {
+		shells: options.shell ? [options.shell] : [.../* @__PURE__ */ new Set([
+			defaultShell(env),
+			"/bin/zsh",
+			"/bin/bash"
+		])],
+		timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+		env: {
+			...env,
+			DISABLE_AUTO_UPDATE: "true",
+			ZSH_TMUX_AUTOSTARTED: "true",
+			ZSH_TMUX_AUTOSTART: "false"
+		}
+	};
+}
+function shellPath(options = {}) {
+	if (process.platform === "win32") return void 0;
+	const { shells, env, timeout } = shellCandidates(options);
+	for (const shell of shells) {
+		const result = spawnSync(shell, SHELL_ARGS, {
+			encoding: "utf8",
+			timeout,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			env
+		});
+		if (result.error || result.status !== 0) continue;
+		const path = parsePath(result.stdout);
+		if (path) return path;
+	}
+}
+/**
+* {@link shellPath} without blocking the event loop: same shells, args,
+* timeout and parsing, run with `spawn`. For hosts (the GUI main
+* process) that can start on a cached PATH and refresh in the background.
+*/
+async function shellPathAsync(options = {}) {
+	if (process.platform === "win32") return void 0;
+	const { shells, env, timeout } = shellCandidates(options);
+	for (const shell of shells) {
+		const stdout = await new Promise((resolve) => {
+			const child = spawn(shell, SHELL_ARGS, {
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				],
+				env
+			});
+			let out = "";
+			let settled = false;
+			let timer;
+			const finish = (value) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(value);
+			};
+			timer = setTimeout(() => {
+				child.kill("SIGTERM");
+				finish(void 0);
+			}, timeout);
+			child.stdout?.setEncoding("utf8");
+			child.stdout?.on("data", (chunk) => {
+				out += chunk;
+			});
+			child.on("error", () => finish(void 0));
+			child.on("close", (code) => finish(code === 0 ? out : void 0));
+		});
+		if (stdout === void 0) continue;
+		const path = parsePath(stdout);
+		if (path) return path;
+	}
+}
+/**
+* Entries of `current` the shell doesn't know about (ad-hoc prepends from the
+* launching terminal) stay in front; then the shell's PATH in its own order.
+* From the Dock every launchd entry is already in the shell PATH, so the
+* result is exactly the shell PATH, with the shell's precedence intact.
+*/
+function mergePath(current, shell) {
+	const split = (path) => (path ?? "").split(delimiter).filter(Boolean);
+	const fromShell = split(shell);
+	const known = new Set(fromShell);
+	return [.../* @__PURE__ */ new Set([...split(current).filter((entry) => !known.has(entry)), ...fromShell])].join(delimiter);
+}
+/** Merge the login shell's PATH into `process.env.PATH`. No-op on Windows or when no shell answers. */
+function fixPath() {
+	const extra = shellPath();
+	if (extra) process.env.PATH = mergePath(process.env.PATH, extra);
+}
+//#endregion
+export { startIpcDaemon as a, shellPathAsync as i, mergePath as n, shellPath as r, fixPath as t };
+
+//# sourceMappingURL=shell-path-Dqaoow2J.js.map

package/dist/shell-path-Dqaoow2J.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-path-Dqaoow2J.js","names":[],"sources":["../src/ipc/transports/peer-rpc.ts","../src/ipc/transports/send-budget.ts","../src/ipc/daemon/server.ts","../src/ipc/daemon/shell-path.ts"],"sourcesContent":["/**\n * The host side of one JSON-RPC connection, for every wire transport (the\n * unix socket in `../daemon/server.ts`, the WebSocket in `./ws-server.ts`):\n * a dispatcher {@link HostPeer} whose signals go out as `ipc.signal`\n * notifications with a write-backpressure bound, and the request /\n * notification handlers that hand incoming messages to the dispatcher.\n * Framing stays with the transport.\n */\nimport type { JsonRpcConnectionOptions } from '../../acp/json-rpc'\nimport type { AcpPeer, JsonRpcRequest, JsonRpcResponse } from '../../acp/types'\nimport type { HostDispatcher, HostPeer } from '../daemon/dispatcher'\nimport { errorResponse, successResponse } from '../../acp/json-rpc'\nimport { SIGNAL_SEQ_FIELD } from '../protocol'\n\n/**\n * Per-peer write backpressure bound. A wedged peer (e.g. a SIGSTOP'd\n * terminal) stops reading, so fan-out writes pile up in the transport's\n * send buffer without bound and can OOM the host. A peer buffering more\n * than this is dropped: the protocol supports re-attach + backfill, so\n * killing a wedged peer is safe and self-healing.\n */\nexport const PEER_WRITE_HIGH_WATERMARK = 8 * 1024 * 1024\n\nexport interface RpcPeerOptions {\n  /** Bytes written to the peer but not yet sent. */\n  buffered: () => number\n  /** Tear the connection down (its close handler removes the peer). */\n  destroy: () => void\n  /** The connection's JSON-RPC side; signals are dropped until it exists. */\n  rpc: () => Pick<AcpPeer, 'sendNotification'> | undefined\n  /** Log prefix, e.g. `[ipc-daemon]`. */\n  label: string\n  /** Drop the peer past this many buffered bytes. Default {@link PEER_WRITE_HIGH_WATERMARK}. */\n  highWatermark?: number\n}\n\nexport function createRpcPeer(options: RpcPeerOptions): HostPeer {\n  return {\n    ready: false,\n    watching: null,\n    send(signal, seq) {\n      const buffered = options.buffered()\n      const limit = options.highWatermark ?? PEER_WRITE_HIGH_WATERMARK\n      if (buffered > limit) {\n        console.warn(`${options.label} peer buffered ${buffered} bytes (> ${limit}), closing the stuck connection`)\n        options.destroy()\n        return\n      }\n      try {\n        options.rpc()?.sendNotification('ipc.signal', seq === undefined ? signal : { ...signal, [SIGNAL_SEQ_FIELD]: seq })\n      }\n      catch {\n        // A dying connection (or a signal JSON can't encode) must never take the host down with it.\n      }\n    },\n  }\n}\n\n/** The JSON-RPC handlers that route one peer's requests and notifications to the dispatcher. */\nexport function dispatcherHandlers(dispatcher: HostDispatcher, peer: HostPeer): Pick<JsonRpcConnectionOptions, 'onRequest' | 'onNotification'> {\n  return {\n    onRequest: async (message: JsonRpcRequest): Promise<JsonRpcResponse> => {\n      const outcome = await dispatcher.handleRequest(message.method, message.params, peer)\n      return outcome.ok\n        ? successResponse(message.id, outcome.result)\n        : errorResponse(message.id, outcome.code, outcome.message, outcome.data)\n    },\n    onNotification: message => dispatcher.handleNotification(message.method, message.params, peer),\n  }\n}\n","/**\n * One connection's outgoing budget, for every wire transport (the unix\n * socket in `../daemon/server.ts`, the WebSocket in `./ws-server.ts`).\n *\n * The slow-consumer bound is about pushed signals piling up for a peer that\n * stopped reading, not about one big reply it asked for: reply bytes still\n * queued are set aside (`replyReserve`) when the backlog is measured. The\n * buffer drains in order, so the reserve can only shrink to what is still\n * buffered; a peer that never reads keeps it whole and is dropped once the\n * signals behind it pass the bound. A reply itself is bounded by the message\n * size (over it, an `IpcErrorCode.ResponseTooLarge` error goes instead and\n * the connection stays), and the whole buffer by a hard cap for memory.\n *\n * The reserve is an approximation: it assumes the buffer drains oldest\n * first and only clamps it to what is still buffered, so after a partial\n * drain it may still count reply bytes that already left, and the signals\n * backlog reads low by at most that much. The memory bound, precisely: a\n * reply leaves the whole buffer at most `H = maxBuffered + 2 × maxMessage`\n * (checked after its write), and every signal re-clamps the reserve to what\n * is buffered, so the reserve never exceeds what the buffer held at the\n * first signal after the last reply (at most `H` plus that signal). A\n * signal leaves the measured backlog at most `maxBuffered`, so between\n * sends a peer holds at most `maxBuffered + H = 2 × maxBuffered + 2 ×\n * maxMessage` bytes (plus one signal). The write that crosses a bound is\n * the last: the peer is marked stuck and nothing more goes out.\n */\nimport type { JsonRpcMessage } from '../../acp/types'\nimport { Buffer } from 'node:buffer'\nimport { errorResponse } from '../../acp/json-rpc'\nimport { IpcErrorCode } from '../protocol'\n\n/** What the budget writes to: the transport's buffer and its framing. */\nexport interface SendTarget {\n  /** Bytes written but not yet handed to the OS. */\n  buffered: () => number\n  /** Write one serialized message (the target frames it); `false`: the transport dropped it. */\n  write: (json: string) => boolean\n}\n\nexport interface SendLimits {\n  /** Signals backlog past which the peer is stuck (replies set aside). */\n  maxBuffered: number\n  /** Largest reply; a bigger one is answered with `ResponseTooLarge`. */\n  maxMessage: number\n  /** The peer cannot keep up: tear it down (called once). */\n  stuck: (why: string) => void\n  log: (line: string) => void\n  /** Log prefix, e.g. `[ipc-ws]`. */\n  label: string\n}\n\nexport interface PeerSend {\n  /** Bytes buffered that are not reply bytes: what the slow-consumer bound measures. */\n  backlog: () => number\n  /** Send one message (the JSON-RPC endpoint's `send`): replies and the rest apart. */\n  send: (json: string, message: JsonRpcMessage) => void\n  /** Give up on the peer (once): {@link SendLimits.stuck} runs and nothing more goes out. */\n  markStuck: (why: string) => void\n}\n\nfunction isReply(message: JsonRpcMessage): boolean {\n  return 'id' in message && message.id !== undefined && message.id !== null && ('result' in message || 'error' in message)\n}\n\nexport function createPeerSend(target: SendTarget, limits: SendLimits): PeerSend {\n  const { maxBuffered, maxMessage, log, label } = limits\n  let replyReserve = 0\n  let stuck = false\n  const markStuck = (why: string): void => {\n    if (stuck)\n      return\n    stuck = true\n    limits.stuck(why)\n  }\n  const backlog = (): number => {\n    const buffered = target.buffered()\n    replyReserve = Math.min(replyReserve, buffered)\n    return buffered - replyReserve\n  }\n  const send = (json: string, message: JsonRpcMessage): void => {\n    if (stuck)\n      return\n    if (!isReply(message)) {\n      if (!target.write(json) || backlog() > maxBuffered)\n        markStuck(`more than ${maxBuffered} bytes of signals unsent`)\n      return\n    }\n    let text = json\n    let bytes = Buffer.byteLength(text)\n    if (bytes > maxMessage) {\n      const id = (message as { id: string | number }).id\n      log(`${label} reply to ${String(id)} is ${bytes} bytes (> ${maxMessage}): answering with an error instead`)\n      text = JSON.stringify(errorResponse(id, IpcErrorCode.ResponseTooLarge, `The reply is over ${maxMessage} bytes: ask for less (a transcript: a smaller page).`, { bytes, maxBytes: maxMessage }))\n      bytes = Buffer.byteLength(text)\n    }\n    if (!target.write(text)) {\n      markStuck('reply dropped by the transport')\n      return\n    }\n    replyReserve += bytes\n    if (target.buffered() > maxBuffered + 2 * maxMessage)\n      markStuck(`more than ${maxBuffered + 2 * maxMessage} bytes unsent`)\n  }\n  return { backlog, send, markStuck }\n}\n","/**\n * Unix-socket JSON-RPC server around a `ChatHost`.\n *\n * One `net.Server`, one JSON-RPC connection per peer (NDJSON framing: a\n * `net.Socket` is both the Readable and the Writable). The method table,\n * per-peer state, signal fan-out and the `ipc.hello` handshake live in the\n * transport-free dispatcher (`./dispatcher`); this module owns only what is\n * specific to the socket and the process: framing, the socket file and its\n * permissions, idle exit, retiring, and draining. Write backpressure (the\n * slow-consumer bound, the reply size) is shared with the WebSocket server\n * (`../transports/send-budget`).\n *\n * Handshake: a peer's first request MUST be `ipc.hello` carrying its\n * protocol version. Mismatched peers get a structured error (code\n * `VERSION_MISMATCH`) and can ask the daemon to drain via `daemon.shutdown`\n * before respawning a fresh one.\n */\nimport type { Server, Socket } from 'node:net'\nimport type { JsonRpcConnection } from '../../acp/json-rpc'\nimport type { ChatHost } from '../../chat/host/engine'\nimport type { HostSignal } from '../protocol'\nimport type { HostDispatcher } from './dispatcher'\nimport type { DaemonEnvironment } from './environment'\nimport { chmodSync, existsSync, mkdirSync, unlinkSync } from 'node:fs'\nimport { createServer } from 'node:net'\nimport { basename, dirname } from 'node:path'\nimport { createJsonRpcConnection } from '../../acp/json-rpc'\nimport { connectIpcClient } from '../client'\nimport { createPacedWriter } from '../transports/paced-writer'\nimport { createRpcPeer, dispatcherHandlers, PEER_WRITE_HIGH_WATERMARK } from '../transports/peer-rpc'\nimport { createPeerSend } from '../transports/send-budget'\nimport { createHostDispatcher } from './dispatcher'\nimport { legacySocketPath, probeSocket } from './lifecycle'\n\n// Canonical home is the protocol module (clients import the codes without\n// pulling the server's module graph); re-exported here for compatibility.\nexport { IpcErrorCode } from '../protocol'\n\nexport interface IpcDaemonOptions {\n  socketPath: string\n  /**\n   * Environment factory — the production daemon uses the disk-backed\n   * `createDaemonEnvironment`; tests inject an in-memory one. Receives the\n   * broadcast sink wired to peer fan-out.\n   */\n  createEnvironment?: (broadcast: (signal: HostSignal) => void) => DaemonEnvironment | Promise<DaemonEnvironment>\n  appVersion?: string\n  /**\n   * Called when the daemon has had zero peers for `idleShutdownMs` and no\n   * session is running. The CLI exits the process; embedded servers ignore.\n   */\n  idleShutdownMs?: number\n  onIdle?: () => void\n  onLog?: (line: string) => void\n  /**\n   * Serve this already-built host instead of creating one: another front-end\n   * (zidane-server's WebSocket) serves it too. Its owner drains it and owns\n   * its lifecycle, so `createEnvironment`, `appVersion` and the idle options\n   * are ignored, and `close()` only closes this socket's connections.\n   */\n  dispatcher?: HostDispatcher\n  /**\n   * A peer with more than this of signals queued for sending (it stopped\n   * reading) is dropped; it re-attaches and resumes. Replies are bounded by\n   * `maxMessageBytes` instead (`../transports/send-budget`). Default\n   * `PEER_WRITE_HIGH_WATERMARK` (8 MiB).\n   */\n  maxBufferedBytes?: number\n  /** A bigger reply goes out as an `IpcErrorCode.ResponseTooLarge` error. Default {@link SOCKET_MAX_REPLY_BYTES}. */\n  maxMessageBytes?: number\n}\n\n/**\n * Largest reply on the socket by default. Generous: the peer is this user's\n * own window on this machine, and whole-session reads (`sessions.get`) of a\n * long local session with images must keep fitting. The bound is there so\n * one reply cannot grow the write buffer without limit.\n */\nconst SOCKET_MAX_REPLY_BYTES = 256 * 1024 * 1024\n\nexport interface IpcDaemon {\n  socketPath: string\n  host: ChatHost\n  peerCount: () => number\n  close: () => Promise<void>\n}\n\n/** One open socket connection; `close()` ends them all. */\ninterface SocketConnection {\n  socket: Socket\n  connection: JsonRpcConnection\n}\n\nexport async function startIpcDaemon(options: IpcDaemonOptions): Promise<IpcDaemon> {\n  const { socketPath } = options\n  const log = options.onLog ?? (() => undefined)\n  const startedAt = Date.now()\n  const appVersion = options.appVersion ?? 'dev'\n  const maxBuffered = options.maxBufferedBytes ?? PEER_WRITE_HIGH_WATERMARK\n  const maxMessage = options.maxMessageBytes ?? SOCKET_MAX_REPLY_BYTES\n\n  const connections = new Set<SocketConnection>()\n  let idleTimer: ReturnType<typeof setTimeout> | undefined\n  // See `retireWhenIdle`.\n  let retiring = false\n  let retireTimer: ReturnType<typeof setInterval> | undefined\n\n  const shared = options.dispatcher\n  const dispatcher = shared ?? await createHostDispatcher({\n    ...(options.createEnvironment ? { createEnvironment: options.createEnvironment } : {}),\n    appVersion,\n    startedAt,\n    identity: { kind: 'daemon' },\n    lifecycle: {\n      shutdown: () => {\n        void close().then(() => options.onIdle?.())\n      },\n      retireWhenIdle,\n      isRetiring: () => retiring,\n    },\n  })\n  const host = dispatcher.host\n\n  /* ----------------------------------------------------------------------\n   * Socket plumbing\n   * -------------------------------------------------------------------- */\n\n  /*\n   * Retire-when-idle: a NEWER client found this daemon mid-work. Draining\n   * now would abort every window's runs (a dev edit under `src/ipc` or an\n   * upgrade mid-`/review` did exactly that), so keep serving and exit at\n   * the first idle point. Two consecutive idle polls: a queue drain is\n   * scheduled just after a dispatch releases, and one poll could land in\n   * that gap.\n   */\n  function retireWhenIdle(): void {\n    if (retiring)\n      return\n    retiring = true\n    log('[ipc-daemon] a newer client attached mid-work; retiring once idle')\n    let idlePolls = 0\n    retireTimer = setInterval(() => {\n      if (host.hasActiveWork()) {\n        idlePolls = 0\n        return\n      }\n      idlePolls += 1\n      if (idlePolls < 2)\n        return\n      clearInterval(retireTimer)\n      void close().then(() => options.onIdle?.())\n    }, 1000)\n  }\n\n  function armIdleTimer(): void {\n    if (shared || !options.idleShutdownMs || !options.onIdle)\n      return\n    clearTimeout(idleTimer)\n    idleTimer = setTimeout(() => {\n      if (dispatcher.peerCount() > 0)\n        return // Peers reconnected — the next last-disconnect re-arms.\n      /*\n       * Never abort a live run just because every window detached — `/exit`\n       * is explicitly \"the run keeps going\". Re-arm and check again later.\n       */\n      if (host.hasActiveWork()) {\n        armIdleTimer()\n        return\n      }\n      options.onIdle?.()\n    }, options.idleShutdownMs)\n  }\n\n  function handleConnection(socket: Socket): void {\n    // Assigned right below; a signal can only reach this peer after `ipc.hello`, i.e. once it is set.\n    let connection: JsonRpcConnection | undefined\n    const writer = createPacedWriter(socket)\n    const budget = createPeerSend(\n      {\n        buffered: writer.buffered,\n        // NDJSON: `JSON.stringify` escapes newlines, so a message is one line.\n        write: (json) => {\n          writer.write(`${json}\\n`)\n          return true\n        },\n      },\n      {\n        maxBuffered,\n        maxMessage,\n        log,\n        label: '[ipc-daemon]',\n        stuck: (why) => {\n          log(`[ipc-daemon] dropping peer: ${why}`)\n          socket.destroy()\n        },\n      },\n    )\n    const peer = createRpcPeer({\n      buffered: budget.backlog,\n      destroy: () => budget.markStuck('not reading'),\n      rpc: () => connection,\n      label: '[ipc-daemon]',\n      highWatermark: maxBuffered,\n    })\n\n    const rpc = createJsonRpcConnection({\n      input: socket,\n      output: socket,\n      send: budget.send,\n      ...dispatcherHandlers(dispatcher, peer),\n      onError: err => log(`[ipc-daemon] peer error: ${err.message}`),\n    })\n\n    connection = rpc\n    const entry: SocketConnection = { socket, connection: rpc }\n    connections.add(entry)\n    dispatcher.addPeer(peer)\n    rpc.start()\n    log(`[ipc-daemon] peer connected (${dispatcher.peerCount()} total)`)\n\n    const drop = (): void => {\n      if (!connections.delete(entry))\n        return\n      rpc.close()\n      dispatcher.removePeer(peer)\n      log(`[ipc-daemon] peer disconnected (${dispatcher.peerCount()} left)`)\n      if (dispatcher.peerCount() === 0)\n        armIdleTimer()\n    }\n\n    socket.on('close', drop)\n    socket.on('error', drop)\n  }\n\n  /*\n   * Stale-socket recovery: a previous daemon that died without cleanup\n   * leaves the socket file behind and `listen` would fail EADDRINUSE.\n   * Probe before unlinking so a LIVE daemon is never yanked out from\n   * under its peers.\n   */\n  if (existsSync(socketPath)) {\n    if (await probeSocket(socketPath))\n      throw new Error(`A zidane daemon is already listening on ${socketPath}.`)\n    /*\n     * Narrow the concurrent-spawn race: another daemon may have bound the\n     * socket between the probe above and the unlink below (each probe is a\n     * full connect attempt). Re-probe immediately before unlinking and\n     * abort startup if something now answers — never yank a live daemon's\n     * socket out from under its peers.\n     */\n    if (await probeSocket(socketPath))\n      throw new Error(`A zidane daemon is already listening on ${socketPath}.`)\n    unlinkSync(socketPath)\n  }\n  /*\n   * The daemon speaks an unauthenticated RPC surface that can execute tools\n   * as the daemon user — restrict access to the owner. The containing dir\n   * is created 0700 (belt) and the socket is chmod'd to 0600 right after\n   * `listen` (suspenders) so connectability never depends on ambient umask.\n   *\n   * `mkdirSync`'s mode only applies on CREATION — a pre-existing dir keeps\n   * its old mode. When the dir is the DEDICATED daemon dir (the `daemon/`\n   * subdir `defaultSocketPath` uses, or one we created fresh for an\n   * explicit socket path) chmod it 0700 explicitly. A shared, pre-existing\n   * dir (tests pointing the socket at a tmpdir) is left alone — never\n   * tighten a directory that also holds unrelated state.\n   */\n  const socketDir = dirname(socketPath)\n  const dedicatedSocketDir = basename(socketDir) === 'daemon' || !existsSync(socketDir)\n  mkdirSync(socketDir, { recursive: true, mode: 0o700 })\n  if (dedicatedSocketDir) {\n    try {\n      chmodSync(socketDir, 0o700)\n    }\n    catch {\n      // Best-effort — mirrors the socket chmod below.\n    }\n  }\n\n  const server: Server = createServer(handleConnection)\n  await new Promise<void>((resolvePromise, reject) => {\n    server.once('error', reject)\n    server.listen(socketPath, () => {\n      server.off('error', reject)\n      resolvePromise()\n    })\n  })\n  try {\n    chmodSync(socketPath, 0o600)\n  }\n  catch {\n    // Best-effort on platforms where socket chmod is a no-op (e.g. some\n    // network filesystems); the 0700 dir still constrains access.\n  }\n  log(`[ipc-daemon] listening on ${socketPath}`)\n  // We bound the socket, so we own the file — close() unlinks it exactly\n  // once. Cleared after the unlink so a file later re-created by a NEW\n  // daemon on the same path is never yanked by a stale close.\n  let ownsSocketFile = true\n  armIdleTimer()\n\n  /*\n   * One-time v6 migration: drain any daemon still serving the pre-v6\n   * socket path (`<stateDir>/daemon.sock`). New clients never probe it,\n   * so a `--idle-exit 0` service daemon there would run forever alongside\n   * this one — two sets of live agents, run guards, and heartbeat writers\n   * against the same sessions.db. Fire-and-forget: version mismatch is\n   * the EXPECTED case (a legacy daemon speaks an older protocol) and\n   * `drainOnMismatch: true` performs the shutdown for us; a same-version\n   * survivor (explicit env overrides) gets an explicit daemon.shutdown.\n   */\n  const legacyPath = shared ? null : legacySocketPath(socketPath)\n  if (legacyPath) {\n    void (async () => {\n      if (!(await probeSocket(legacyPath)))\n        return\n      log(`[ipc-daemon] draining legacy daemon on ${legacyPath}`)\n      try {\n        const survivor = await connectIpcClient({ socketPath: legacyPath, appVersion: `${appVersion}/legacy-drain`, drainOnMismatch: true })\n        await survivor.request('daemon.shutdown', {}).catch(() => undefined)\n        survivor.close()\n      }\n      catch {\n        // IpcVersionMismatchError = drained by the handshake path; anything\n        // else (raced exit, wedged socket) is best-effort — leave it.\n      }\n    })()\n  }\n\n  async function doClose(): Promise<void> {\n    clearTimeout(idleTimer)\n    clearInterval(retireTimer)\n    // A shared host is its owner's to drain and detach (see `dispatcher`).\n    if (!shared)\n      await host.drain()\n    // Stop accepting before closing what is open: a connection landing in\n    // between would otherwise keep `server.close` waiting forever.\n    const stopped = new Promise<void>((resolvePromise) => {\n      server.close(() => resolvePromise())\n    })\n    for (const { connection, socket } of connections) {\n      connection.close()\n      socket.destroy()\n    }\n    connections.clear()\n    if (!shared)\n      dispatcher.detachAll()\n    await stopped\n    if (ownsSocketFile) {\n      ownsSocketFile = false\n      try {\n        unlinkSync(socketPath)\n      }\n      catch {\n        // already gone\n      }\n    }\n  }\n\n  /*\n   * Idempotent close: `daemon.shutdown` runs close() and then onIdle, whose\n   * CLI implementation calls daemon.close() again — both callers share one\n   * drain instead of double-unlinking the socket. Memoized rather than\n   * flag-guarded so the second caller awaits actual completion.\n   */\n  let closePromise: Promise<void> | null = null\n  function close(): Promise<void> {\n    closePromise ??= doClose()\n    return closePromise\n  }\n\n  return {\n    socketPath,\n    host,\n    peerCount: () => dispatcher.peerCount(),\n    close,\n  }\n}\n","/**\n * Login-shell PATH for processes not started from a terminal.\n *\n * A Dock/Finder-launched GUI, or a daemon it spawns, inherits launchd's PATH\n * (`/usr/bin:/bin:/usr/sbin:/sbin`), so `node` / `bun` / `yarn` are invisible\n * to agent shell commands. Ask the user's login shell for its PATH and merge\n * it into `process.env.PATH`.\n *\n * Merge, don't replace: a terminal launch may have prepended entries the rc\n * files know nothing about (`nvm use`, direnv, `PATH=... zidane`), and those\n * must survive. Idempotent, so every surface (GUI, daemon) can call it and a\n * daemon spawned by an already-fixed GUI ends up with the same PATH.\n */\nimport { spawn, spawnSync } from 'node:child_process'\nimport { userInfo } from 'node:os'\nimport { delimiter } from 'node:path'\nimport process from 'node:process'\n\nconst DELIMITER = '_ZIDANE_SHELL_ENV_'\n\n/** A slow rc file costs startup time; a prompting one must never hang the process. */\nconst DEFAULT_TIMEOUT_MS = 3_000\n\nfunction defaultShell(env: NodeJS.ProcessEnv): string {\n  try {\n    const { shell } = userInfo()\n    if (shell)\n      return shell\n  }\n  catch {}\n  return env.SHELL || (process.platform === 'darwin' ? '/bin/zsh' : '/bin/sh')\n}\n\nfunction parsePath(stdout: string): string | undefined {\n  const body = stdout.split(DELIMITER)[1]\n  if (body === undefined)\n    return undefined\n  // eslint-disable-next-line no-control-regex\n  const clean = body.replace(/\\u001B\\[[0-9;]*[A-Z]/gi, '')\n  for (const line of clean.split('\\n')) {\n    if (line.startsWith('PATH='))\n      return line.slice('PATH='.length) || undefined\n  }\n  return undefined\n}\n\n/**\n * PATH as seen by an interactive login shell, or `undefined` when no shell\n * answers in time. Tries the user's shell first, then POSIX fallbacks for\n * non-POSIX defaults (nushell, xonsh) whose `-ilc` differs. An explicit\n * `shell` is tried alone.\n */\nexport interface ShellPathOptions { env?: NodeJS.ProcessEnv, timeoutMs?: number, shell?: string }\n\n// `command env` sidesteps aliases/functions named `env`.\nconst SHELL_ARGS = ['-ilc', `echo -n \"${DELIMITER}\"; command env; echo -n \"${DELIMITER}\"; exit`]\n\nfunction shellCandidates(options: ShellPathOptions): { shells: string[], env: NodeJS.ProcessEnv, timeout: number } {\n  const env = options.env ?? process.env\n  return {\n    shells: options.shell ? [options.shell] : [...new Set([defaultShell(env), '/bin/zsh', '/bin/bash'])],\n    timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n    env: {\n      ...env,\n      // Keep oh-my-zsh from blocking on its update prompt / tmux autostart.\n      DISABLE_AUTO_UPDATE: 'true',\n      ZSH_TMUX_AUTOSTARTED: 'true',\n      ZSH_TMUX_AUTOSTART: 'false',\n    },\n  }\n}\n\nexport function shellPath(options: ShellPathOptions = {}): string | undefined {\n  if (process.platform === 'win32')\n    return undefined\n  const { shells, env, timeout } = shellCandidates(options)\n  for (const shell of shells) {\n    const result = spawnSync(shell, SHELL_ARGS, {\n      encoding: 'utf8',\n      timeout,\n      stdio: ['ignore', 'pipe', 'ignore'],\n      env,\n    })\n    if (result.error || result.status !== 0)\n      continue\n    const path = parsePath(result.stdout)\n    if (path)\n      return path\n  }\n  return undefined\n}\n\n/**\n * {@link shellPath} without blocking the event loop: same shells, args,\n * timeout and parsing, run with `spawn`. For hosts (the GUI main\n * process) that can start on a cached PATH and refresh in the background.\n */\nexport async function shellPathAsync(options: ShellPathOptions = {}): Promise<string | undefined> {\n  if (process.platform === 'win32')\n    return undefined\n  const { shells, env, timeout } = shellCandidates(options)\n  for (const shell of shells) {\n    const stdout = await new Promise<string | undefined>((resolve) => {\n      // Same stdio as the sync variant: no stdin, stderr discarded.\n      const child = spawn(shell, SHELL_ARGS, { stdio: ['ignore', 'pipe', 'ignore'], env })\n      let out = ''\n      let settled = false\n      let timer: ReturnType<typeof setTimeout> | undefined\n      const finish = (value: string | undefined): void => {\n        if (settled)\n          return\n        settled = true\n        clearTimeout(timer)\n        resolve(value)\n      }\n      timer = setTimeout(() => {\n        child.kill('SIGTERM')\n        finish(undefined)\n      }, timeout)\n      child.stdout?.setEncoding('utf8')\n      child.stdout?.on('data', (chunk: string) => {\n        out += chunk\n      })\n      child.on('error', () => finish(undefined))\n      child.on('close', code => finish(code === 0 ? out : undefined))\n    })\n    if (stdout === undefined)\n      continue\n    const path = parsePath(stdout)\n    if (path)\n      return path\n  }\n  return undefined\n}\n\n/**\n * Entries of `current` the shell doesn't know about (ad-hoc prepends from the\n * launching terminal) stay in front; then the shell's PATH in its own order.\n * From the Dock every launchd entry is already in the shell PATH, so the\n * result is exactly the shell PATH, with the shell's precedence intact.\n */\nexport function mergePath(current: string | undefined, shell: string | undefined): string {\n  const split = (path: string | undefined): string[] => (path ?? '').split(delimiter).filter(Boolean)\n  const fromShell = split(shell)\n  const known = new Set(fromShell)\n  return [...new Set([...split(current).filter(entry => !known.has(entry)), ...fromShell])].join(delimiter)\n}\n\n/** Merge the login shell's PATH into `process.env.PATH`. No-op on Windows or when no shell answers. */\nexport function fixPath(): void {\n  const extra = shellPath()\n  if (extra)\n    process.env.PATH = mergePath(process.env.PATH, extra)\n}\n"],"mappings":"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"}