@morlay/dsh-desktopify 0.1.0 → 0.1.1

package/README.md

@@ -37,15 +37,18 @@
   `src/cli/electron-builder.ts` 内配置（无独立配置文件）。壳以最小 app
   目录（`dist/` + 入口 manifest，版本取工作区版本）打包，工具自身的构建
   依赖不进 app；`--dir` 产出未打包的应用目录，不签名、不 notarize。
-- **后端**：直接复用上游已构建的 `@deepseek-ai/dsh-desktop-host`（字节管
-  道协议），不重复实现 boot 逻辑。
+- **后端**：复用上游已构建的 desktop-host 产物（字节管道协议），不重复实现
+  boot 逻辑。上游 `@deepseek-ai/dsh-desktop-host` 是 `private` 包、不发布，
+  所以 `tsdown.config.ts` 构建时把它的 `lib/index.js` +
+  `config/desktop.cordis.patch.yml` + manifest `copy` 进 `dist/desktop-host`，
+  运行时从这里装配；`package.json` 不再依赖该私有包，可正常发布。
 - **官方依赖内部维护**：`@deepseek-ai/*` 依赖清单（dsh、dsh-desktop-host、
   cordis-plugin-group 及约 20 个 peer 包）由工具内部维护
   （`src/official.ts`），app 只声明自己的依赖、`dsh.version` 与 bundles。
   官方依赖 spec 由工具按 `dsh.version` + 已安装包解析
   （`src/cli/official-deps.ts`）：app 工作区优先，工具自身安装兜底，不写死
-  `workspace:`，仓库外的独立项目同样可装配；`dsh-desktop-host` 未发布，
-  固定由工具引入（同一 workspace 用 `link:`，独立项目暂存后 `file:`）。
+  `workspace:`，仓库外的独立项目同样可装配；desktop-host 用工具自带的产物
+  （同一 workspace 用 `link:`，独立项目暂存后 `file:`）。
 - **bundles 自动合并**：官方 bundles（`@deepseek-ai/dsh-base`、
   `@deepseek-ai/dsh-web-app`）+ app 的 `dsh.profile.bundles` 自动合并进 dev
   项目与种子 profile。
@@ -118,5 +121,7 @@
 
 - pnpm workspace（dev 依赖 `findWorkspaceRoot` 装配临时项目；bundle 依赖
   `pnpm deploy`）。
-- `vendor/deepseek-harness` 已构建（dev 需要 dsh CLI 与 desktop-host 的
-  `lib/` 产物）。
+- `vendor/deepseek-harness` 已构建（`just vendor prepare`：dev 需要 dsh CLI，
+  工具构建需要 desktop-host 的 `lib/` 产物来 stage 进 `dist/desktop-host`）。
+- 工具自身已构建（`pnpm build`）：dev / bundle 用 `dist/desktop-host` 里的
+  后端产物。

package/dist/cli/index.mjs

