@morlay/dsh-desktop-host 0.2.4 → 0.2.6

package/src/preload-source.ts

@@ -0,0 +1,86 @@
+/**
+ * preload 的**源码**由服务现场打包成 CJS 交给壳，装配目录里因此不再有 `dist/`。
+ *
+ * 为什么需要它：sandboxed preload 有三个硬约束——只能 CJS、不能 ESM、不能 `require` 第三方（因此也挂不了
+ * 本仓库那套 TS hooks）。而它的源码是 TS（还跨几个文件：`preload-app.ts` 拉 `./stream-uplink.ts` 那些），
+ * 所以只能**打成单文件 CJS**——打包这件事放在这里做，壳就不必在装配时预先产出一份 `dist/`。
+ *
+ * 谁来取：壳在窗口创建之前（那时宿主已经就绪）取回来落盘，再把路径交给 `BrowserWindow` 的 `preload`。
+ */
+import { readFile } from "node:fs/promises";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { join } from "node:path";
+import { rolldown } from "rolldown";
+import type { Context } from "@deepseek-ai/cordis";
+
+/** 壳取 preload 的路径（`GET` 它得到可执行的 CJS 字节）。 */
+export const PRELOAD_SOURCE_PATH = "/@dsh/preload.cjs";
+
+export interface PreloadSourceOptions {
+  /** 壳包所在的目录（app 目录）：preload 的源码在它的 `src/` 下。 */
+  readonly shellRoot: string;
+}
+
+/**
+ * 把 preload 打包成单文件 CJS。
+ *
+ * @param options - 见 {@link PreloadSourceOptions}。
+ * @returns CJS 源码。
+ */
+export async function bundlePreload(options: PreloadSourceOptions): Promise<string> {
+  const bundle = await rolldown({
+    input: join(options.shellRoot, "src", "preload-app.ts"),
+    platform: "node",
+    // preload 里只能 require Electron 自己给的模块。
+    external: ["electron"],
+  });
+  try {
+    const { output } = await bundle.generate({ format: "cjs", inlineDynamicImports: true });
+    const chunk = output.find((item) => item.type === "chunk");
+    if (chunk === undefined) throw new Error("dsh desktop: preload bundling produced no chunk");
+    return chunk.code;
+  } finally {
+    await bundle.close();
+  }
+}
+
+/** 构建期打好的那份 preload（`prepareShell` 里调 {@link bundlePreload} 产出）。 */
+export const PRELOAD_BUNDLE_FILE = join("dist", "preload.cjs");
+
+/**
+ * 在宿主的 webServer 上注册 `/@dsh/preload.cjs`：壳按这条路径取走 preload 的 CJS 字节。
+ *
+ * **读的是构建期打好的文件**，不在运行时打包：现场打包要读 `src/preload-app.ts`，而打包器（rolldown）
+ * 是 native 模块、用自己的文件 IO——**读不了 asar 内的路径**（宿主跑在 Electron 上，`fs` 才被补丁照看着）。
+ * 构建期那份读进来是字节，`readFile` 对归档是透明的。
+ *
+ * @param ctx - 宿主上下文（拿 `webServer`）。
+ * @param options - 见 {@link PreloadSourceOptions}。
+ */
+export function installPreloadSource(ctx: Context, options: PreloadSourceOptions): void {
+  const file = join(options.shellRoot, PRELOAD_BUNDLE_FILE);
+  const serve = (req: IncomingMessage, res: ServerResponse): void => {
+    void (async () => {
+      let code: Buffer;
+      try {
+        code = await readFile(file);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.logger.error(`dsh desktop: preload bundle is unreadable at ${file}: ${message}`);
+        res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+        res.end(`dsh desktop: preload bundle is unreadable at ${file}: ${message}`);
+        return;
+      }
+      res.writeHead(200, {
+        "content-type": "text/javascript; charset=utf-8",
+        // 构建期定的产物（dev 形态由工具在装配时重打）：别缓存。
+        "cache-control": "no-store",
+      });
+      res.end(req.method === "HEAD" ? undefined : code);
+    })();
+  };
+  ctx.effect(
+    () => ctx.webServer.register({ kind: "exact", path: PRELOAD_SOURCE_PATH, handler: serve }),
+    `dsh-desktop-host: ${PRELOAD_SOURCE_PATH}`,
+  );
+}

