opentray 0.1.0 → 0.2.0

package/dist/client-COyxXT9C.d.mts

@@ -0,0 +1,29 @@
+import { ClientFrame, ClientRequestFrame, RequestId, ServerFrame, SurfaceOptions, SurfaceRef, TrayId, TrayOptions } from "@opentray/spec";
+
+//#region src/client.d.ts
+interface OpenTrayTransport {
+  request(frame: ClientRequestFrame): Promise<ServerFrame>;
+}
+interface OpenTrayClient {
+  createSurface(options: SurfaceOptions): Promise<SurfaceHandle>;
+}
+interface SurfaceHandle {
+  surface: SurfaceRef;
+  createTray(options: TrayOptions): Promise<TrayHandle>;
+}
+interface TrayHandle {
+  surface: SurfaceRef;
+  trayId: TrayId;
+  commandExtension(ext: string, data: unknown): Promise<void>;
+  destroy(): Promise<void>;
+}
+declare const createInitFrame: (clientVersion: string) => ClientFrame;
+interface CreateClientOptions {
+  requestIdPrefix?: string;
+}
+declare const createClient: (transport: OpenTrayTransport, options?: CreateClientOptions) => OpenTrayClient;
+declare const createSurfaceHandle: (transport: OpenTrayTransport, surface: SurfaceRef, nextRequestId?: () => RequestId) => SurfaceHandle;
+declare const createTrayHandle: (transport: OpenTrayTransport, surface: SurfaceRef, trayId: TrayId, nextRequestId?: () => RequestId) => TrayHandle;
+//#endregion
+export { TrayHandle as a, createSurfaceHandle as c, SurfaceHandle as i, createTrayHandle as l, OpenTrayClient as n, createClient as o, OpenTrayTransport as r, createInitFrame as s, CreateClientOptions as t };
+//# sourceMappingURL=client-COyxXT9C.d.mts.map

package/dist/client-COyxXT9C.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-COyxXT9C.d.mts","names":[],"sources":["../src/client.ts"],"mappings":";;;UAYiB,iBAAA;EACf,OAAA,CAAQ,KAAA,EAAO,kBAAA,GAAqB,OAAA,CAAQ,WAAA;AAAA;AAAA,UAG7B,cAAA;EACf,aAAA,CAAc,OAAA,EAAS,cAAA,GAAiB,OAAA,CAAQ,aAAA;AAAA;AAAA,UAGjC,aAAA;EACf,OAAA,EAAS,UAAA;EACT,UAAA,CAAW,OAAA,EAAS,WAAA,GAAc,OAAA,CAAQ,UAAA;AAAA;AAAA,UAG3B,UAAA;EACf,OAAA,EAAS,UAAA;EACT,MAAA,EAAQ,MAAA;EACR,gBAAA,CAAiB,GAAA,UAAa,IAAA,YAAgB,OAAA;EAC9C,OAAA,IAAW,OAAA;AAAA;AAAA,cAGA,eAAA,GAAmB,aAAA,aAAwB,WAItD;AAAA,UAEe,mBAAA;EACf,eAAe;AAAA;AAAA,cAGJ,YAAA,GACX,SAAA,EAAW,iBAAA,EACX,OAAA,GAAS,mBAAA,KACR,cAAA;AAAA,cAiBU,mBAAA,GACX,SAAA,EAAW,iBAAA,EACX,OAAA,EAAS,UAAA,EACT,aAAA,SAAqB,SAAA,KACpB,aAAA;AAAA,cAeU,gBAAA,GACX,SAAA,EAAW,iBAAA,EACX,OAAA,EAAS,UAAA,EACT,MAAA,EAAQ,MAAA,EACR,aAAA,SAAqB,SAAA,KACpB,UAAA"}

package/dist/index.d.mts