@@ -2,7 +2,7 @@
 import { a as writeAppConfig, t as SEED_HASH_NAME } from "../seed-Ca0AMFtp.mjs";
 import { createRequire } from "node:module";
 import { chmod, readFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { cpSync, createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
@@ -400,9 +400,8 @@ async function runPrepareRuntime(options) {
 * repository resolves the same way:
 *   - `@deepseek-ai/dsh` → `dsh.version` when declared (concrete version,
 *     range, or `workspace:` in-tree), else `^<resolved>`;
-*   - `@deepseek-ai/dsh-desktop-host` → `link:<dir>`, or a staged `file:`
-*     copy when the host lives outside the app workspace (the host is not
-*     published, so it always comes from the tool);
+*   - `@deepseek-ai/dsh-desktop-host` → the tool's own bundled host artifact
+*     (upstream never publishes it), `link:<dir>` or a staged `file:` copy;
 *   - every other official package → `^<resolved>`.
 *
 * `hasTsx` reports whether the workspace can load TypeScript sources directly;
@@ -444,6 +443,29 @@ function resolveOfficialPackage(packageName, input) {
 	}
 }
 /**
+* The tool's bundled desktop-host artifact. Upstream keeps
+* `@deepseek-ai/dsh-desktop-host` private (never published), so the tool ships
+* its built output itself: `dist/desktop-host`, written by the `tsdown` build.
+*/
+function desktopHostDir(toolRoot) {
+	const dir = join(toolRoot, "dist", "desktop-host");
+	return existsSync(join(dir, "lib", "index.js")) ? realpathSync(dir) : void 0;
+}
+/** The bundled desktop host, or `undefined` when it has not been built. */
+function desktopHost(input) {
+	const dir = desktopHostDir(input.toolRoot);
+	if (dir === void 0) return void 0;
+	try {
+		const value = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		return typeof value.version === "string" && value.version !== "" ? {
+			dir,
+			version: value.version
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+/**
 * The tool's own `node_modules` root holding the official surface, used as a
 * dev fallback for an app that declares only `dsh.version` and has not
 * installed the official packages itself. Prefers the surrounding store (the
@@ -465,17 +487,22 @@ function officialDependencySpecs(input) {
 	const specs = {};
 	const missing = [];
 	for (const packageName of OFFICIAL_RUNTIME_PACKAGES) {
-		const resolved = resolveOfficialPackage(packageName, input);
 		if (packageName === "@deepseek-ai/dsh" && input.dshVersion !== void 0) {
 			specs[packageName] = input.dshVersion;
 			continue;
 		}
-		if (resolved === void 0) {
-			missing.push(packageName);
+		if (packageName === "@deepseek-ai/dsh-desktop-host") {
+			const host = desktopHost(input);
+			if (host === void 0) {
+				missing.push(packageName);
+				continue;
+			}
+			specs[packageName] = `link:${host.dir}`;
 			continue;
 		}
-		if (packageName === "@deepseek-ai/dsh-desktop-host") {
-			specs[packageName] = `link:${resolved.dir}`;
+		const resolved = resolveOfficialPackage(packageName, input);
+		if (resolved === void 0) {
+			missing.push(packageName);
 			continue;
 		}
 		specs[packageName] = `^${resolved.version}`;
@@ -483,24 +510,18 @@ function officialDependencySpecs(input) {
 	if (missing.length > 0) throw new Error(`dsh-desktopify: cannot resolve official packages ${missing.join(", ")}; install them in the workspace or run from the tool's own install`);
 	return specs;
 }
-/** Whether `candidate` is `root` itself or nested under it. */
-function isInside(root, candidate) {
-	const rel = relative(resolve(root), resolve(candidate));
-	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
-}
 /**
-* Dependency spec for the private desktop host in a `pnpm deploy` closure.
+* Dependency spec for the tool's desktop host in a `pnpm deploy` closure.
 *
-* In-repo the host lives inside the same pnpm workspace, so a `link:` spec is
-* copied by deploy. When the app workspace is elsewhere, `pnpm deploy` refuses
-* paths outside it: stage a copy inside the app workspace (with the host's
-* `workspace:` dependencies rewritten to the specs already computed) and use a
-* `file:` spec. The staged directory is temporary and removed by the caller.
+* `pnpm deploy` only copies linked packages that are workspace members, so a
+* `link:` to the tool's own `dist/desktop-host` would be dropped. Stage a copy
+* inside the app workspace instead (with the host's `workspace:` dependencies
+* rewritten to the specs already computed) and inject it as a `file:` dep. The
+* staged directory is temporary and removed by the caller.
 */
 function stageDesktopHost(input, specs) {
-	const host = resolveOfficialPackage(DESKTOP_HOST_PACKAGE, input);
-	if (host === void 0) throw new Error(`dsh-desktopify: cannot resolve ${DESKTOP_HOST_PACKAGE}`);
-	if (isInside(input.workspaceRoot, host.dir)) return `link:${host.dir}`;
+	const host = desktopHost(input);
+	if (host === void 0) throw new Error(`dsh-desktopify: bundled ${DESKTOP_HOST_PACKAGE} is missing; run the tool build (pnpm build)`);
 	const staged = join(input.workspace, ".dsh-desktopify-host");
 	rmSync(staged, {
 		recursive: true,
@@ -1052,9 +1073,9 @@ function mirrorDependencyLinks(sourceRoot, destinationRoot, skipExisting = false
 function prepareDevelopmentProject(projectDir, workspace, input) {
 	const manifest = workspaceManifest(workspace);
 	const dsh = resolveOfficialPackage(DSH_PACKAGE, input);
-	const host = resolveOfficialPackage(DESKTOP_HOST_PACKAGE, input);
+	const host = desktopHost(input);
 	if (dsh === void 0) throw new Error(`desktop development: cannot resolve ${DSH_PACKAGE}`);
-	if (host === void 0) throw new Error(`desktop development: cannot resolve ${DESKTOP_HOST_PACKAGE}`);
+	if (host === void 0) throw new Error(`desktop development: bundled ${DESKTOP_HOST_PACKAGE} is missing; run the tool build (pnpm build)`);
 	const virtualStore = join(input.workspaceRoot, "node_modules", ".pnpm", "node_modules");
 	const workspaceDependencyDir = existsSync(virtualStore) ? virtualStore : join(workspace, "node_modules");
 	if (!existsSync(workspaceDependencyDir)) throw new Error(`desktop development: workspace dependency links are missing under ${workspaceDependencyDir}; run pnpm install`);

package/dist/desktop-host/config/desktop.cordis.patch.yml

@@ -0,0 +1,34 @@
+# Electron reuses the browser composition without its network and browser-launch rows.
+
+- id: web-startup
+  disabled: true
+
+- id: webserver
+  disabled: true
+
+- id: web-runtime
+  disabled: true
+
+- id: client-hmr
+  disabled: true
+
+- id: open-in-app
+  disabled: true
+
+- id: ui-open-in-app
+  disabled: true
+
+- id: directory-picker
+  disabled: true
+
+- id: connection
+  inject:
+    - credentials
+  config: {}
+
+- insert:
+    - id: directory-picker-native
+      name: '@deepseek-ai/dsh-host-directory-picker-native'
+
+    - id: ui-directory-picker-native
+      name: '@deepseek-ai/dsh-client-ui-directory-picker-native'

package/dist/desktop-host/lib/index.js

@@ -0,0 +1,609 @@
+import { createRequire } from "node:module";
+import { closeSync, createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { once } from "node:events";
+import { readFile } from "node:fs/promises";
+import { dirname, extname, join, normalize, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { boot, composeEntries, loadLayeredEnv, loadOverlayPatches, loadProfileDirectory } from "@deepseek-ai/dsh-app-boot";
+import { provideCmdline } from "@deepseek-ai/dsh-cmdline";
+import { DSH_LAUNCH_ENVIRONMENT_KEY } from "@deepseek-ai/dsh-launch-environment";
+import { renderIndexInjections } from "@deepseek-ai/dsh-host-webserver";
+//#region lib/types/wire.js
+/** Framed request and response bytes for the Electron Desktop Host transport. */
+/** Protocol version shared with the Electron shell. */
+const DESKTOP_HOST_PROTOCOL_VERSION = 3;
+/** Maximum raw body bytes carried by one data frame. */
+const DESKTOP_PIPE_CHUNK_BYTES = 64 * 1024;
+const FRAME_MAGIC = 1146308659;
+const FRAME_HEADER_BYTES = 13;
+const MAX_CONTROL_PAYLOAD_BYTES = 1024 * 1024;
+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$1(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 === RESPONSE_FRAME_DATA ? DESKTOP_PIPE_CHUNK_BYTES : MAX_CONTROL_PAYLOAD_BYTES;
+	if (payload.byteLength > limit) throw new Error(`dsh desktop: response 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 response metadata before any body frames. */
+function encodeDesktopResponseStart(streamId, response) {
+	return encodeJsonFrame(RESPONSE_FRAME_START, streamId, response);
+}
+/** Encode one bounded raw response-body chunk. */
+function encodeDesktopResponseData(streamId, data) {
+	return encodeFrame(RESPONSE_FRAME_DATA, streamId, Buffer.from(data));
+}
+/** Encode normal response completion. */
+function encodeDesktopResponseEnd(streamId) {
+	return encodeFrame(RESPONSE_FRAME_END, streamId, Buffer.alloc(0));
+}
+/** Encode one response failure without exposing an Error object across processes. */
+function encodeDesktopResponseError(streamId, message) {
+	return encodeJsonFrame(RESPONSE_FRAME_ERROR, streamId, { message });
+}
+/** Incrementally decode validated request frames from the Electron byte pipe. */
+var DesktopHostRequestDecoder = class {
+	buffer = Buffer.alloc(0);
+	/**
+	* Append bytes and return every complete request frame.
+	* @param chunk - next bytes read from the Electron request 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: Electron request 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 Electron request 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 === REQUEST_FRAME_DATA ? DESKTOP_PIPE_CHUNK_BYTES : MAX_CONTROL_PAYLOAD_BYTES;
+		if (payloadLength > limit) throw new Error(`dsh desktop: Electron request 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 REQUEST_FRAME_START: return this.parseStart(streamId, payload);
+			case REQUEST_FRAME_DATA: return {
+				type: "data",
+				streamId,
+				data: payload
+			};
+			case REQUEST_FRAME_END:
+				if (payloadLength !== 0) throw new Error("dsh desktop: Electron request end frame carried a payload");
+				return {
+					type: "end",
+					streamId
+				};
+			case REQUEST_FRAME_CANCEL:
+				if (payloadLength !== 0) throw new Error("dsh desktop: Electron request cancel frame carried a payload");
+				return {
+					type: "cancel",
+					streamId
+				};
+			default: throw new Error(`dsh desktop: unknown Electron request frame type ${String(rawType)}`);
+		}
+	}
+	parseStart(streamId, payload) {
+		let value;
+		try {
+			value = JSON.parse(payload.toString("utf8"));
+		} catch (error) {
+			throw new Error(`dsh desktop: Electron request start payload is not JSON: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!isRecord$1(value) || typeof value.url !== "string" || typeof value.method !== "string" || !isHeaders(value.headers) || typeof value.hasBody !== "boolean") throw new Error("dsh desktop: invalid Electron request start payload");
+		return {
+			type: "start",
+			streamId,
+			url: value.url,
+			method: value.method,
+			headers: value.headers,
+			hasBody: value.hasBody
+		};
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/**
+* Electron child-process entry: boots the desktop project without a listening
+* socket and carries API plus validated Web assets over framed byte pipes.
+* @module @deepseek-ai/dsh-desktop-host
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isDesktopHostCommand(message) {
+	return typeof message === "object" && message !== null && "type" in message && message.type === "shutdown";
+}
+const DESKTOP_PATCH = fileURLToPath(new URL("../config/desktop.cordis.patch.yml", import.meta.url));
+const ROOT_CONFIG = "# Electron desktop composition root; package transactions own this file.\n[]\n";
+const ROOT_CONFIG_FILENAME = "desktop.cordis.yml";
+const DESKTOP_STREAM_PATH = "/.dsh/remote-stream";
+const DESKTOP_TRANSPORT_SCRIPT = `globalThis.__DSH_TRANSPORT__={
+  ownsHost:true,
+  async *openStream(endpoint,payload,signal){
+    const response=await fetch(${JSON.stringify(DESKTOP_STREAM_PATH)},{
+      method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({endpoint,payload}),signal
+    })
+    if(!response.ok||response.body===null)throw new Error('desktop stream transport failed: HTTP '+response.status)
+    const reader=response.body.getReader(),decoder=new TextDecoder()
+    let pending=''
+    for(;;){
+      const {done,value}=await reader.read()
+      pending+=decoder.decode(value,{stream:!done})
+      let newline
+      while((newline=pending.indexOf('\\n'))!==-1){
+        const line=pending.slice(0,newline);pending=pending.slice(newline+1)
+        if(line!=='')yield JSON.parse(line)
+      }
+      if(done)break
+    }
+    if(pending!=='')yield JSON.parse(pending)
+  }
+}`;
+const MIME = {
+	".css": "text/css; charset=utf-8",
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".webmanifest": "application/manifest+json"
+};
+function readManifest(path) {
+	const value = JSON.parse(readFileSync(path, "utf8"));
+	if (!isRecord(value)) throw new Error(`dsh desktop: ${path} must contain a package manifest`);
+	return {
+		...typeof value.name === "string" ? { name: value.name } : {},
+		...typeof value.version === "string" ? { version: value.version } : {}
+	};
+}
+function packageManifestPath(projectDir, packageName) {
+	const path = join(projectDir, "node_modules", ...packageName.split("/"), "package.json");
+	if (!existsSync(path)) throw new Error(`dsh desktop: installed package ${JSON.stringify(packageName)} has no manifest`);
+	return path;
+}
+function isProjectPath(projectDir, target) {
+	const root = realpathSync(projectDir);
+	const path = realpathSync(target);
+	return path === root || path.startsWith(root + sep);
+}
+function desktopPatches(projectDir, allowLinkedPackages) {
+	const dshRoot = dirname(packageManifestPath(projectDir, "@deepseek-ai/dsh"));
+	const profile = loadProfileDirectory("dsh desktop", projectDir, join(dshRoot, "package.json"));
+	for (const layer of profile.layers) if (!allowLinkedPackages && !isProjectPath(projectDir, layer.packageDir)) throw new Error(`dsh desktop: profile bundle ${JSON.stringify(layer.packageName)} resolved outside the desktop profile`);
+	const layers = [
+		...profile.layers.map((layer) => layer.patches),
+		profile.patches,
+		loadOverlayPatches("dsh desktop", DESKTOP_PATCH)
+	];
+	const agentPresets = new Map(composeEntries(layers).flatMap((row) => typeof row.id === "string" ? [[row.id, row]] : [])).get("agent-presets");
+	if (agentPresets !== void 0) layers.push([{
+		id: "agent-presets",
+		config: {
+			...agentPresets.config ?? {},
+			roots: [{
+				path: join(dshRoot, "config", "agent-presets"),
+				trust: "system"
+			}]
+		}
+	}]);
+	return layers.flat();
+}
+function dshVersion(projectDir) {
+	const manifest = readManifest(packageManifestPath(projectDir, "@deepseek-ai/dsh"));
+	if (typeof manifest.version !== "string") throw new Error("dsh desktop: installed dsh manifest has no version");
+	return manifest.version;
+}
+function assetHandler(ctx, projectDir) {
+	const distIndex = createRequire(join(projectDir, "package.json")).resolve("@deepseek-ai/dsh-web-frontend/dist/index.html");
+	const distRoot = realpathSync(dirname(distIndex));
+	const renderIndex = async () => {
+		const rows = [{
+			kind: "script",
+			placement: "head",
+			text: DESKTOP_TRANSPORT_SCRIPT
+		}];
+		ctx.emit("webserver/index-inject", rows);
+		const body = renderIndexInjections(await readFile(distIndex, "utf8"), rows);
+		return new Response(body, { headers: { "content-type": MIME[".html"] ?? "text/html; charset=utf-8" } });
+	};
+	return {
+		requestBodyMode: () => "buffered",
+		async fetch(request) {
+			if (request.method !== "GET" && request.method !== "HEAD") return new Response(null, { status: 405 });
+			const url = new URL(request.url);
+			if (url.pathname.startsWith("/plugins/")) return ctx.clientModules.fetchBundle(request);
+			let pathname;
+			try {
+				pathname = decodeURIComponent(url.pathname);
+			} catch {
+				return new Response(null, { status: 400 });
+			}
+			if (pathname === "/" || pathname === "/index.html") return renderIndex();
+			const target = resolve(normalize(join(distRoot, pathname)));
+			if (target !== distRoot && !target.startsWith(distRoot + sep)) return new Response(null, { status: 403 });
+			try {
+				const realTarget = realpathSync(target);
+				if (realTarget !== distRoot && !realTarget.startsWith(distRoot + sep)) return new Response(null, { status: 403 });
+				return new Response(request.method === "HEAD" ? null : await readFile(realTarget), { headers: { "content-type": MIME[extname(realTarget)] ?? "application/octet-stream" } });
+			} catch {
+				return renderIndex();
+			}
+		}
+	};
+}
+function remoteStreamHandler(ctx) {
+	return {
+		requestBodyMode: () => "buffered",
+		async fetch(request) {
+			if (request.method !== "POST") return new Response(null, { status: 405 });
+			const gateway = ctx.get("typertGateway");
+			if (gateway === void 0) return new Response("gateway unavailable", { status: 503 });
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return new Response("body is not JSON", { status: 400 });
+			}
+			if (!isRecord(body) || typeof body.endpoint !== "string") return new Response("invalid stream request", { status: 400 });
+			const abort = new AbortController();
+			const cancel = () => {
+				abort.abort(request.signal.reason);
+			};
+			request.signal.addEventListener("abort", cancel, { once: true });
+			const encoder = new TextEncoder();
+			const stream = new ReadableStream({
+				async start(controller) {
+					try {
+						const values = await gateway.wireStream.open(body.endpoint, body.payload, abort.signal);
+						for await (const value of values) controller.enqueue(encoder.encode(`${JSON.stringify(value)}\n`));
+						controller.close();
+					} catch (error) {
+						controller.error(error);
+					} finally {
+						request.signal.removeEventListener("abort", cancel);
+					}
+				},
+				cancel(reason) {
+					abort.abort(reason);
+					request.signal.removeEventListener("abort", cancel);
+				}
+			});
+			return new Response(stream, { headers: { "content-type": "application/x-ndjson" } });
+		}
+	};
+}
+/**
+* Boot one installed desktop npm project.
+* @param projectDir - active or staged Electron-owned desktop profile.
+* @param writeResponse - serialized response-pipe writer that applies byte backpressure.
+* @param options - development-only allowance for workspace-linked bundle packages.
+* @returns controller after every Host and client-manifest row is active.
+*/
+async function runDesktopHost(projectDir, writeResponse, options = {}) {
+	const absoluteProject = resolve(projectDir);
+	mkdirSync(absoluteProject, { recursive: true });
+	const rootConfig = join(absoluteProject, ROOT_CONFIG_FILENAME);
+	writeFileSync(rootConfig, ROOT_CONFIG);
+	const environment = loadLayeredEnv("dsh desktop");
+	let current;
+	const ctx = await boot("dsh desktop", rootConfig, structuredClone(desktopPatches(absoluteProject, options.allowLinkedPackages === true)), (hostCtx) => {
+		current = hostCtx;
+		hostCtx.provide(DSH_LAUNCH_ENVIRONMENT_KEY, environment);
+		provideCmdline(hostCtx, {
+			args: [],
+			exit: () => {}
+		});
+	});
+	current = ctx;
+	const connection = ctx.get("connection");
+	const clientModules = ctx.get("clientModules");
+	const gateway = ctx.get("typertGateway");
+	if (connection === void 0 || clientModules === void 0 || gateway === void 0) {
+		await ctx.fiber.dispose();
+		throw new Error("dsh desktop: composition did not provide connection, typertGateway, and clientModules");
+	}
+	const api = connection.createSharedFetchHandler("/api");
+	const assets = assetHandler(ctx, absoluteProject);
+	const streams = remoteStreamHandler(ctx);
+	const requests = /* @__PURE__ */ new Map();
+	let disposing;
+	const dispose = async () => {
+		disposing ??= (async () => {
+			for (const controller of requests.values()) controller.abort();
+			requests.clear();
+			await current?.fiber.dispose();
+			current = void 0;
+		})();
+		await disposing;
+	};
+	return {
+		dshVersion: dshVersion(absoluteProject),
+		cancel(streamId) {
+			requests.get(streamId)?.abort();
+		},
+		async fetch(command, body) {
+			if (disposing !== void 0) throw new Error("dsh desktop: host is disposing");
+			const controller = new AbortController();
+			requests.set(command.streamId, controller);
+			try {
+				const url = new URL(command.request.url);
+				const init = {
+					method: command.request.method,
+					headers: new Headers(command.request.headers.map(([name, value]) => [name, value])),
+					...body === null ? {} : {
+						body,
+						duplex: "half"
+					},
+					signal: controller.signal
+				};
+				const request = new Request(url, init);
+				const response = url.pathname === DESKTOP_STREAM_PATH ? await streams.fetch(request) : url.pathname.startsWith("/api/") ? await api.fetch(request) : await assets.fetch(request);
+				await writeResponse(encodeDesktopResponseStart(command.streamId, {
+					status: response.status,
+					headers: [...response.headers.entries()],
+					hasBody: response.body !== null
+				}));
+				if (response.body !== null) for await (const chunk of response.body) {
+					const bytes = Buffer.from(chunk);
+					for (let offset = 0; offset < bytes.byteLength; offset += DESKTOP_PIPE_CHUNK_BYTES) await writeResponse(encodeDesktopResponseData(command.streamId, bytes.subarray(offset, offset + DESKTOP_PIPE_CHUNK_BYTES)));
+				}
+				await writeResponse(encodeDesktopResponseEnd(command.streamId));
+			} catch (error) {
+				if (!controller.signal.aborted) await writeResponse(encodeDesktopResponseError(command.streamId, error instanceof Error ? error.message : String(error)));
+			} finally {
+				requests.delete(command.streamId);
+			}
+		},
+		dispose
+	};
+}
+async function main() {
+	const projectDir = process.argv[2];
+	if (projectDir === void 0 || process.send === void 0) throw new Error("dsh desktop: expected project directory, byte pipes, and a Node IPC channel");
+	const option = process.argv[3];
+	if (option !== void 0 && option !== "--allow-linked-profile") throw new Error(`dsh desktop: unsupported internal option ${JSON.stringify(option)}`);
+	const requestPipe = createReadStream("", {
+		fd: 3,
+		autoClose: false
+	});
+	const responsePipe = createWriteStream("", {
+		fd: 4,
+		autoClose: false
+	});
+	let responseWriteTail = Promise.resolve();
+	const writeResponse = (frame) => {
+		const write = responseWriteTail.then(async () => {
+			if (responsePipe.destroyed) throw new Error("dsh desktop: Electron response pipe is unavailable");
+			if (!responsePipe.write(frame)) await once(responsePipe, "drain");
+		});
+		responseWriteTail = write.catch(() => void 0);
+		return write;
+	};
+	const send = (event) => {
+		if (process.send === void 0 || !process.connected) return;
+		try {
+			process.send(event);
+		} catch (error) {
+			if (error.code !== "ERR_IPC_CHANNEL_CLOSED") throw error;
+		}
+	};
+	const controller = await runDesktopHost(projectDir, writeResponse, { allowLinkedPackages: option !== void 0 });
+	send({
+		type: "ready",
+		protocolVersion: 3,
+		dshVersion: controller.dshVersion
+	});
+	const decoder = new DesktopHostRequestDecoder();
+	const requestBodies = /* @__PURE__ */ new Map();
+	const blockedRequests = /* @__PURE__ */ new Set();
+	const discardedRequestBodies = /* @__PURE__ */ new Set();
+	const runs = /* @__PURE__ */ new Set();
+	let lastStreamId = 0;
+	let requestedExitCode = 0;
+	let stopping;
+	const resumeRequestPipe = () => {
+		if (blockedRequests.size === 0) requestPipe.resume();
+	};
+	const stop = (exitCode = 0) => {
+		requestedExitCode = Math.max(requestedExitCode, exitCode);
+		stopping ??= (async () => {
+			requestPipe.pause();
+			requestPipe.removeAllListeners("data");
+			const stopped = /* @__PURE__ */ new Error("dsh desktop: Host is stopping");
+			for (const body of requestBodies.values()) body.error(stopped);
+			requestBodies.clear();
+			blockedRequests.clear();
+			discardedRequestBodies.clear();
+			requestPipe.destroy();
+			closeSync(3);
+			await controller.dispose();
+			await Promise.allSettled([...runs]);
+			await responseWriteTail.catch(() => void 0);
+			if (!responsePipe.destroyed) {
+				await new Promise((resolvePromise) => {
+					responsePipe.end(resolvePromise);
+				});
+				responsePipe.destroy();
+			}
+			closeSync(4);
+			if (process.connected) process.disconnect();
+			process.exitCode = requestedExitCode;
+		})();
+		return stopping;
+	};
+	const failTransport = (error) => {
+		send({
+			type: "fatal",
+			message: error instanceof Error ? error.message : String(error)
+		});
+		stop(1);
+	};
+	const beginRequest = (frame) => {
+		if (frame.streamId <= lastStreamId) throw new Error(`dsh desktop: Electron reused or reordered request stream ${String(frame.streamId)}`);
+		lastStreamId = frame.streamId;
+		let body = null;
+		if (frame.hasBody) body = new ReadableStream({
+			start(controllerOfBody) {
+				requestBodies.set(frame.streamId, controllerOfBody);
+			},
+			pull() {
+				blockedRequests.delete(frame.streamId);
+				resumeRequestPipe();
+			},
+			cancel() {
+				requestBodies.delete(frame.streamId);
+				blockedRequests.delete(frame.streamId);
+				controller.cancel(frame.streamId);
+				resumeRequestPipe();
+			}
+		});
+		const run = controller.fetch({
+			streamId: frame.streamId,
+			request: {
+				url: frame.url,
+				method: frame.method,
+				headers: frame.headers
+			}
+		}, body);
+		runs.add(run);
+		run.catch(failTransport).finally(() => {
+			runs.delete(run);
+			const openBody = requestBodies.get(frame.streamId);
+			if (openBody === void 0) return;
+			openBody.error(/* @__PURE__ */ new Error("dsh desktop: response completed before the request body ended"));
+			requestBodies.delete(frame.streamId);
+			blockedRequests.delete(frame.streamId);
+			discardedRequestBodies.add(frame.streamId);
+			resumeRequestPipe();
+		});
+	};
+	const handleRequestFrame = (frame) => {
+		switch (frame.type) {
+			case "start":
+				beginRequest(frame);
+				return;
+			case "data": {
+				const body = requestBodies.get(frame.streamId);
+				if (body === void 0) {
+					if (discardedRequestBodies.has(frame.streamId)) return;
+					throw new Error(`dsh desktop: Electron sent body data for inactive stream ${String(frame.streamId)}`);
+				}
+				body.enqueue(frame.data);
+				if ((body.desiredSize ?? 0) <= 0) {
+					blockedRequests.add(frame.streamId);
+					requestPipe.pause();
+				}
+				return;
+			}
+			case "end": {
+				const body = requestBodies.get(frame.streamId);
+				if (body === void 0) {
+					if (discardedRequestBodies.delete(frame.streamId)) return;
+					throw new Error(`dsh desktop: Electron ended inactive body stream ${String(frame.streamId)}`);
+				}
+				body.close();
+				requestBodies.delete(frame.streamId);
+				blockedRequests.delete(frame.streamId);
+				resumeRequestPipe();
+				return;
+			}
+			case "cancel":
+				if (frame.streamId > lastStreamId) throw new Error(`dsh desktop: Electron canceled unknown stream ${String(frame.streamId)}`);
+				requestBodies.get(frame.streamId)?.error(/* @__PURE__ */ new Error("dsh desktop: Electron canceled the request"));
+				requestBodies.delete(frame.streamId);
+				blockedRequests.delete(frame.streamId);
+				discardedRequestBodies.delete(frame.streamId);
+				controller.cancel(frame.streamId);
+				resumeRequestPipe();
+				return;
+			default:
+		}
+	};
+	requestPipe.on("data", (chunk) => {
+		try {
+			for (const frame of decoder.push(Buffer.from(chunk))) handleRequestFrame(frame);
+		} catch (error) {
+			failTransport(error);
+		}
+	});
+	requestPipe.once("end", () => {
+		if (stopping !== void 0) return;
+		try {
+			decoder.finish();
+			failTransport(/* @__PURE__ */ new Error("dsh desktop: Electron request pipe ended"));
+		} catch (error) {
+			failTransport(error);
+		}
+	});
+	requestPipe.once("error", failTransport);
+	responsePipe.once("error", failTransport);
+	process.on("message", (message) => {
+		if (!isDesktopHostCommand(message)) {
+			send({
+				type: "fatal",
+				message: "dsh desktop: invalid Electron IPC command"
+			});
+			stop(1);
+			return;
+		}
+		stop();
+	});
+	process.once("disconnect", () => {
+		stop();
+	});
+	process.once("SIGTERM", () => {
+		stop();
+	});
+	process.once("SIGINT", () => {
+		stop();
+	});
+}
+if (import.meta.main) main().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	if (process.send !== void 0) process.send({
+		type: "fatal",
+		message
+	});
+	else process.stderr.write(`dsh desktop: ${message}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export { DESKTOP_HOST_PROTOCOL_VERSION, runDesktopHost };

package/dist/desktop-host/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@deepseek-ai/dsh-desktop-host",
+  "description": "Private upstream-Node host process for the Electron desktop application",
+  "version": "0.1.5-rc.1",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "files": [
+    "lib/index.js",
+    "config/desktop.cordis.patch.yml"
+  ],
+  "dependencies": {
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/cordis-plugin-include": "workspace:^",
+    "@deepseek-ai/dsh": "workspace:^",
+    "@deepseek-ai/dsh-api-gateway": "workspace:^",
+    "@deepseek-ai/dsh-app-boot": "workspace:^",
+    "@deepseek-ai/dsh-client-connection": "workspace:^",
+    "@deepseek-ai/dsh-client-modules": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-directory-picker-native": "workspace:^",
+    "@deepseek-ai/dsh-cmdline": "workspace:^",
+    "@deepseek-ai/dsh-host-directory-picker-native": "workspace:^",
+    "@deepseek-ai/dsh-host-webserver": "workspace:^",
+    "@deepseek-ai/dsh-launch-environment": "workspace:^",
+    "@deepseek-ai/dsh-web-frontend": "workspace:^"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/dsh-desktopify",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Desktop packaging tool for dsh workspaces: hosts the upstream dsh-desktop-host child over framed byte pipes, with dev (workspace-linked) and bundle (static, unsigned) modes.",
   "keywords": [
     "desktop",
@@ -30,7 +30,6 @@
   },
   "dependencies": {
     "@deepseek-ai/dsh": "^0.1.5-rc.1",
-    "@deepseek-ai/dsh-desktop-host": "^0.1.5-rc.1",
     "commander": "^15.0.0",
     "electron": "^44.3.0",
     "electron-builder": "^26.16.1",