package/src/settings-namespace.ts

@@ -0,0 +1,31 @@
+// 桌面形态的**账号面空壳**：本部署不要官方账号的用户界面，但那一行（`ui-settings-account`）同时是
+// **settings namespace 的 owner**——它的 `apply` 只做两件不可省的事，我们只需第一件：
+//
+// ```ts
+// ctx.inject(['settings'], (scope) => {
+//   scope.effect(() => scope.settings.configure({ auto: false }, ctx.fiber))
+// })
+// ```
+//
+// 少了这个注册，前端的 settings 镜面拿不到名册（`describeFace.view === undefined`）→ 直接 failLoad，
+// 整个设置页判 "settings are unavailable in this browser"，连 `/api/settings` 都不请求。
+//
+// 上游那一行还往页面注入 contact 配置（给它自己的账号页用），以及渲染设置页的账号页、侧栏账号菜单、
+// 首次引导层——本部署都不需要，所以停掉上游那行、由这里顶上这个注册。
+//
+// 装配方式见 `../config/desktop.cordis.patch.yml` 的 `insert`（必须写在那份 overlay 里：写在 bundle
+// 层的停用会被后来应用的层盖回去）。
+
+import type { Context } from "@deepseek-ai/cordis";
+
+export const name = "@morlay/dsh-desktop-host-settings-namespace";
+
+/**
+ * 注册 settings namespace（`auto: false` 表示这个 namespace 的界面由宿主自己安排，不走自动渲染）。
+ * @param ctx - 宿主的上下文。
+ */
+export function apply(ctx: Context): void {
+  ctx.inject(["settings"], (scope) => {
+    scope.effect(() => scope.settings.configure({ auto: false }, ctx.fiber));
+  });
+}

package/src/transport.ts