@@ -1,24 +1,3 @@
-import { ClientFrame, SurfaceOptions, SurfaceRef, TrayId, TrayOptions } from "@opentray/spec";
-
-//#region src/index.d.ts
-interface OpenTrayTransport {
-  send(frame: ClientFrame): Promise<void>;
-}
-interface SurfaceHandle {
-  surface: SurfaceRef;
-  createTray(options: TrayOptions): Promise<TrayHandle>;
-}
-interface TrayHandle {
-  surface: SurfaceRef;
-  trayId: TrayId;
-  commandExtension(ext: string, data: unknown): Promise<void>;
-  destroy(): Promise<void>;
-}
-declare const createClient: (transport: OpenTrayTransport) => {
-  createSurface(options: SurfaceOptions): Promise<SurfaceHandle>;
-};
-declare const createSurfaceHandle: (transport: OpenTrayTransport, surface: SurfaceRef) => SurfaceHandle;
-declare const createTrayHandle: (transport: OpenTrayTransport, surface: SurfaceRef, trayId: TrayId) => TrayHandle;
-//#endregion
-export { OpenTrayTransport, SurfaceHandle, TrayHandle, createClient, createSurfaceHandle, createTrayHandle };
-//# sourceMappingURL=index.d.mts.map
+import { a as TrayHandle, c as createSurfaceHandle, i as SurfaceHandle, l as createTrayHandle, n as OpenTrayClient, o as createClient, r as OpenTrayTransport, s as createInitFrame, t as CreateClientOptions } from "./client-COyxXT9C.mjs";
+import { BrokerEndpointIdentity, BrokerEndpointIdentityOptions, PROTOCOL_VERSION, createBrokerEndpointIdentity, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatWindowsPipeName, isSupportedProtocolVersion } from "@opentray/spec";
+export { type BrokerEndpointIdentity, type BrokerEndpointIdentityOptions, type CreateClientOptions, type OpenTrayClient, type OpenTrayTransport, PROTOCOL_VERSION, type SurfaceHandle, type TrayHandle, createBrokerEndpointIdentity, createClient, createInitFrame, createSurfaceHandle, createTrayHandle, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatWindowsPipeName, isSupportedProtocolVersion };

package/dist/index.mjs

@@ -1,46 +1,3 @@
-//#region src/index.ts
-const createClient = (transport) => ({ async createSurface(options) {
-	await transport.send({
-		type: "create-surface",
-		...options
-	});
-	return createSurfaceHandle(transport, {
-		surfaceId: `pending:${options.appId}`,
-		appId: options.appId
-	});
-} });
-const createSurfaceHandle = (transport, surface) => ({
-	surface,
-	async createTray(options) {
-		await transport.send({
-			type: "create-tray",
-			surface,
-			tray: options
-		});
-		return createTrayHandle(transport, surface, options.trayId ?? "pending");
-	}
-});
-const createTrayHandle = (transport, surface, trayId) => ({
-	surface,
-	trayId,
-	async commandExtension(ext, data) {
-		await transport.send({
-			type: "ext-command",
-			surfaceId: surface.surfaceId,
-			trayId,
-			ext,
-			data
-		});
-	},
-	async destroy() {
-		await transport.send({
-			type: "destroy-tray",
-			surfaceId: surface.surfaceId,
-			trayId
-		});
-	}
-});
-//#endregion
-export { createClient, createSurfaceHandle, createTrayHandle };
-
-//# sourceMappingURL=index.mjs.map
+import { i as createTrayHandle, n as createInitFrame, r as createSurfaceHandle, t as createClient } from "./client-BfXT-Zz9.mjs";
+import { PROTOCOL_VERSION, createBrokerEndpointIdentity, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatWindowsPipeName, isSupportedProtocolVersion } from "@opentray/spec";
+export { PROTOCOL_VERSION, createBrokerEndpointIdentity, createClient, createInitFrame, createSurfaceHandle, createTrayHandle, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatWindowsPipeName, isSupportedProtocolVersion };

package/dist/local-broker-CXOpd9Z8.mjs

