@morlay/dsh-desktopify 0.1.0

package/dist/index.mjs

@@ -0,0 +1,860 @@
+import { i as loadAppConfig, n as ensureSeedProfile } from "./seed-Ca0AMFtp.mjs";
+import { readFile } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, normalize, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { BrowserWindow, app, dialog, protocol } from "electron";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { Readable, Writable } from "node:stream";
+//#region src/dshhome.ts
+/**
+* Resolve the runtime `DSH_HOME` from the shell configuration, following the
+* reference desktop semantics: `xdg` maps to the XDG data home
+* (`~/Library/Application Support` on macOS, `$XDG_DATA_HOME` or
+* `~/.local/share` on Linux) joined with the application name, so the packaged
+* app shares the same data root as the reference implementation and never
+* touches the workspace. `env` inherits the environment; an absolute path pins
+* the home. `DSH_APP_DSH_HOME` overrides everything (development and tests).
+* @module @morlay/dsh-desktopify
+*/
+/** XDG data home for the current platform (macOS and Linux). */
+function xdgDataHome() {
+	if (process.platform === "darwin") return join(homedir(), "Library", "Application Support");
+	const configured = process.env.XDG_DATA_HOME;
+	if (configured !== void 0 && configured.trim() !== "") return resolve(configured);
+	return join(homedir(), ".local", "share");
+}
+/**
+* Resolve the runtime `DSH_HOME` for one shell configuration.
+* @param config - shell configuration read beside the executable.
+* @returns the absolute home, or `undefined` when the strategy is `env`
+* (the caller then leaves `DSH_HOME` unset).
+*/
+function resolveDshHome(config) {
+	const override = process.env.DSH_APP_DSH_HOME;
+	if (override !== void 0 && override.trim() !== "") return resolve(override);
+	if (config.dshHome === "env") return void 0;
+	if (config.dshHome === "xdg") return join(xdgDataHome(), config.name);
+	if (!isAbsolute(config.dshHome)) throw new Error(`dsh desktop: dshHome must be xdg, env, or an absolute path, got ${JSON.stringify(config.dshHome)}`);
+	return config.dshHome;
+}
+//#endregion
+//#region src/host-protocol.ts
+/** Maximum raw body bytes carried by one data frame. */
+const DESKTOP_PIPE_CHUNK_BYTES = 65536;
+const FRAME_MAGIC = 1146308659;
+const FRAME_HEADER_BYTES = 13;
+const MAX_CONTROL_PAYLOAD_BYTES = 1048576;
+const REQUEST_FRAME_START = 1;
+const REQUEST_FRAME_DATA = 2;
+const REQUEST_FRAME_END = 3;
+const REQUEST_FRAME_CANCEL = 4;
+const RESPONSE_FRAME_START = 1;
+const RESPONSE_FRAME_DATA = 2;
+const RESPONSE_FRAME_END = 3;
+const RESPONSE_FRAME_ERROR = 4;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isHeaders(value) {
+	return Array.isArray(value) && value.every((header) => Array.isArray(header) && header.length === 2 && typeof header[0] === "string" && typeof header[1] === "string");
+}
+function assertStreamId(streamId) {
+	if (!Number.isInteger(streamId) || streamId < 1 || streamId > 4294967295) throw new Error(`dsh desktop: invalid pipe stream id ${String(streamId)}`);
+}
+function encodeFrame(type, streamId, payload) {
+	assertStreamId(streamId);
+	const limit = type === REQUEST_FRAME_DATA ? DESKTOP_PIPE_CHUNK_BYTES : MAX_CONTROL_PAYLOAD_BYTES;
+	if (payload.byteLength > limit) throw new Error(`dsh desktop: request pipe frame exceeds the ${String(limit)}-byte limit`);
+	const frame = Buffer.allocUnsafe(FRAME_HEADER_BYTES + payload.byteLength);
+	frame.writeUInt32BE(FRAME_MAGIC, 0);
+	frame.writeUInt8(type, 4);
+	frame.writeUInt32BE(streamId, 5);
+	frame.writeUInt32BE(payload.byteLength, 9);
+	payload.copy(frame, FRAME_HEADER_BYTES);
+	return frame;
+}
+function encodeJsonFrame(type, streamId, value) {
+	return encodeFrame(type, streamId, Buffer.from(JSON.stringify(value), "utf8"));
+}
+/** Encode the metadata opening one request stream. */
+function encodeDesktopRequestStart(streamId, request) {
+	return encodeJsonFrame(REQUEST_FRAME_START, streamId, request);
+}
+/** Encode one bounded raw request-body chunk. */
+function encodeDesktopRequestData(streamId, data) {
+	return encodeFrame(REQUEST_FRAME_DATA, streamId, Buffer.from(data));
+}
+/** Encode normal request-body completion. */
+function encodeDesktopRequestEnd(streamId) {
+	return encodeFrame(REQUEST_FRAME_END, streamId, Buffer.alloc(0));
+}
+/** Encode cancellation of one request and its response. */
+function encodeDesktopRequestCancel(streamId) {
+	return encodeFrame(REQUEST_FRAME_CANCEL, streamId, Buffer.alloc(0));
+}
+/** Incrementally decode validated response frames from the Host byte pipe. */
+var DesktopHostResponseDecoder = class {
+	buffer = Buffer.alloc(0);
+	/**
+	* Append bytes and return every complete response frame.
+	* @param chunk - next bytes read from the Host response pipe.
+	* @returns complete frames in pipe order.
+	*/
+	push(chunk) {
+		this.buffer = this.buffer.byteLength === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+		const frames = [];
+		for (;;) {
+			const frame = this.next();
+			if (frame === void 0) return frames;
+			frames.push(frame);
+		}
+	}
+	/** Reject EOF that splits a frame. */
+	finish() {
+		if (this.buffer.byteLength !== 0) throw new Error("dsh desktop: Host response pipe ended inside a frame");
+	}
+	next() {
+		if (this.buffer.byteLength < FRAME_HEADER_BYTES) return void 0;
+		if (this.buffer.readUInt32BE(0) !== FRAME_MAGIC) throw new Error("dsh desktop: invalid Host response frame marker");
+		const rawType = this.buffer.readUInt8(4);
+		const streamId = this.buffer.readUInt32BE(5);
+		const payloadLength = this.buffer.readUInt32BE(9);
+		assertStreamId(streamId);
+		const limit = rawType === RESPONSE_FRAME_DATA ? DESKTOP_PIPE_CHUNK_BYTES : MAX_CONTROL_PAYLOAD_BYTES;
+		if (payloadLength > limit) throw new Error(`dsh desktop: Host response frame exceeds the ${String(limit)}-byte limit`);
+		const frameLength = FRAME_HEADER_BYTES + payloadLength;
+		if (this.buffer.byteLength < frameLength) return void 0;
+		const payload = this.buffer.subarray(FRAME_HEADER_BYTES, frameLength);
+		this.buffer = this.buffer.subarray(frameLength);
+		switch (rawType) {
+			case RESPONSE_FRAME_START: return this.parseStart(streamId, payload);
+			case RESPONSE_FRAME_DATA: return {
+				type: "data",
+				streamId,
+				data: payload
+			};
+			case RESPONSE_FRAME_END:
+				if (payloadLength !== 0) throw new Error("dsh desktop: Host response end frame carried a payload");
+				return {
+					type: "end",
+					streamId
+				};
+			case RESPONSE_FRAME_ERROR: return this.parseError(streamId, payload);
+			default: throw new Error(`dsh desktop: unknown Host response frame type ${String(rawType)}`);
+		}
+	}
+	parseStart(streamId, payload) {
+		const value = this.parseJson(payload, "start");
+		if (!isRecord(value) || !Number.isInteger(value.status) || value.status < 100 || value.status > 599 || !isHeaders(value.headers) || typeof value.hasBody !== "boolean") throw new Error("dsh desktop: invalid Host response start payload");
+		return {
+			type: "start",
+			streamId,
+			status: value.status,
+			headers: value.headers,
+			hasBody: value.hasBody
+		};
+	}
+	parseError(streamId, payload) {
+		const value = this.parseJson(payload, "error");
+		if (!isRecord(value) || typeof value.message !== "string") throw new Error("dsh desktop: invalid Host response error payload");
+		return {
+			type: "error",
+			streamId,
+			message: value.message
+		};
+	}
+	parseJson(payload, subject) {
+		try {
+			return JSON.parse(payload.toString("utf8"));
+		} catch (error) {
+			throw new Error(`dsh desktop: Host response ${subject} payload is not JSON: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+};
+//#endregion
+//#region src/host-process.ts
+/** Upstream-Node child lifecycle and streaming custom-protocol carrier. */
+function isDesktopHostEvent(message) {
+	if (typeof message !== "object" || message === null || !("type" in message)) return false;
+	const candidate = message;
+	switch (candidate.type) {
+		case "ready": return candidate.protocolVersion === 3 && typeof candidate.dshVersion === "string";
+		case "fatal": return typeof candidate.message === "string";
+		default: return false;
+	}
+}
+function errorOf(reason, fallback) {
+	return reason instanceof Error ? reason : new Error(fallback);
+}
+async function exitsWithin(exit, milliseconds) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => {
+			resolve(false);
+		}, milliseconds);
+		timer.unref();
+	});
+	try {
+		return await Promise.race([exit.then(() => true), timeout]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/** One dsh backend running under the bundled upstream Node.js executable. */
+var DesktopHostProcess = class {
+	node;
+	projectDir;
+	inspectPort;
+	options;
+	child;
+	requestPipe;
+	responsePipe;
+	responseDecoder = new DesktopHostResponseDecoder();
+	requestWriteTail = Promise.resolve();
+	nextStreamId = 1;
+	pending = /* @__PURE__ */ new Map();
+	blockedResponses = /* @__PURE__ */ new Set();
+	readyResolve;
+	readyReject;
+	readyPromise = new Promise((resolve, reject) => {
+		this.readyResolve = resolve;
+		this.readyReject = reject;
+	});
+	exitPromise;
+	stderr = "";
+	/**
+	* @param node - absolute bundled upstream Node.js executable.
+	* @param projectDir - active or staged desktop npm project.
+	* @param inspectPort - optional loopback inspector port for workspace development.
+	* @param options - launch customization (node args, environment, shell spawn).
+	*/
+	constructor(node, projectDir, inspectPort, options = {}) {
+		this.node = node;
+		this.projectDir = projectDir;
+		this.inspectPort = inspectPort;
+		this.options = options;
+	}
+	/** Start the child once and resolve only after its complete composition is active. */
+	async start() {
+		if (this.child !== void 0) return this.readyPromise;
+		const entry = join(this.projectDir, "node_modules", "@deepseek-ai", "dsh-desktop-host", "lib", "index.js");
+		const allowLinked = this.options.allowLinkedProfile === true || this.inspectPort !== void 0;
+		const args = [
+			...this.inspectPort === void 0 ? [] : [`--inspect=127.0.0.1:${String(this.inspectPort)}`],
+			...this.options.nodeArgs ?? [],
+			entry,
+			this.projectDir,
+			...allowLinked ? ["--allow-linked-profile"] : []
+		];
+		const env = {
+			...Object.fromEntries(Object.entries(process.env).filter(([name]) => name !== "NODE_OPTIONS" && !name.startsWith("DSH_DESKTOP_") && !/^(?:npm|pnpm|corepack)_/iu.test(name))),
+			...this.options.extraEnv
+		};
+		const child = (this.options.spawn ?? spawn)(this.node, args, {
+			cwd: this.projectDir,
+			env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe",
+				"pipe",
+				"pipe",
+				"ipc"
+			]
+		});
+		const requestPipe = child.stdio[3];
+		const responsePipe = child.stdio[4];
+		if (!(requestPipe instanceof Writable) || !(responsePipe instanceof Readable)) {
+			this.killChild("SIGTERM");
+			throw new Error("dsh desktop host did not expose the required byte pipes and IPC channel");
+		}
+		this.child = child;
+		this.requestPipe = requestPipe;
+		this.responsePipe = responsePipe;
+		child.stderr?.setEncoding("utf8");
+		child.stderr?.on("data", (chunk) => {
+			this.stderr += chunk;
+			process.stderr.write(`[dsh-host] ${chunk}`);
+		});
+		child.stdout?.pipe(process.stdout);
+		responsePipe.on("data", (chunk) => {
+			this.acceptResponseBytes(chunk);
+		});
+		responsePipe.once("end", () => {
+			try {
+				this.responseDecoder.finish();
+				this.fail(/* @__PURE__ */ new Error("dsh desktop host response pipe ended"));
+			} catch (error) {
+				this.fail(errorOf(error, "dsh desktop host response pipe failed"));
+			}
+		});
+		requestPipe.once("error", (error) => {
+			this.fail(error);
+		});
+		responsePipe.once("error", (error) => {
+			this.fail(error);
+		});
+		child.on("message", (message) => {
+			if (!isDesktopHostEvent(message)) {
+				this.fail(/* @__PURE__ */ new Error("dsh desktop host sent an invalid IPC event"));
+				this.killChild("SIGTERM");
+				return;
+			}
+			this.handleMessage(message);
+		});
+		child.once("error", (error) => {
+			this.fail(error);
+		});
+		this.exitPromise = new Promise((resolve) => {
+			child.once("exit", (code) => {
+				const suffix = this.stderr.trim() === "" ? "" : `: ${this.stderr.trim()}`;
+				if (code !== 0 && code !== null) this.fail(/* @__PURE__ */ new Error(`dsh desktop host exited with ${String(code)}${suffix}`));
+				else this.fail(/* @__PURE__ */ new Error(`dsh desktop host stopped${suffix}`));
+				resolve();
+			});
+		});
+		return this.readyPromise;
+	}
+	/** Forward one `dsh-app://app` request to the child without buffering its body. */
+	async fetch(request) {
+		await this.start();
+		const child = this.child;
+		if (child === void 0 || !child.connected || this.requestPipe === void 0) throw new Error("dsh desktop host is unavailable");
+		if (this.nextStreamId > 4294967295) throw new Error("dsh desktop host exhausted its request stream ids");
+		const streamId = this.nextStreamId++;
+		const method = request.method.toUpperCase();
+		const hasBody = method !== "GET" && method !== "HEAD" && request.body !== null;
+		return new Promise((resolve, reject) => {
+			const pending = {
+				resolve,
+				reject,
+				responseStarted: false,
+				uploadOpen: hasBody
+			};
+			const abort = () => {
+				if (!this.pending.has(streamId)) return;
+				const error = errorOf(request.signal.reason, "request aborted");
+				pending.uploadOpen = false;
+				pending.requestReader?.cancel(error).catch(() => void 0);
+				this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((pipeError) => {
+					this.fail(errorOf(pipeError, "dsh desktop request pipe failed"));
+				});
+				if (pending.controller === void 0) pending.reject(error);
+				else pending.controller.error(error);
+				this.finishPending(streamId, false);
+			};
+			if (request.signal.aborted) {
+				reject(errorOf(request.signal.reason, "request aborted"));
+				return;
+			}
+			request.signal.addEventListener("abort", abort, { once: true });
+			pending.removeAbort = () => {
+				request.signal.removeEventListener("abort", abort);
+			};
+			this.pending.set(streamId, pending);
+			this.pumpRequest(streamId, request, hasBody).catch((error) => {
+				this.failPending(streamId, errorOf(error, "dsh desktop request upload failed"));
+			});
+		});
+	}
+	/** Request graceful teardown, then wait for child exit. */
+	async stop() {
+		const child = this.child;
+		if (child === void 0) return;
+		this.blockedResponses.clear();
+		this.responsePipe?.resume();
+		if (child.connected) this.send({ type: "shutdown" });
+		this.requestPipe?.destroy();
+		const exited = this.exitPromise ?? Promise.resolve();
+		if (!await exitsWithin(exited, 1e4)) this.killChild("SIGTERM");
+		if (!await exitsWithin(exited, 5e3)) {
+			this.killChild("SIGKILL");
+			if (!await exitsWithin(exited, 5e3)) throw new Error("dsh desktop host did not exit after SIGKILL");
+		}
+		this.child = void 0;
+		this.requestPipe = void 0;
+		this.responsePipe = void 0;
+	}
+	/** Signal the child, covering its whole process group when it was detached. */
+	killChild(signal) {
+		const child = this.child;
+		if (child === void 0 || child.pid === void 0) return;
+		if (process.platform !== "win32") try {
+			process.kill(-child.pid, signal);
+			return;
+		} catch (error) {
+			if (error.code !== "ESRCH") throw error;
+		}
+		child.kill(signal);
+	}
+	async pumpRequest(streamId, request, hasBody) {
+		await this.enqueueRequestFrame(encodeDesktopRequestStart(streamId, {
+			url: request.url,
+			method: request.method.toUpperCase(),
+			headers: [...request.headers.entries()],
+			hasBody
+		}));
+		if (!hasBody) return;
+		const body = request.body;
+		if (body === null) throw new Error("dsh desktop request body disappeared before upload");
+		const reader = body.getReader();
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) {
+			await reader.cancel();
+			return;
+		}
+		pending.requestReader = reader;
+		try {
+			for (;;) {
+				const next = await reader.read();
+				if (next.done) break;
+				for (let offset = 0; offset < next.value.byteLength; offset += DESKTOP_PIPE_CHUNK_BYTES) {
+					if (!this.pending.has(streamId)) return;
+					await this.enqueueRequestFrame(encodeDesktopRequestData(streamId, next.value.subarray(offset, offset + DESKTOP_PIPE_CHUNK_BYTES)));
+				}
+			}
+			const live = this.pending.get(streamId);
+			if (live !== void 0) {
+				await this.enqueueRequestFrame(encodeDesktopRequestEnd(streamId));
+				live.uploadOpen = false;
+			}
+		} finally {
+			reader.releaseLock();
+			const live = this.pending.get(streamId);
+			if (live?.requestReader === reader) delete live.requestReader;
+		}
+	}
+	enqueueRequestFrame(frame) {
+		const write = this.requestWriteTail.then(async () => {
+			const pipe = this.requestPipe;
+			if (pipe === void 0 || pipe.destroyed) throw new Error("dsh desktop host request pipe is unavailable");
+			if (!pipe.write(frame)) await once(pipe, "drain");
+		});
+		this.requestWriteTail = write.catch(() => void 0);
+		return write;
+	}
+	send(message) {
+		const child = this.child;
+		if (child === void 0 || !child.connected) throw new Error("dsh desktop host IPC is unavailable");
+		child.send(message);
+	}
+	acceptResponseBytes(chunk) {
+		try {
+			for (const frame of this.responseDecoder.push(chunk)) this.handleResponseFrame(frame);
+		} catch (error) {
+			this.fail(errorOf(error, "dsh desktop host response pipe failed"));
+			this.child?.kill("SIGTERM");
+		}
+	}
+	handleResponseFrame(frame) {
+		const pending = this.pending.get(frame.streamId);
+		if (pending === void 0) {
+			if (frame.streamId >= this.nextStreamId) throw new Error(`dsh desktop host responded for unknown stream ${String(frame.streamId)}`);
+			return;
+		}
+		switch (frame.type) {
+			case "start": {
+				if (pending.responseStarted) throw new Error(`dsh desktop host started stream ${String(frame.streamId)} twice`);
+				pending.responseStarted = true;
+				let body = null;
+				if (frame.hasBody) body = new ReadableStream({
+					start: (controller) => {
+						pending.controller = controller;
+					},
+					pull: () => {
+						this.blockedResponses.delete(frame.streamId);
+						this.resumeResponsePipe();
+					},
+					cancel: (reason) => {
+						this.cancelResponse(frame.streamId, reason);
+					}
+				});
+				pending.resolve(new Response(body, {
+					status: frame.status,
+					headers: new Headers(frame.headers.map(([name, value]) => [name, value]))
+				}));
+				return;
+			}
+			case "data": {
+				const controller = pending.controller;
+				if (!pending.responseStarted || controller === void 0) throw new Error(`dsh desktop host sent body data before a body start for stream ${String(frame.streamId)}`);
+				controller.enqueue(frame.data);
+				if ((controller.desiredSize ?? 0) <= 0) {
+					this.blockedResponses.add(frame.streamId);
+					this.responsePipe?.pause();
+				}
+				return;
+			}
+			case "end":
+				if (!pending.responseStarted) throw new Error(`dsh desktop host ended stream ${String(frame.streamId)} before its response start`);
+				pending.controller?.close();
+				this.finishPending(frame.streamId, true);
+				return;
+			case "error":
+				this.failPending(frame.streamId, new Error(frame.message));
+				return;
+		}
+	}
+	cancelResponse(streamId, reason) {
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) return;
+		pending.uploadOpen = false;
+		pending.requestReader?.cancel(reason).catch(() => void 0);
+		this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((error) => {
+			this.fail(errorOf(error, "dsh desktop request pipe failed"));
+		});
+		this.finishPending(streamId, false);
+	}
+	failPending(streamId, error) {
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) return;
+		pending.uploadOpen = false;
+		pending.requestReader?.cancel(error).catch(() => void 0);
+		if (pending.controller === void 0) pending.reject(error);
+		else pending.controller.error(error);
+		this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((pipeError) => {
+			this.fail(errorOf(pipeError, "dsh desktop request pipe failed"));
+		});
+		this.finishPending(streamId, false);
+	}
+	finishPending(streamId, cancelOpenUpload) {
+		const pending = this.pending.get(streamId);
+		if (pending === void 0) return;
+		if (cancelOpenUpload && pending.uploadOpen) {
+			pending.uploadOpen = false;
+			pending.requestReader?.cancel().catch(() => void 0);
+			this.enqueueRequestFrame(encodeDesktopRequestCancel(streamId)).catch((error) => {
+				this.fail(errorOf(error, "dsh desktop request pipe failed"));
+			});
+		}
+		pending.removeAbort?.();
+		this.pending.delete(streamId);
+		this.blockedResponses.delete(streamId);
+		this.resumeResponsePipe();
+	}
+	resumeResponsePipe() {
+		if (this.blockedResponses.size === 0) this.responsePipe?.resume();
+	}
+	handleMessage(message) {
+		switch (message.type) {
+			case "ready":
+				this.readyResolve(message);
+				return;
+			case "fatal":
+				this.fail(new Error(message.message));
+				return;
+		}
+	}
+	fail(error) {
+		this.readyReject(error);
+		for (const pending of this.pending.values()) {
+			pending.requestReader?.cancel(error).catch(() => void 0);
+			if (pending.controller === void 0) pending.reject(error);
+			else pending.controller.error(error);
+			pending.removeAbort?.();
+		}
+		this.pending.clear();
+		this.blockedResponses.clear();
+		this.responsePipe?.resume();
+	}
+};
+//#endregion
+//#region src/shell-env.ts
+/**
+* Unix backend launch with user-shell environment injection: when the user's
+* `$SHELL` has a matching rc file (`~/.bashrc` for bash, `~/.zshrc` for zsh),
+* the backend command is spawned through `$SHELL -c 'source <rc> >/dev/null
+* 2>&1; exec <command> <args...>'` so the backend inherits the user's terminal
+* environment (API keys and other exports). `exec` keeps the same process, so
+* the supervisor's wait and process-group semantics are unaffected; the source
+* output is discarded so it never pollutes the backend's stdout. The child is
+* detached into its own process group so the shell can terminate the whole
+* backend tree on exit. Windows spawns directly.
+* @module @morlay/dsh-desktopify
+*/
+/** rc file to source for one shell basename; empty means no injection. */
+function rcFileFor(shell) {
+	switch (basename(shell)) {
+		case "bash": return "~/.bashrc";
+		case "zsh": return "~/.zshrc";
+		default: return "";
+	}
+}
+/** Single-quote a string for shell command lines (paths may contain spaces). */
+function shellQuote(value) {
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+/**
+* Spawn a backend command through the user shell with rc sourcing on Unix,
+* directly otherwise. The child joins a new process group (detached) so the
+* shell can terminate the whole backend tree on exit.
+* @param command - backend executable (bundled node or the Electron binary in node mode).
+* @param args - backend arguments.
+* @param options - spawn options (env, stdio pipes, cwd).
+* @returns the spawned child.
+*/
+function shellWrappedSpawn(command, args, options) {
+	const shell = process.env.SHELL;
+	const rc = shell === void 0 || shell === "" ? "" : rcFileFor(shell);
+	if (rc !== "" && process.platform !== "win32" && shell !== void 0) {
+		const commandLine = `source ${rc} >/dev/null 2>&1; exec ${shellQuote(command)} ${args.map(shellQuote).join(" ")}`;
+		return spawn(shell, ["-c", commandLine], {
+			...options,
+			detached: true
+		});
+	}
+	return spawn(command, [...args], {
+		...options,
+		detached: process.platform !== "win32"
+	});
+}
+//#endregion
+//#region src/index.ts
+/**
+* Electron shell: window, `dsh-app://` custom protocol, and the dsh backend
+* child lifecycle. The backend is the upstream `@deepseek-ai/dsh-desktop-host`
+* entry run under a bundled Node.js executable (packaged) or the current
+* Electron executable in node mode (development); requests from the renderer
+* are forwarded over framed byte pipes. On Unix the backend inherits the
+* user's shell environment through rc sourcing (see shell-env.ts).
+* @module @morlay/dsh-desktopify
+*/
+const SCHEME = "dsh-app";
+let focusPrimaryWindow = () => {};
+protocol.registerSchemesAsPrivileged([{
+	scheme: SCHEME,
+	privileges: {
+		standard: true,
+		secure: true,
+		supportFetchAPI: true,
+		corsEnabled: false,
+		stream: true,
+		codeCache: true
+	}
+}]);
+const MIME = {
+	".css": "text/css; charset=utf-8",
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".svg": "image/svg+xml"
+};
+function runtimeResources() {
+	const development = !app.isPackaged;
+	return {
+		node: (development ? process.env.DSH_DESKTOP_NODE_BINARY : void 0) ?? join(process.resourcesPath, "runtime", "node", process.platform === "win32" ? "node.exe" : "node"),
+		seed: (development ? process.env.DSH_DESKTOP_SEED_DIR : void 0) ?? join(process.resourcesPath, "seed")
+	};
+}
+function developmentProject() {
+	const configured = process.env.DSH_DESKTOP_DEV_PROJECT_DIR;
+	if (configured === void 0 || configured === "") return void 0;
+	if (app.isPackaged) throw new Error("dsh desktop: development project override is unavailable in packaged applications");
+	return resolve(configured);
+}
+/**
+* 无标题栏窗口框架：macOS 隐藏标题栏（保留交通灯，顶部仍可拖动）；Windows
+* 隐藏标题栏并用 `titleBarOverlay` 保留系统窗口控制按钮（透明底、中性符号
+* 色，避免与页面内容冲突）；其余平台去掉系统边框。
+*/
+function windowFrame() {
+	if (process.platform === "darwin") return { titleBarStyle: "hidden" };
+	if (process.platform === "win32") return {
+		titleBarStyle: "hidden",
+		titleBarOverlay: {
+			color: "#00000000",
+			symbolColor: "#888888"
+		}
+	};
+	return { frame: false };
+}
+function createWindow(preload, config) {
+	const window = new BrowserWindow({
+		width: config.width,
+		height: config.height,
+		minWidth: config.minWidth,
+		minHeight: config.minHeight,
+		show: false,
+		...windowFrame(),
+		webPreferences: {
+			preload,
+			nodeIntegration: false,
+			contextIsolation: true,
+			sandbox: true,
+			webSecurity: true
+		}
+	});
+	window.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
+	window.webContents.on("will-navigate", (event, url) => {
+		if (new URL(url).protocol !== `${SCHEME}:`) event.preventDefault();
+	});
+	return window;
+}
+async function serveShellAsset(request) {
+	if (request.method !== "GET" && request.method !== "HEAD") return new Response(null, { status: 405 });
+	const root = resolve(app.getAppPath(), "renderer");
+	const url = new URL(request.url);
+	let pathname;
+	try {
+		pathname = decodeURIComponent(url.pathname);
+	} catch {
+		return new Response(null, { status: 400 });
+	}
+	const target = resolve(normalize(join(root, pathname)));
+	if (target !== root && !target.startsWith(root + sep)) return new Response(null, { status: 403 });
+	try {
+		const body = request.method === "HEAD" ? null : await readFile(target);
+		return new Response(body, { headers: { "content-type": MIME[extname(target)] ?? "application/octet-stream" } });
+	} catch {
+		return new Response(null, { status: 404 });
+	}
+}
+function developmentHostInspectPort(enabled) {
+	const configured = process.env.DSH_DESKTOP_HOST_INSPECT_PORT;
+	if (!enabled || configured === void 0 || configured === "") return void 0;
+	const port = Number(configured);
+	if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new Error("dsh desktop: DSH_DESKTOP_HOST_INSPECT_PORT must be an integer from 1 through 65535");
+	return port;
+}
+/**
+* Development host Node arguments. The launcher sets `DSH_DESKTOP_TSX_IMPORT`
+* only when the workspace actually has tsx installed, so a workspace without
+* it never receives a loader it cannot resolve.
+*/
+function developmentNodeArgs() {
+	const specifier = process.env.DSH_DESKTOP_TSX_IMPORT;
+	return specifier === void 0 || specifier === "" ? [] : [`--import=${specifier}`];
+}
+async function main() {
+	const development = developmentProject();
+	const config = development === void 0 ? loadAppConfig(process.resourcesPath) : loadAppConfig(process.env.DSH_DESKTOP_APPCONFIG_DIR ?? process.resourcesPath);
+	const resources = runtimeResources();
+	const hostInspectPort = developmentHostInspectPort(development !== void 0);
+	const activeProject = development ?? join(resolveDshHome(config) ?? "", "profiles", "desktop");
+	const dshHome = resolveDshHome(config);
+	if (development === void 0) {
+		if (dshHome === void 0) throw new Error("dsh desktop: packaged applications require a concrete dshHome");
+		ensureSeedProfile(resources.seed, dshHome);
+	}
+	let host;
+	let mainWindow;
+	let quitConfirmed = false;
+	let quitPrompting = false;
+	const appPreload = fileURLToPath(new URL("./preload-app.cjs", import.meta.url));
+	/**
+	* 退出确认：红叉 / Cmd+Q / 菜单退出都先问一次，避免误关把后台 host 与
+	* 运行中的会话一起强杀。确认后置 quitConfirmed 并重新走退出流程。
+	*/
+	const confirmQuit = async (window) => {
+		if (quitPrompting) return;
+		quitPrompting = true;
+		try {
+			const options = {
+				type: "question",
+				buttons: ["Cancel", "Quit"],
+				defaultId: 0,
+				cancelId: 0,
+				noLink: true,
+				message: `Quit ${config.name}?`,
+				detail: "The desktop backend and its running sessions will stop."
+			};
+			const parent = window ?? mainWindow;
+			const { response } = parent === void 0 || parent.isDestroyed() ? await dialog.showMessageBox(options) : await dialog.showMessageBox(parent, options);
+			if (response !== 1) return;
+			quitConfirmed = true;
+			app.quit();
+		} finally {
+			quitPrompting = false;
+		}
+	};
+	const startHost = async (projectDir = activeProject) => {
+		const next = new DesktopHostProcess(resources.node, projectDir, hostInspectPort, {
+			nodeArgs: development === void 0 ? [] : developmentNodeArgs(),
+			extraEnv: {
+				...dshHome === void 0 ? {} : { DSH_HOME: dshHome },
+				...development === void 0 ? {} : { ELECTRON_RUN_AS_NODE: "1" }
+			},
+			spawn: shellWrappedSpawn
+		});
+		await next.start();
+		return next;
+	};
+	protocol.handle(SCHEME, (request) => {
+		const url = new URL(request.url);
+		if (url.hostname === "shell") return serveShellAsset(request);
+		if (url.hostname !== "app") return Promise.resolve(new Response(null, { status: 404 }));
+		const active = host;
+		if (active === void 0) return Promise.resolve(new Response("backend unavailable", { status: 503 }));
+		return active.fetch(request);
+	});
+	const createMainWindow = () => {
+		const window = createWindow(appPreload, config.window);
+		mainWindow = window;
+		window.once("ready-to-show", () => {
+			if (!window.isDestroyed()) window.show();
+		});
+		window.on("close", (event) => {
+			if (quitConfirmed) return;
+			event.preventDefault();
+			confirmQuit(window);
+		});
+		window.on("closed", () => {
+			if (mainWindow === window) mainWindow = void 0;
+		});
+		return window;
+	};
+	focusPrimaryWindow = () => {
+		const window = mainWindow;
+		if (window === void 0 || window.isDestroyed()) {
+			createMainWindow().loadURL(`${SCHEME}://app/index.html`);
+			return;
+		}
+		if (window.isMinimized()) window.restore();
+		window.show();
+		window.focus();
+	};
+	host = await startHost();
+	mainWindow = createMainWindow();
+	await mainWindow.loadURL(`${SCHEME}://app/index.html`);
+	if (development !== void 0 && process.env.DSH_DESKTOP_OPEN_DEVTOOLS !== "0") mainWindow.webContents.openDevTools({ mode: "detach" });
+	app.on("activate", () => {
+		if (BrowserWindow.getAllWindows().length === 0) focusPrimaryWindow();
+	});
+	app.on("window-all-closed", () => {
+		app.quit();
+	});
+	app.on("before-quit", (event) => {
+		if (!quitConfirmed) {
+			event.preventDefault();
+			confirmQuit();
+			return;
+		}
+		if (host === void 0) return;
+		event.preventDefault();
+		const active = host;
+		host = void 0;
+		active.stop().finally(() => {
+			app.quit();
+		});
+	});
+}
+if ((() => {
+	if (!app.requestSingleInstanceLock()) {
+		app.quit();
+		return false;
+	}
+	app.on("second-instance", () => {
+		focusPrimaryWindow();
+	});
+	return true;
+})()) app.whenReady().then(main).catch(async (error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(error);
+	const diagnosticFile = process.env.DSH_DESKTOP_DIAGNOSTIC_FILE;
+	if (diagnosticFile !== void 0) await import("node:fs/promises").then((fs) => fs.writeFile(diagnosticFile, `${error instanceof Error ? error.stack ?? message : message}\n`)).catch(() => void 0);
+	dialog.showErrorBox("dsh desktop startup failed", message);
+	app.exit(1);
+});
+//#endregion
+export {};