@@ -0,0 +1,286 @@
+// 桌面形态的传输接管：把 Web 应用的浏览器装配换成「宿主内直连」——放行 `connection` 的浏览器认证，
+// 并把客户端的 transport 行注入 index、注册它访问的 `/.dsh/remote-stream`（请求体首行定
+// endpoint/payload、后续行是逻辑流的上行项，响应体是下行 NDJSON）。
+
+import { once } from "node:events";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { TypertGatewayWireStream } from "@deepseek-ai/dsh-api-gateway";
+import type { Context, LoggerService } from "@deepseek-ai/cordis";
+import { DESKTOP_STREAM_PATH, DesktopStreamBodyDecoder } from "./wire.ts";
+
+export { DESKTOP_STREAM_PATH } from "./wire.ts";
+
+// 桌面流的计数：给「宿主内存一直在涨」这类问题用的——把增长落到「哪条流、多少字节」上。
+// 只在 `DSH_MEMORY_REPORT=1` 时被读出来打印（见 `index.ts` 的 reportMemoryWhenAsked），平时就是几个自增。
+export const desktopStreamStats = {
+  active: 0,
+  opened: 0,
+  failed: 0,
+  items: 0,
+  bytes: 0,
+};
+
+// 注入 index 的 transport 行：声明页面拥有 Host，并给出 Gateway 流载体（下行流 + 上行项）。
+// 这份脚本里的 `console.*` 是**页面里**跑的代码（浏览器没有 cordis 树），不是宿主日志。
+export const DESKTOP_TRANSPORT_SCRIPT = `globalThis.__DSH_TRANSPORT__={
+  _desktop:true,
+  ownsHost:true,
+  async *openStream(endpoint,payload,signal,uplink){
+    console.info('[dsh-desktop] openStream',endpoint)
+    const carrier=globalThis.__DSH_DESKTOP_STREAM__
+    if(carrier===undefined){
+      console.error('[dsh-desktop] stream carrier missing for',endpoint)
+      throw new Error('desktop stream carrier is unavailable')
+    }
+    const queue=[]
+    let buffer=''
+    let ended=false
+    let failure
+    let wake
+    const notify=()=>{const pending=wake;wake=undefined;if(pending)pending()}
+    const append=(text)=>{
+      buffer+=text
+      let at
+      while((at=buffer.indexOf('\\n'))!==-1){
+        const line=buffer.slice(0,at)
+        buffer=buffer.slice(at+1)
+        if(line!=='')queue.push(JSON.parse(line))
+      }
+      notify()
+    }
+    const stream=carrier.open(endpoint,payload,{
+      chunk(text){append(text)},
+      end(){
+        if(buffer!==''){queue.push(JSON.parse(buffer));buffer=''}
+        ended=true
+        notify()
+      },
+      fail(message){failure=new Error(message);ended=true;notify()},
+    })
+    // 收尾只有一处：取消必须结束迭代（不叫醒它，等在这一句上的消费方收不到 end 帧，
+    // dispose（await iterator.return）也永不落定——窗口重建会卡在这里），同时取消载体流本身。
+    // abort（窗口重建）与消费方提前退出（切会话时上游只 return 迭代器，不发 abort）都走它；
+    // 幂等，两条路径都发生也只 cancel 一次。
+    let closed=false
+    const close=()=>{
+      if(closed)return
+      closed=true
+      stream.cancel()
+      ended=true
+      notify()
+    }
+    const onAbort=close
+    signal.addEventListener('abort',onAbort,{once:true})
+    if(signal.aborted)onAbort()
+    // 上行（客户端 → 宿主）是逻辑流的输入项：逐条交给主进程，收尾时结束请求体；
+    // 没有 uplink 的流（如 $events）立刻结束请求体，宿主侧不用等一个永不来的 end。
+    if(uplink===undefined)stream.end()
+    else void (async()=>{
+      try{
+        for await(const item of uplink){
+          // 取消后不再上行：宿主那边这条逻辑流已经作废。
+          if(signal.aborted)break
+          stream.send(item)
+        }
+      }catch(error){
+        console.error('[dsh-desktop] stream uplink failed for',endpoint,error)
+      }finally{
+        stream.end()
+      }
+    })()
+    try{
+      for(;;){
+        while(queue.length>0)yield queue.shift()
+        if(failure!==undefined)throw failure
+        if(ended)return
+        await new Promise(resolve=>{wake=resolve})
+      }
+    }finally{
+      signal.removeEventListener('abort',onAbort)
+      close()
+    }
+  }
+}
+console.info('[dsh-desktop] transport installed',Object.keys(globalThis.__DSH_TRANSPORT__))`;
+interface BrowserAuthSurface {
+  /** 桌面形态下这棵树的流代表的 peer：已认证浏览器连接共享的 owner Peer（上游 `HostConnectionService`）。 */
+  readonly browserPeer: PeerScope;
+  requestRejection(request: unknown): number | undefined;
+  authorizeIndex(request: unknown, response: unknown): boolean;
+}
+
+/** 流开口的 peer 形参类型：上游签名一改这里跟着改（见 `GatewaySurface` 的同一考虑）。 */
+type PeerScope = Parameters<TypertGatewayWireStream["open"]>[3];
+
+interface GatewaySurface {
+  // 直接用上游导出的签名：它变参数时我们编译即报错，抄一份会静默失效成运行时 TypeError。
+  readonly wireStream: Pick<TypertGatewayWireStream, "open">;
+}
+
+// 桌面形态下放行 `connection` 的两处浏览器认证：`requestRejection`（`/api` 路由与各插件 handler
+// 的自查）与 `authorizeIndex`（`frontend-static` 的 index 渲染）——页面由壳独占，认证没有对象。
+export function takeOverDesktopAuthentication(ctx: Context): void {
+  const connection = ctx.get("connection") as unknown as BrowserAuthSurface | undefined;
+  if (connection === undefined)
+    throw new Error("dsh desktop: the composition did not provide the connection service");
+  if (
+    typeof connection.requestRejection !== "function" ||
+    typeof connection.authorizeIndex !== "function"
+  )
+    throw new Error(
+      "dsh desktop: the connection service no longer exposes requestRejection / authorizeIndex; " +
+        "desktop authentication takeover needs an update",
+    );
+  connection.requestRejection = () => undefined;
+  connection.authorizeIndex = () => true;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// 桌面流请求体：首行是 open（endpoint / payload），后续每行是一道上行项。
+async function* readStreamFrames(request: IncomingMessage): AsyncGenerator<unknown> {
+  const decoder = new DesktopStreamBodyDecoder();
+  for await (const chunk of request) {
+    for (const frame of decoder.push(chunk as Uint8Array)) yield frame;
+  }
+  for (const frame of decoder.finish()) yield frame;
+}
+
+interface StreamOpening {
+  readonly endpoint: string;
+  readonly payload: unknown;
+}
+
+// 校验首行：它决定这条流开在哪个 endpoint 上。
+function parseStreamOpening(value: unknown, subject: string): StreamOpening {
+  if (!isRecord(value) || typeof value.endpoint !== "string")
+    throw new Error(`dsh desktop: invalid stream request ${subject}`);
+  return { endpoint: value.endpoint, payload: value.payload ?? { args: {} } };
+}
+
+// 诊断行：桌面流是连接就绪的唯一来源，出问题时先看这几行——走这条树的 logger（由调用方给）。
+function reportStreamFailure(subject: string, detail: unknown, log: LoggerService): void {
+  log.error(`[dsh-desktop] ${subject}: ${errorText(detail)}`);
+}
+
+function errorText(value: unknown): string {
+  return value instanceof Error ? (value.stack ?? value.message) : String(value);
+}
+
+function streamHandler(ctx: Context): (req: IncomingMessage, res: ServerResponse) => Promise<void> {
+  return async (request, response) => {
+    if (request.method !== "POST") {
+      response.writeHead(405);
+      response.end();
+      return;
+    }
+    const gateway = ctx.get("typertGateway") as unknown as GatewaySurface | undefined;
+    if (gateway === undefined) {
+      reportStreamFailure("stream failed", "typertGateway service is missing", ctx.logger);
+      response.writeHead(503);
+      response.end("gateway unavailable");
+      return;
+    }
+    // 上游 0.2.1-alpha.4 起 `wireStream.open` 的 peer 必填：桌面这条流代表的就是浏览器那个 owner Peer
+    // （认证已被 `takeOverDesktopAuthentication` 放行，见上）。
+    const peer = (ctx.get("connection") as unknown as BrowserAuthSurface | undefined)?.browserPeer;
+    if (peer === undefined) {
+      reportStreamFailure("stream failed", "connection service is missing", ctx.logger);
+      response.writeHead(503);
+      response.end("connection unavailable");
+      return;
+    }
+    const endpointFromQuery = new URL(request.url ?? "/", "http://127.0.0.1").searchParams.get(
+      "endpoint",
+    );
+    // 首行定流，其余行是上行项：`frames` 剩下的部分就是交给 Gateway 的 uplink。
+    const frames = readStreamFrames(request);
+    let opening: StreamOpening;
+    try {
+      const first = await frames.next();
+      opening = first.done
+        ? parseStreamOpening(
+            endpointFromQuery === null ? undefined : { endpoint: endpointFromQuery },
+            String(request.url),
+          )
+        : parseStreamOpening(first.value, String(request.url));
+    } catch (error) {
+      reportStreamFailure("stream body is not a valid opener", error, ctx.logger);
+      response.writeHead(400);
+      response.end("invalid stream request");
+      return;
+    }
+    const endpoint = opening.endpoint;
+    const abort = new AbortController();
+    const cancel = (): void => {
+      abort.abort();
+    };
+    request.once("aborted", cancel);
+    response.once("close", cancel);
+    try {
+      ctx.logger.debug(`[dsh-desktop] stream opening ${endpoint}`);
+      // 上游契约是五参：`uplink` 是「客户端 → 宿主」的逻辑流输入，`$events` 那类 Gateway 自己的流
+      // 会被上游立刻释放（`releaseUplink`）。
+      const values = await gateway.wireStream.open(
+        endpoint,
+        opening.payload,
+        frames,
+        peer,
+        abort.signal,
+      );
+      ctx.logger.debug(`[dsh-desktop] stream opened ${endpoint}`);
+      response.writeHead(200, {
+        "content-type": "application/x-ndjson",
+        "cache-control": "no-store",
+      });
+      desktopStreamStats.opened += 1;
+      desktopStreamStats.active += 1;
+      try {
+        for await (const value of values) {
+          // 尊重下游背压：`write()` 返回 false 就是这一侧的缓冲满了，必须等 `drain` 再继续拉上游。
+          // 不等就是「客户端丢下这条流、上游还在产」时的无界缓冲——侧栏反复重试那条循环实测
+          // 4MB/s 一路涨到 GB（进程崩在这里，而不是崩在业务错误上）。
+          const line = `${JSON.stringify(value)}\n`;
+          desktopStreamStats.items += 1;
+          desktopStreamStats.bytes += Buffer.byteLength(line);
+          if (!response.write(line)) {
+            await Promise.race([once(response, "drain"), once(response, "close")]).catch(
+              () => undefined,
+            );
+            if (response.destroyed) return;
+          }
+        }
+        response.end();
+      } finally {
+        desktopStreamStats.active -= 1;
+      }
+    } catch (error) {
+      desktopStreamStats.failed += 1;
+      reportStreamFailure(`stream ${endpoint} failed`, error, ctx.logger);
+      if (response.headersSent) {
+        response.destroy(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      response.writeHead(502);
+      response.end(error instanceof Error ? error.message : String(error));
+    }
+  };
+}
+
+// 注入 transport 行并注册 Gateway 流路由；随插件 fiber 一起撤销。
+export function installDesktopTransport(ctx: Context): void {
+  ctx.on("webserver/index-inject", (table) => {
+    table.push({ kind: "script", placement: "head", text: DESKTOP_TRANSPORT_SCRIPT });
+  });
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: "exact",
+        path: DESKTOP_STREAM_PATH,
+        handler: streamHandler(ctx),
+      }),
+    "dsh-desktop: remote stream route",
+  );
+}