@@ -0,0 +1,502 @@
+import { createRequire } from "node:module";
+import { PROTOCOL_VERSION, createBrokerEndpointIdentity, formatUnixSocketPath, formatWindowsPipeName, parseServerFrame } from "@opentray/spec";
+import { createConnection } from "node:net";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { constants } from "node:fs";
+import { access, mkdir, open, readFile, rm, unlink, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { dirname, join } from "node:path";
+//#region src/daemon/native-target.ts
+const resolveBrokerNativeTarget = (platform = process.platform, arch = process.arch) => {
+	const packageOs = platformToPackageOs(platform);
+	return {
+		packageName: `@opentray/${packageOs}-${normalizeArch(arch)}`,
+		binaryRelativePath: `bin/${packageOs === "windows" ? "opentray.exe" : "opentray"}`
+	};
+};
+const platformToPackageOs = (platform) => {
+	switch (platform) {
+		case "darwin":
+		case "linux": return platform;
+		case "win32": return "windows";
+		default: throw new MissingPlatformBrokerBinaryError(`unsupported OpenTray broker platform: ${platform}`, platform, process.arch);
+	}
+};
+const normalizeArch = (arch) => {
+	switch (arch) {
+		case "arm64":
+		case "x64": return arch;
+		default: throw new MissingPlatformBrokerBinaryError(`unsupported OpenTray broker architecture: ${arch}`, process.platform, arch);
+	}
+};
+var MissingPlatformBrokerBinaryError = class extends Error {
+	code = "OPENTRAY_MISSING_PLATFORM_BROKER_BINARY";
+	platform;
+	arch;
+	packageName;
+	binaryPath;
+	constructor(message, platform, arch, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "MissingPlatformBrokerBinaryError";
+		this.platform = platform;
+		this.arch = arch;
+		this.packageName = options.packageName;
+		this.binaryPath = options.binaryPath;
+	}
+};
+//#endregion
+//#region src/daemon/broker-command.ts
+const sourceUrl = import.meta.url;
+const requireFromSource = createRequire(sourceUrl);
+const resolveBrokerCommand = async (paths, options = {}) => {
+	const explicit = (options.env ?? process.env).OPENTRAY_BROKER_BIN;
+	if (explicit !== void 0 && explicit.length > 0) return commandForBinary(explicit, paths);
+	const platform = options.platform ?? process.platform;
+	const arch = options.arch ?? process.arch;
+	let installedBinaryError;
+	try {
+		const installedBinary = await resolveInstalledBrokerBinary({
+			platform,
+			arch,
+			resolvePackageJson: options.resolvePackageJson ?? resolvePackageJson
+		});
+		if (installedBinary !== void 0) return commandForBinary(installedBinary, paths);
+	} catch (error) {
+		if (!(error instanceof MissingPlatformBrokerBinaryError)) throw error;
+		installedBinaryError = error;
+	}
+	const sourceDir = options.sourceDir ?? dirname(fileURLToPath(sourceUrl));
+	const workspaceRoot = await (options.findWorkspaceRoot ?? findWorkspaceRoot)(sourceDir);
+	if (workspaceRoot !== void 0) return commandForBinary(await (options.ensureDevBrokerBinary ?? ensureDevBrokerBinary)(workspaceRoot), paths, workspaceRoot);
+	if (installedBinaryError !== void 0) throw installedBinaryError;
+	const target = resolveBrokerNativeTarget(platform, arch);
+	throw new MissingPlatformBrokerBinaryError(`unable to resolve OpenTray broker binary for ${platform}/${arch}; install ${target.packageName} or set OPENTRAY_BROKER_BIN`, platform, arch, { packageName: target.packageName });
+};
+const commandForBinary = (binary, paths, cwd) => {
+	const command = {
+		command: binary,
+		args: [
+			"broker",
+			"--endpoint",
+			paths.endpoint,
+			"--ready-file",
+			paths.readyFile,
+			"--package-version",
+			paths.packageVersion,
+			"--protocol-version",
+			`${paths.protocolVersion}`
+		]
+	};
+	if (cwd !== void 0) command.cwd = cwd;
+	return command;
+};
+const resolveInstalledBrokerBinary = async ({ platform, arch, resolvePackageJson }) => {
+	const target = resolveBrokerNativeTarget(platform, arch);
+	const packageJsonPath = resolvePackageJson(target.packageName);
+	if (packageJsonPath === void 0) return;
+	const binary = join(dirname(packageJsonPath), target.binaryRelativePath);
+	if (!await exists(binary)) throw new MissingPlatformBrokerBinaryError(`OpenTray broker package ${target.packageName} is installed but missing ${target.binaryRelativePath}`, platform, arch, {
+		packageName: target.packageName,
+		binaryPath: binary
+	});
+	return binary;
+};
+const resolvePackageJson = (packageName) => {
+	try {
+		return requireFromSource.resolve(`${packageName}/package.json`);
+	} catch (error) {
+		if (isNodeError$1(error) && error.code === "MODULE_NOT_FOUND") return;
+		throw error;
+	}
+};
+const findWorkspaceRoot = async (start) => {
+	let current = start;
+	while (true) {
+		if (await exists(join(current, "Cargo.toml"))) {
+			if (await exists(join(current, "crates", "opentray-bin", "Cargo.toml"))) return current;
+		}
+		const parent = dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+};
+const ensureDevBrokerBinary = async (workspaceRoot) => {
+	const binary = join(workspaceRoot, "target", "debug", process.platform === "win32" ? "opentray.exe" : "opentray");
+	await runCargoBuild(workspaceRoot);
+	return binary;
+};
+const runCargoBuild = (workspaceRoot) => new Promise((resolve, reject) => {
+	const child = spawn("cargo", [
+		"build",
+		"-p",
+		"opentray-bin"
+	], {
+		cwd: workspaceRoot,
+		stdio: process.env.OPENTRAY_BROKER_BUILD_LOGS === "1" ? "inherit" : "ignore"
+	});
+	child.once("error", reject);
+	child.once("exit", (code) => {
+		if (code === 0) {
+			resolve();
+			return;
+		}
+		reject(/* @__PURE__ */ new Error(`cargo build -p opentray-bin failed with code ${code ?? "unknown"}`));
+	});
+});
+const exists = async (path) => {
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const isNodeError$1 = (error) => error instanceof Error && "code" in error;
+//#endregion
+//#region src/daemon/lifecycle.ts
+const createNodeDaemonDriver = (cliEntrypoint) => ({
+	async isAlive(pid) {
+		return isProcessAlive(pid);
+	},
+	async spawnBroker(paths) {
+		const broker = await resolveBrokerCommand(paths);
+		const child = spawn(broker.command, broker.args, {
+			cwd: broker.cwd,
+			detached: true,
+			env: {
+				...process.env,
+				OPENTRAY_DAEMON_HOME: paths.homeDir,
+				OPENTRAY_DAEMON_PACKAGE_VERSION: paths.packageVersion,
+				OPENTRAY_DAEMON_CLI_ENTRYPOINT: cliEntrypoint
+			},
+			stdio: "ignore"
+		});
+		child.unref();
+		return child.pid ?? 0;
+	},
+	async stop(pid) {
+		process.kill(pid, "SIGTERM");
+	}
+});
+const startDaemon = async ({ paths, driver, lockTimeoutMs = 1e3 }) => {
+	await mkdir(paths.runtimeDir, { recursive: true });
+	const lock = await acquireLock(paths.lockFile, lockTimeoutMs);
+	try {
+		const existingPid = await readPid(paths.pidFile);
+		if (existingPid !== void 0 && await driver.isAlive(existingPid)) return {
+			status: "already-running",
+			pid: existingPid,
+			paths
+		};
+		await cleanupRuntimeFiles(paths);
+		const pid = await driver.spawnBroker(paths);
+		if (!Number.isInteger(pid) || pid <= 0) throw new Error("daemon broker process did not expose a valid pid");
+		await writeFile(paths.pidFile, `${pid}\n`, "utf8");
+		await waitForReadyFile(paths.readyFile);
+		return {
+			status: "started",
+			pid,
+			paths
+		};
+	} finally {
+		await lock.release();
+	}
+};
+const stopDaemon = async ({ paths, driver }) => {
+	const pid = await readPid(paths.pidFile);
+	if (pid === void 0 || !await driver.isAlive(pid)) {
+		await cleanupRuntimeFiles(paths);
+		return {
+			status: "not-running",
+			paths
+		};
+	}
+	await driver.stop(pid);
+	await waitUntilStopped(driver, pid);
+	await cleanupRuntimeFiles(paths);
+	return {
+		status: "stopped",
+		pid,
+		paths
+	};
+};
+const restartDaemon = async (options) => {
+	await stopDaemon({
+		paths: options.paths,
+		driver: options.driver
+	});
+	return startDaemon(options);
+};
+const inspectDaemon = async ({ paths, driver }) => {
+	const pid = await readPid(paths.pidFile);
+	if (pid !== void 0 && await driver.isAlive(pid)) return {
+		status: "running",
+		pid,
+		paths
+	};
+	await cleanupRuntimeFiles(paths);
+	return pid === void 0 ? {
+		status: "not-running",
+		paths
+	} : {
+		status: "not-running",
+		paths,
+		stalePid: pid
+	};
+};
+const readPid = async (pidFile) => {
+	try {
+		const content = await readFile(pidFile, "utf8");
+		const pid = Number.parseInt(content.trim(), 10);
+		return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return;
+		throw error;
+	}
+};
+const cleanupRuntimeFiles = async (paths) => {
+	await rm(paths.readyFile, { force: true });
+	await rm(paths.pidFile, { force: true });
+	if (process.platform !== "win32") await rm(paths.endpoint, { force: true });
+};
+const waitUntilStopped = async (driver, pid) => {
+	for (let attempt = 0; attempt < 20; attempt += 1) {
+		if (!await driver.isAlive(pid)) return;
+		await sleep(50);
+	}
+};
+const waitForReadyFile = async (readyFile) => {
+	for (let attempt = 0; attempt < 40; attempt += 1) try {
+		await readFile(readyFile, "utf8");
+		return;
+	} catch (error) {
+		if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+		await sleep(50);
+	}
+	throw new Error(`timed out waiting for daemon readiness: ${readyFile}`);
+};
+const acquireLock = async (lockFile, timeoutMs) => {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() <= deadline) try {
+		const handle = await open(lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+		await handle.writeFile(`${process.pid}\n`, "utf8");
+		return { async release() {
+			await handle.close();
+			await unlink(lockFile).catch((error) => {
+				if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+			});
+		} };
+	} catch (error) {
+		if (isNodeError(error) && error.code === "EEXIST") {
+			await sleep(25);
+			continue;
+		}
+		throw error;
+	}
+	throw new Error(`timed out acquiring daemon lock: ${lockFile}`);
+};
+const isProcessAlive = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isNodeError = (error) => error instanceof Error && "code" in error;
+//#endregion
+//#region src/daemon/package-version.ts
+const readPackageVersion = async (packageJsonUrl) => {
+	const value = JSON.parse(await readFile(packageJsonUrl, "utf8"));
+	if (!isPackageJsonWithVersion(value)) throw new Error(`package.json is missing a string version: ${packageJsonUrl.href}`);
+	return value.version;
+};
+const isPackageJsonWithVersion = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && "version" in value && typeof value.version === "string";
+//#endregion
+//#region src/daemon/paths.ts
+const resolveDaemonPaths = ({ homeDir, packageVersion, platform = process.platform }) => {
+	const identity = createBrokerEndpointIdentity({ packageVersion });
+	const normalizedHome = homeDir.replace(/[\\/]+$/u, "");
+	const stateRoot = `${normalizedHome}/.opentray/${identity.packageVersion}`;
+	const runtimeDir = `${stateRoot}/runtime`;
+	const endpoint = platform === "win32" ? formatWindowsPipeName(identity) : formatUnixSocketPath(normalizedHome, identity);
+	return {
+		homeDir: normalizedHome,
+		packageVersion: identity.packageVersion,
+		protocolVersion: identity.protocolVersion,
+		stateRoot,
+		runtimeDir,
+		endpoint,
+		pidFile: `${runtimeDir}/broker.pid`,
+		lockFile: `${runtimeDir}/broker.lock`,
+		readyFile: `${runtimeDir}/ready.json`
+	};
+};
+//#endregion
+//#region src/local-broker.ts
+const packageJsonUrl = new URL("../package.json", import.meta.url);
+const connectLocalBroker = async (options = {}) => {
+	const packageVersion = options.packageVersion ?? await readPackageVersion(packageJsonUrl);
+	const clientVersion = options.clientVersion ?? packageVersion;
+	const paths = resolveDaemonPaths({
+		homeDir: options.homeDir ?? process.env.OPENTRAY_HOME ?? homedir(),
+		packageVersion
+	});
+	const endpoint = options.endpoint ?? paths.endpoint;
+	const autoStart = options.autoStart ?? endpoint === paths.endpoint;
+	if (autoStart && endpoint !== paths.endpoint) throw new Error("local broker autoStart requires the derived same-version endpoint");
+	if (autoStart) {
+		const cliEntrypoint = options.cliEntrypoint ?? resolveCliEntrypoint();
+		await startDaemon({
+			paths,
+			driver: options.daemonDriver ?? createNodeDaemonDriver(cliEntrypoint)
+		});
+	}
+	const connection = new LocalBrokerConnection(await connectSocket(endpoint), endpoint);
+	await connection.init(clientVersion, options.protocolVersion ?? PROTOCOL_VERSION);
+	return connection;
+};
+var LocalBrokerConnection = class {
+	socket;
+	endpoint;
+	leaseId = "";
+	buffer = "";
+	listeners = /* @__PURE__ */ new Set();
+	pending = /* @__PURE__ */ new Map();
+	ready;
+	constructor(socket, endpoint) {
+		this.socket = socket;
+		this.endpoint = endpoint;
+		socket.setEncoding("utf8");
+		socket.on("data", (chunk) => {
+			this.consume(String(chunk));
+		});
+		socket.on("error", (error) => {
+			this.rejectAll(error);
+		});
+		socket.on("close", () => {
+			this.rejectAll(/* @__PURE__ */ new Error("broker connection closed"));
+		});
+	}
+	async init(clientVersion, protocolVersion) {
+		const ready = new Promise((resolve, reject) => {
+			this.ready = {
+				resolve,
+				reject
+			};
+		});
+		this.write({
+			type: "init",
+			protocolVersion,
+			clientVersion
+		});
+		const frame = await ready;
+		this.leaseId = frame.leaseId;
+	}
+	async request(frame) {
+		if (this.pending.has(frame.requestId)) throw new Error(`duplicate requestId: ${frame.requestId}`);
+		const response = new Promise((resolve, reject) => {
+			this.pending.set(frame.requestId, {
+				resolve,
+				reject
+			});
+		});
+		this.write(frame);
+		return response;
+	}
+	onEvent(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	async close() {
+		this.write({ type: "exit" });
+		await new Promise((resolve) => {
+			this.socket.end(resolve);
+		});
+	}
+	consume(chunk) {
+		this.buffer += chunk;
+		while (true) {
+			const newline = this.buffer.indexOf("\n");
+			if (newline < 0) return;
+			const line = this.buffer.slice(0, newline).trim();
+			this.buffer = this.buffer.slice(newline + 1);
+			if (line.length > 0) this.dispatchLine(line);
+		}
+	}
+	dispatchLine(line) {
+		const parsed = parseServerFrame(line);
+		if (!parsed.ok || parsed.frame === void 0) {
+			this.rejectAll(new Error(parsed.error ?? "invalid server frame"));
+			return;
+		}
+		this.dispatchFrame(parsed.frame);
+	}
+	dispatchFrame(frame) {
+		if (frame.type === "ready") {
+			this.ready?.resolve(frame);
+			this.ready = void 0;
+			return;
+		}
+		if (frame.type === "error") {
+			const error = /* @__PURE__ */ new Error(`${frame.code}: ${frame.message}`);
+			if (frame.requestId !== void 0) {
+				this.pending.get(frame.requestId)?.reject(error);
+				this.pending.delete(frame.requestId);
+				return;
+			}
+			this.ready?.reject(error);
+			this.ready = void 0;
+			return;
+		}
+		const requestId = responseRequestId(frame);
+		if (requestId !== void 0) {
+			this.pending.get(requestId)?.resolve(frame);
+			this.pending.delete(requestId);
+			return;
+		}
+		if (frame.type === "event" || frame.type === "ext-event") for (const listener of this.listeners) listener(frame);
+	}
+	write(frame) {
+		this.socket.write(`${JSON.stringify(frame)}\n`);
+	}
+	rejectAll(error) {
+		this.ready?.reject(error);
+		this.ready = void 0;
+		for (const pending of this.pending.values()) pending.reject(error);
+		this.pending.clear();
+	}
+};
+const connectSocket = (endpoint) => new Promise((resolve, reject) => {
+	const socket = createConnection(endpoint);
+	socket.once("connect", () => {
+		socket.off("error", reject);
+		resolve(socket);
+	});
+	socket.once("error", reject);
+});
+const responseRequestId = (frame) => {
+	switch (frame.type) {
+		case "surface-created":
+		case "default-surface":
+		case "tray-created":
+		case "ack":
+		case "daemon-health": return frame.requestId;
+		case "ready":
+		case "event":
+		case "ext-event":
+		case "error": return;
+	}
+};
+const resolveCliEntrypoint = () => {
+	const suffix = fileURLToPath(import.meta.url).endsWith(".ts") ? "cli.ts" : "cli.mjs";
+	return fileURLToPath(new URL(`./${suffix}`, import.meta.url));
+};
+//#endregion
+export { inspectDaemon as a, stopDaemon as c, createNodeDaemonDriver as i, resolveDaemonPaths as n, restartDaemon as o, readPackageVersion as r, startDaemon as s, connectLocalBroker as t };
+
+//# sourceMappingURL=local-broker-CXOpd9Z8.mjs.map