package/src/web.ts

@@ -0,0 +1,57 @@
+// dev 形态的 web 启动入口（不进包的 `files`：只有 `dev --web` 用它）。
+//
+// 它做的事只有一件：把 **profile root 当 profile 启一次 web 形态**——装配走 `@morlay/dsh-app-boot`，与桌面
+// 宿主同一份；`@deepseek-ai/dsh-web-app` 那套行（端口、认证、打印 URL、开浏览器）由 profile 的
+// bundle 层提供，和上游 `dsh --profile web` 完全同一套。
+//
+// argv 与桌面宿主**同一套**（见 `./invocation.ts`）：`--profile-dir <dir> --runtime-dir <dir>
+// [--patch <file>]... [-- <web app 的内层参数>...]`；端口契约与上游一致：`PORT` 环境变量定缺省
+// （3080），内层里显式 `--port` 以它为准，`--no-open` 等 flag 原样交给 web app 的 flag family。
+
+import { bootAppProfile } from "@morlay/dsh-app-boot";
+import { parseHostInvocation } from "./invocation.ts";
+
+/**
+ * 缺省端口：`0` = 向系统要一个。
+ *
+ * 不跟着上游用 3080 写死——本机上跑第二个实例、或别的工具占了它，web 形态就只能靠"改 `PORT`"才起得来。
+ * 实际端口看 web app 自己打的那行 `➜  Local:   http://127.0.0.1:<port>/`（浏览器也由它打开）。
+ */
+export const DEFAULT_WEB_PORT = "0";
+
+/**
+ * 把缺省端口补进内层参数：web app 的 flag family 自己解析 `--port`，所以这里只在内层没给
+ * `--port` 时补一个。
+ * @param inner - `--` 之后的内层参数。
+ * @param port - `PORT` 环境变量给出的端口。
+ * @returns 交给树的内层参数。
+ */
+export function webArgs(inner: readonly string[], port: string): readonly string[] {
+  return inner.includes("--port") ? [...inner] : ["--port", port, ...inner];
+}
+
+async function main(): Promise<void> {
+  const invocation = parseHostInvocation("dsh web", process.argv.slice(2));
+  const port = process.env.PORT ?? DEFAULT_WEB_PORT;
+  const { ctx } = await bootAppProfile({
+    profileDir: invocation.profileDir,
+    profile: "web",
+    patchFiles: invocation.patches,
+    args: webArgs(invocation.inner, port),
+  });
+  // 这行在**树起来之后**打：名字交给这条树的 logger（不自己拼 `[dsh-web]` 前缀），exporter 拿到的是字段。
+  ctx.logger.info(
+    "profile root=%s runtime=%s port=%s",
+    invocation.profileDir,
+    invocation.runtimeDir,
+    port,
+  );
+}
+
+if (import.meta.main) {
+  main().catch((error: unknown) => {
+    // 树没起来（或已经在拆）时只能用 console：这里没有 `ctx.logger` 可用。
+    console.error(error);
+    process.exitCode = 1;
+  });
+}