@langify-org/dsh-code-server 0.1.2 → 0.2.0

package/README.ja.md

@@ -29,25 +29,26 @@ DSH の Web 版や Desktop 版では **Plugins** ページから追加できま
 
 ## 設定
 
-| 設定            | 既定値        | 意味                                                           |
-| --------------- | ------------- | -------------------------------------------------------------- |
-| `command`       | `code-server` | 実行ファイルの名前またはパス。                                 |
-| `userDataDir`   | 空            | code-server の `--user-data-dir`。空なら code-server の既定。  |
-| `extensionsDir` | 空            | code-server の `--extensions-dir`。空なら code-server の既定。 |
+| 設定            | 既定値        | 意味                                                                                                                                                    |
+| --------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `command`       | `code-server` | 実行ファイルの名前またはパス。                                                                                                                          |
+| `userDataDir`   | 空            | code-server の `--user-data-dir`。空なら code-server の既定。                                                                                           |
+| `extensionsDir` | 空            | code-server の `--extensions-dir`。空なら code-server の既定。                                                                                          |
+| `desktopPort`   | `41820`       | DSH Desktop がエディターを読み込む `127.0.0.1` のポート。固定のままにしてください。信頼済みフォルダーなどエディターの状態はオリジンごとに保存されます。 |
 
 既定のままなら、普段使いの code-server と設定・拡張を共有します。同じディレクトリを使う別の code-server を同時に動かさないでください。
 
 ## 仕組み
 
-- プラグインは必要になったときに DSH 用の code-server を1つ起動します。待ち受けは本人だけが開ける Unix socket（`0700` のディレクトリ内の `0600`）で、code-server 自身の認証は無効にしています。ネットワークのポートは開きません。
-- DSH は自分のオリジンの `/code-server` で code-server を配信します。すべてのリクエストと WebSocket は、先に DSH の認証とオリジンの検査を通ります。そのため code-server には、DSH に届く場所（Tailscale 経由など）からだけ届きます。
-- DSH Desktop のページは `dsh-app://app` にあり、code-server はその宛先に WebSocket をつなごうとします。中継は code-server のページに小さなスクリプトを差し込み、WebSocket を Desktop が示す Host の宛先（`__DSH_TRANSPORT__.streamBaseUrl`）に付け替えます。Desktop はそこへの接続に DSH の認証情報を付けます。ブラウザーではこのスクリプトは何もしません。
+- プラグインは必要になったときに DSH 用の code-server を1つ起動します。待ち受けは本人だけが開ける Unix socket（`0700` のディレクトリ内の `0600`）で、code-server 自身の認証は無効にしています。code-server 自体はネットワークのポートを開きません。
+- ブラウザーでは、DSH が自分のオリジンの `/code-server` でエディターを配信します。すべてのリクエストと WebSocket は、先に DSH の認証とオリジンの検査を通ります。そのためエディターには、DSH に届く場所（Tailscale 経由など）からしか届きません。
+- DSH Desktop は DSH を `dsh-app://app` で表示します。code-server はここでは動きません。サーバーの宛先を自分のページのアドレスから作り、このスキームでは webview に必要な Service Worker も使えないためです。また Desktop は、自分以外のオリジンから Host への WebSocket を遮断します。そこで Desktop では、プラグイン自身が `127.0.0.1:<desktopPort>` でエディターを配信します。DSH とは別の、ふつうの http のオリジンです。待ち受けは、Desktop が初めて Code ページを開いたときに始めます。エディターのアドレスのパスには、プラグインの起動ごとに作るランダムなトークンが入ります。code-server はすべてをページからの相対パスで指すので、どのリクエストにもトークンが付きます。トークンを受け取れるのは、DSH が認証したページだけです。さらに、別のホスト名を名乗るリクエストは拒否し、DNS rebinding を防ぎます。
 - 起動のたびに、同梱の VS Code 拡張 **DSH Code Bridge**（`langify-org.dsh-code-bridge`）を code-server に入れ、古いものを置き換えます。
 - Code ページごとに専用の接続（binding）を作ります。ページは binding をエディターの URL の断片（サーバーには送られない部分）に入れ、そのエディター画面の拡張がそれを読み取って、別の非公開 socket でプラグインに接続します。同じフォルダーを複数のページで開いていても、ファイルはその画面にだけ開きます。
 
 ## セキュリティ
 
-code-server とそのターミナル・拡張は、あなたの権限で、DSH のサンドボックスや承認の外で動きます。さらに DSH と同じオリジンなので、code-server の中で動くコード（拡張やその webview を含む）は、あなたのセッションで DSH を操作することもできます。信頼できる拡張だけを入れてください。[SECURITY.ja.md](../../SECURITY.ja.md) も参照してください。
+code-server とそのターミナル・拡張は、あなたの権限で、DSH のサンドボックスや承認の外で動きます。ブラウザーではエディターが DSH と同じオリジンなので、code-server の中で動くコード（拡張やその webview を含む）は、あなたのセッションで DSH を操作することもできます。信頼できる拡張だけを入れてください。[SECURITY.ja.md](../../SECURITY.ja.md) も参照してください。
 
 ## 手動確認
 
@@ -57,7 +58,8 @@ code-server とそのターミナル・拡張は、あなたの権限で、DSH
 2. **Workspace files** で選んだテキストファイルが Code ページの該当行で開く。画像は DSH のビューアーのまま開く。
 3. サインインしていないと `/code-server/` と `POST /api/langify-code-server/create` が 401 を返し、別オリジンからの WebSocket の upgrade は 403 を返す。
 4. セッションの作業フォルダーが変わると、エディターが開き直すかを尋ねる。未保存のファイルがあれば先に保存を求め、そのあとページが新しいフォルダーでエディターを開き直す。
-5. Code タブを閉じると binding が閉じる。DSH を止めると code-server も止まり、socket が消える。
+5. DSH Desktop では、エディターが `http://127.0.0.1:41820/…` から読み込まれ、テーマとファイルアイコンが出て、Markdown のプレビューが開く。トークンが無いとポートは 404 を返す。
+6. Code タブを閉じると binding が閉じる。DSH を止めると code-server も止まり、socket が消える。
 
 ## 既知の制約
 

package/README.md

@@ -29,25 +29,26 @@ Open the right sidebar, add a tab, and choose **Code**. The page opens the sessi
 
 ## Configuration
 
-| Setting         | Default       | Meaning                                                             |
-| --------------- | ------------- | ------------------------------------------------------------------- |
-| `command`       | `code-server` | Executable name or path.                                            |
-| `userDataDir`   | empty         | code-server's `--user-data-dir`. Empty uses code-server's default.  |
-| `extensionsDir` | empty         | code-server's `--extensions-dir`. Empty uses code-server's default. |
+| Setting         | Default       | Meaning                                                                                                                                 |
+| --------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `command`       | `code-server` | Executable name or path.                                                                                                                |
+| `userDataDir`   | empty         | code-server's `--user-data-dir`. Empty uses code-server's default.                                                                      |
+| `extensionsDir` | empty         | code-server's `--extensions-dir`. Empty uses code-server's default.                                                                     |
+| `desktopPort`   | `41820`       | Port on `127.0.0.1` where DSH Desktop loads the editor. Keep it fixed: the editor keeps its state, such as trusted folders, per origin. |
 
 With the defaults, the editor shares settings and extensions with your own code-server. Do not run another code-server on the same directories at the same time.
 
 ## How it works
 
-- The plugin starts one code-server for DSH on demand, listening on a Unix socket that only you can open (mode `0600` in a `0700` directory), with code-server's own authentication off. It never opens a network port.
-- DSH serves code-server under `/code-server` on its own origin. Every request and WebSocket passes DSH's authentication and origin check first, so code-server is reachable wherever DSH is, for example over Tailscale, and nowhere else.
-- In DSH Desktop the page lives at `dsh-app://app`, and code-server would dial its WebSockets at that host. The relay adds a small script to code-server's page that sends them to the address Desktop gives its Host (`__DSH_TRANSPORT__.streamBaseUrl`), where Desktop adds DSH's credentials. In a browser the script changes nothing.
+- The plugin starts one code-server for DSH on demand, listening on a Unix socket that only you can open (mode `0600` in a `0700` directory), with code-server's own authentication off. code-server itself never opens a network port.
+- In a browser, DSH serves the editor under `/code-server` on its own origin. Every request and WebSocket passes DSH's authentication and origin check first, so the editor is reachable wherever DSH is, for example over Tailscale, and nowhere else.
+- DSH Desktop shows DSH at `dsh-app://app`, where code-server cannot run: it builds its server's addresses from its own page's, and that scheme allows no service workers, which webviews need. Desktop also refuses WebSockets to its Host from any other origin. So in Desktop the plugin serves the editor itself, on `127.0.0.1:<desktopPort>`, a plain http origin apart from DSH's. It starts listening when Desktop first opens the Code page. The editor's address carries in its path a random token, made anew whenever the plugin starts; code-server addresses everything relative to its page, so every request carries it. Only pages DSH has authenticated receive the token. The port also refuses requests that name another host, which stops DNS rebinding.
 - Before each start, the plugin installs its bundled VS Code extension, **DSH Code Bridge** (`langify-org.dsh-code-bridge`), into code-server, replacing any older copy.
 - Each Code page gets its own connection ("binding"). The page puts the binding in the editor's URL fragment, which never reaches a server; the extension in that editor window reads it back and connects to the plugin over another private socket. Files open in that window only, even when several pages show the same folder.
 
 ## Security
 
-code-server runs as you, and so do its terminal and extensions, outside DSH's sandbox and approvals. Because it shares DSH's origin, code running in code-server, including extensions and their webviews, can also use DSH with your session. Install only extensions you trust. See also [SECURITY.md](../../SECURITY.md).
+code-server runs as you, and so do its terminal and extensions, outside DSH's sandbox and approvals. In a browser the editor shares DSH's origin, so code running in code-server, including extensions and their webviews, can also use DSH with your session. In DSH Desktop the editor has its own origin, and other programs on this computer can reach its port but not without the token. Install only extensions you trust. See also [SECURITY.md](../../SECURITY.md).
 
 ## Manual checks
 
@@ -57,7 +58,8 @@ These need a browser and a real code-server, so they are not part of `pnpm check
 2. A text file chosen in **Workspace files** opens in the Code page at its line; an image keeps DSH's viewer.
 3. Without signing in, `/code-server/` and `POST /api/langify-code-server/create` answer 401, and a WebSocket upgrade from another origin answers 403.
 4. After the session's working folder changes, the editor offers to reopen; with an unsaved file it asks to save first, then the page reloads the editor on the new folder.
-5. Closing the Code tab closes its binding; stopping DSH stops code-server and removes its sockets.
+5. In DSH Desktop, the editor loads from `http://127.0.0.1:41820/…` with your theme and file icons, and a Markdown preview opens. The port answers 404 without the token.
+6. Closing the Code tab closes its binding; stopping DSH stops code-server and removes its sockets.
 
 ## Known limitations
 

package/README.zh.md

@@ -29,25 +29,26 @@ dsh plugin --profile <profile> add @langify-org/dsh-code-server
 
 ## 配置
 
-| 设置            | 默认值        | 含义                                                    |
-| --------------- | ------------- | ------------------------------------------------------- |
-| `command`       | `code-server` | 可执行文件的名称或路径。                                |
-| `userDataDir`   | 空            | code-server 的 `--user-data-dir`。为空时使用其默认值。  |
-| `extensionsDir` | 空            | code-server 的 `--extensions-dir`。为空时使用其默认值。 |
+| 设置            | 默认值        | 含义                                                                                                  |
+| --------------- | ------------- | ----------------------------------------------------------------------------------------------------- |
+| `command`       | `code-server` | 可执行文件的名称或路径。                                                                              |
+| `userDataDir`   | 空            | code-server 的 `--user-data-dir`。为空时使用其默认值。                                                |
+| `extensionsDir` | 空            | code-server 的 `--extensions-dir`。为空时使用其默认值。                                               |
+| `desktopPort`   | `41820`       | DSH Desktop 加载编辑器所用的 `127.0.0.1` 端口。请保持固定：编辑器的状态（如受信任的文件夹）按源保存。 |
 
 使用默认值时，编辑器会与你平时使用的 code-server 共享设置和扩展。请不要同时运行使用相同目录的另一个 code-server。
 
 ## 工作原理
 
-- 插件在需要时为 DSH 启动一个 code-server，监听只有你能打开的 Unix 套接字（位于 `0700` 目录中，权限为 `0600`），并关闭 code-server 自身的认证。它不会打开任何网络端口。
-- DSH 在自己的源下通过 `/code-server` 提供 code-server。每个请求和 WebSocket 都会先经过 DSH 的认证和来源检查，因此只有能访问 DSH 的地方（例如通过 Tailscale）才能访问 code-server。
-- 在 DSH Desktop 中，页面位于 `dsh-app://app`，code-server 会向该地址建立 WebSocket。中继会向 code-server 的页面注入一段小脚本，把 WebSocket 改为发往 Desktop 提供的 Host 地址（`__DSH_TRANSPORT__.streamBaseUrl`），Desktop 会为发往该地址的连接附加 DSH 的凭据。在浏览器中，该脚本不做任何改动。
+- 插件在需要时为 DSH 启动一个 code-server，监听只有你能打开的 Unix 套接字（位于 `0700` 目录中，权限为 `0600`），并关闭 code-server 自身的认证。code-server 本身不会打开任何网络端口。
+- 在浏览器中，DSH 在自己的源下通过 `/code-server` 提供编辑器。每个请求和 WebSocket 都会先经过 DSH 的认证和来源检查，因此只有能访问 DSH 的地方（例如通过 Tailscale）才能访问编辑器。
+- DSH Desktop 在 `dsh-app://app` 显示 DSH，code-server 无法在那里运行：它根据自身页面的地址构造服务器地址，而且该协议不支持 webview 所需的 Service Worker。Desktop 还会拒绝来自其他源、发往其 Host 的 WebSocket。因此在 Desktop 中，插件自己在 `127.0.0.1:<desktopPort>` 提供编辑器，这是一个独立于 DSH 的普通 http 源。Desktop 第一次打开 Code 页面时才开始监听。编辑器地址的路径中带有一个随机令牌，插件每次启动时重新生成；code-server 的所有地址都相对于其页面，因此每个请求都会带上它。只有经过 DSH 认证的页面才能拿到该令牌。该端口还会拒绝声明为其他主机名的请求，以防 DNS rebinding。
 - 每次启动前，插件都会把内置的 VS Code 扩展 **DSH Code Bridge**（`langify-org.dsh-code-bridge`）安装到 code-server 中，替换旧版本。
 - 每个 Code 页面都有自己的连接（binding）。页面把 binding 放在编辑器 URL 的片段中（这一部分不会发送到服务器），该编辑器窗口中的扩展读取它，并通过另一个私有套接字连接到插件。即使多个页面打开了同一个文件夹，文件也只会在对应的窗口中打开。
 
 ## 安全
 
-code-server 及其终端和扩展以你的身份运行，不受 DSH 沙箱和审批的约束。由于它与 DSH 同源，在 code-server 中运行的代码（包括扩展及其 webview）也能以你的会话使用 DSH。请只安装你信任的扩展。另请参阅 [SECURITY.zh.md](../../SECURITY.zh.md)。
+code-server 及其终端和扩展以你的身份运行，不受 DSH 沙箱和审批的约束。在浏览器中，编辑器与 DSH 同源，因此在 code-server 中运行的代码（包括扩展及其 webview）也能以你的会话使用 DSH。请只安装你信任的扩展。另请参阅 [SECURITY.zh.md](../../SECURITY.zh.md)。
 
 ## 手动检查
 
@@ -57,7 +58,8 @@ code-server 及其终端和扩展以你的身份运行，不受 DSH 沙箱和审
 2. 在 **Workspace files** 中选择的文本文件会在 Code 页面的对应行打开；图片仍使用 DSH 的查看器。
 3. 未登录时，`/code-server/` 和 `POST /api/langify-code-server/create` 返回 401，来自其他源的 WebSocket upgrade 返回 403。
 4. 会话的工作文件夹变化后，编辑器会询问是否重新打开；如有未保存的文件，会先要求保存，然后页面在新文件夹中重新打开编辑器。
-5. 关闭 Code 标签页会关闭其 binding；停止 DSH 会停止 code-server 并删除其套接字。
+5. 在 DSH Desktop 中，编辑器从 `http://127.0.0.1:41820/…` 加载，显示你的主题和文件图标，Markdown 预览可以打开；没有令牌时该端口返回 404。
+6. 关闭 Code 标签页会关闭其 binding；停止 DSH 会停止 code-server 并删除其套接字。
 
 ## 已知限制
 

package/dist/client.cjs

@@ -35,6 +35,7 @@ window.__ModuleLoader__.load({
 			"error.different_host": "This session runs on another file system, which Code cannot open.",
 			"error.code_server_not_found": "code-server was not found. Install it, or set its command in the plugin settings.",
 			"error.code_server_failed": "code-server failed to start: {message}",
+			"error.desktop_port_in_use": "The editor's port for DSH Desktop is taken: {message}. Choose another one with the plugin's desktopPort setting.",
 			"error.unknown_binding": "This editor connection is gone. Reconnect.",
 			"error.not_ready": "The editor is still starting.",
 			"error.binding_disconnected": "The editor window disconnected. Reconnect.",
@@ -79,6 +80,7 @@ window.__ModuleLoader__.load({
 			"error.different_host": "此会话运行在其他文件系统上，Code 无法打开。",
 			"error.code_server_not_found": "未找到 code-server。请安装它，或在插件设置中指定其命令。",
 			"error.code_server_failed": "code-server 启动失败：{message}",
+			"error.desktop_port_in_use": "供 DSH Desktop 使用的编辑器端口已被占用：{message}。请在插件设置 desktopPort 中改用其他端口。",
 			"error.unknown_binding": "与此编辑器的连接已不存在。请重新连接。",
 			"error.not_ready": "编辑器仍在启动中。",
 			"error.binding_disconnected": "编辑器窗口已断开。请重新连接。",
@@ -123,6 +125,7 @@ window.__ModuleLoader__.load({
 			"error.different_host": "このセッションは別のファイルシステムで動いているため、Code では開けません。",
 			"error.code_server_not_found": "code-server が見つかりません。インストールするか、プラグインの設定でコマンドを指定してください。",
 			"error.code_server_failed": "code-server を起動できませんでした: {message}",
+			"error.desktop_port_in_use": "DSH Desktop 用のエディターのポートが使われています: {message}。プラグインの設定 desktopPort で別の番号にしてください。",
 			"error.unknown_binding": "このエディターとの接続はもうありません。再接続してください。",
 			"error.not_ready": "エディターはまだ起動中です。",
 			"error.binding_disconnected": "エディターの画面が切断されました。再接続してください。",
@@ -148,6 +151,12 @@ window.__ModuleLoader__.load({
 		/** DSH's shared RPC channel, and the prefix of the endpoints this plugin owns on it. */
 		const RPC_CHANNEL = "/api";
 		const RPC_PREFIX = "langify-code-server/";
+		/**
+		* Where the page loads the editor from. `dsh` serves it under DSH's own origin;
+		* `desktop` is the plugin's own address on 127.0.0.1, for DSH Desktop, whose
+		* page is not on http(s) (see host/ingress/).
+		*/
+		const INGRESSES = ["dsh", "desktop"];
 		const id = zod.z.string().min(1).max(256).refine((value) => !value.includes("\0"));
 		const position = zod.z.int().min(1).max(1e6);
 		const binding = {
@@ -156,7 +165,8 @@ window.__ModuleLoader__.load({
 		};
 		zod.z.strictObject({
 			sessionId: id,
-			ownerId: id
+			ownerId: id,
+			ingress: zod.z.enum(INGRESSES)
 		}), zod.z.strictObject({
 			...binding,
 			revision: zod.z.int().min(-1)
@@ -311,6 +321,11 @@ window.__ModuleLoader__.load({
 		}
 		// src/client/code-page.tsx
 		const SANDBOX = "allow-scripts allow-forms allow-same-origin allow-popups allow-popups-to-escape-sandbox allow-downloads";
+		/**
+		* code-server runs only on an http(s) page. DSH Desktop's page is not one, so
+		* the editor comes from the plugin's own address instead (host/ingress/).
+		*/
+		const INGRESS = location.protocol === "http:" || location.protocol === "https:" ? "dsh" : "desktop";
 		/** After these, the binding is gone and the page must reconnect. */
 		const FINAL_ERRORS = /* @__PURE__ */ new Set([
 			"unknown_binding",
@@ -378,7 +393,10 @@ window.__ModuleLoader__.load({
 				};
 				(async () => {
 					try {
-						binding = await call("create", { ownerId: crypto.randomUUID() });
+						binding = await call("create", {
+							ownerId: crypto.randomUUID(),
+							ingress: INGRESS
+						});
 						if (disposed) {
 							call("close", { bindingId: binding.bindingId }).catch(() => {});
 							return;

package/dist/index.mjs

@@ -4,19 +4,24 @@ import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import Schema from "@deepseek-ai/schemastery";
 import { z } from "zod";
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:net";
-import { STATUS_CODES, get, request } from "node:http";
+import { STATUS_CODES, createServer as createServer$1, get, request } from "node:http";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { clientRequestSchema } from "@deepseek-ai/dsh-client-connection";
 import { SessionId } from "@deepseek-ai/dsh-session/types";
 import { parseFileAddress } from "@deepseek-ai/dsh-util-workspace-path";
-import { buffer } from "node:stream/consumers";
 // src/rpc.ts
 /** DSH's shared RPC channel, and the prefix of the endpoints this plugin owns on it. */
 const RPC_CHANNEL = "/api";
 const RPC_PREFIX = "langify-code-server/";
 /**
+* Where the page loads the editor from. `dsh` serves it under DSH's own origin;
+* `desktop` is the plugin's own address on 127.0.0.1, for DSH Desktop, whose
+* page is not on http(s) (see host/ingress/).
+*/
+const INGRESSES = ["dsh", "desktop"];
+/**
 * Why the extension could not open a file. `outcome_unknown` means the editor
 * was already asked and may still show the file later.
 */
@@ -38,6 +43,7 @@ const HOST_ERROR_CODES = [
 	"different_host",
 	"code_server_not_found",
 	"code_server_failed",
+	"desktop_port_in_use",
 	"unknown_binding",
 	"not_ready",
 	"binding_disconnected",
@@ -54,7 +60,8 @@ const binding = {
 const requestSchemas = {
 	create: z.strictObject({
 		sessionId: id,
-		ownerId: id
+		ownerId: id,
+		ingress: z.enum(INGRESSES)
 	}),
 	watch: z.strictObject({
 		...binding,
@@ -585,151 +592,24 @@ function healthy(socketPath) {
 		}).on("error", () => resolve(false));
 	});
 }
-// src/host/desktop-websocket.ts
-/** Self-contained: it is serialized into {@link DESKTOP_WEBSOCKET_SCRIPT}. */
-function retargetWebSockets(page) {
-	let base;
-	try {
-		base = page.parent.__DSH_TRANSPORT__?.streamBaseUrl;
-	} catch {
-		return;
-	}
-	if (typeof base !== "string") return;
-	const host = new URL(base);
-	const scheme = host.protocol === "https:" ? "wss:" : "ws:";
-	const Native = page.WebSocket;
-	page.WebSocket = class extends Native {
-		constructor(url, protocols) {
-			const target = new URL(url, page.location.href);
-			if (target.hostname === page.location.hostname) {
-				target.protocol = scheme;
-				target.host = host.host;
-			}
-			super(target, protocols);
-		}
-	};
-}
-const DESKTOP_WEBSOCKET_SCRIPT = `(${retargetWebSockets.toString()})(window)\n`;
-// src/host/relay.ts
-/** Path prefix code-server is served under, relative to the DSH page. */
-const RELAY_PREFIX = "/code-server";
-/** Served by the relay itself, below the prefix; code-server has no such route. */
-const SCRIPT_PATH = "/_dsh/desktop-websocket.js";
-/** DSH's credentials are not code-server's business. */
-const PRIVATE_HEADERS = /* @__PURE__ */ new Set(["cookie", "authorization"]);
-function upstreamHeaders(headers) {
-	return Object.fromEntries(Object.entries(headers).filter(([name]) => !PRIVATE_HEADERS.has(name)));
-}
-function upstreamPath(url = "/") {
-	const path = url.slice(12);
-	return path.startsWith("/") ? path : `/${path}`;
-}
-/** Handler for HTTP requests below {@link RELAY_PREFIX}. */
-function relayRequests(admission, start) {
-	return async (req, res) => {
-		const rejection = admission({ headers: req.headers });
-		if (rejection !== void 0) {
-			res.writeHead(rejection).end();
-			return;
-		}
-		let server;
-		try {
-			server = await start();
-		} catch (error) {
-			res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-			res.end(error instanceof Error ? error.message : "code-server is unavailable");
-			return;
-		}
-		const path = upstreamPath(req.url);
-		const pathname = new URL(path, "http://code-server").pathname;
-		if (req.method === "GET" && pathname === SCRIPT_PATH) {
-			res.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
-			res.end(DESKTOP_WEBSOCKET_SCRIPT);
-			return;
-		}
-		const page = req.method === "GET" && pathname === "/";
-		const headers = upstreamHeaders(req.headers);
-		const upstream = request({
-			socketPath: server.socketPath,
-			method: req.method,
-			path,
-			headers: page ? {
-				...headers,
-				"accept-encoding": "identity"
-			} : headers
-		}, (response) => {
-			if (page && response.headers["content-type"]?.startsWith("text/html") === true) {
-				sendPage(response, res).catch(() => res.destroy());
-				return;
-			}
-			res.writeHead(response.statusCode ?? 502, response.statusMessage, response.headers);
-			response.pipe(res);
-		});
-		upstream.on("error", () => {
-			if (res.headersSent) res.destroy();
-			else res.writeHead(502).end();
-		});
-		res.on("close", () => upstream.destroy());
-		req.pipe(upstream);
-	};
-}
-/** Send code-server's page with the script ahead of code-server's own. */
-async function sendPage(response, res) {
-	const html = (await buffer(response)).toString("utf8").replace(/<head[^>]*>/i, (head) => `${head}<script src=".${SCRIPT_PATH}"><\/script>`);
-	const { "content-length": _length, ...headers } = response.headers;
-	res.writeHead(response.statusCode ?? 502, response.statusMessage, headers).end(html);
-}
-/** Handler for code-server's WebSocket upgrades, which arrive on one exact path. */
-function relayUpgrades(admission, socketPath) {
-	return (req, socket, head) => {
-		const rejection = admission({ headers: req.headers });
-		if (rejection !== void 0) {
-			socket.end(`HTTP/1.1 ${rejection} ${STATUS_CODES[rejection] ?? ""}\r\n\r\n`);
-			return;
-		}
-		const upstream = request({
-			socketPath,
-			method: req.method,
-			path: upstreamPath(req.url),
-			headers: upstreamHeaders(req.headers)
-		});
-		upstream.on("upgrade", (response, upstreamSocket, upstreamHead) => {
-			const lines = [`HTTP/1.1 ${response.statusCode ?? 101} ${response.statusMessage ?? ""}`];
-			for (let index = 0; index < response.rawHeaders.length; index += 2) lines.push(`${response.rawHeaders[index] ?? ""}: ${response.rawHeaders[index + 1] ?? ""}`);
-			socket.write(`${lines.join("\r\n")}\r\n\r\n`);
-			if (upstreamHead.length > 0) socket.write(upstreamHead);
-			if (head.length > 0) upstreamSocket.write(head);
-			upstreamSocket.pipe(socket).pipe(upstreamSocket);
-			upstreamSocket.on("error", () => socket.destroy());
-			upstreamSocket.on("close", () => socket.destroy());
-			socket.on("close", () => upstreamSocket.destroy());
-		});
-		upstream.on("response", (response) => {
-			response.resume();
-			socket.end(`HTTP/1.1 ${response.statusCode ?? 502} ${response.statusMessage ?? ""}\r\n\r\n`);
-		});
-		upstream.on("error", () => socket.destroy());
-		socket.on("error", () => upstream.destroy());
-		upstream.end();
-	};
-}
 // src/host/handlers.ts
 /**
 * One exact route per method on DSH's shared RPC channel. DSH authenticates the
 * browser before a request reaches these routes.
 */
-function rpcRoutes(services, bridge, codeServer) {
+function rpcRoutes(services, bridge, codeServer, editors) {
 	const handlers = {
-		async create({ sessionId, ownerId }, signal) {
+		async create({ sessionId, ownerId, ingress }, signal) {
 			const { cwd } = await sessionFolders(services, sessionId, signal);
 			const folder = await localPath(services, cwd, cwd, "directory", signal);
 			await codeServer.ensure();
+			const base = await editors[ingress]();
 			signal.throwIfAborted();
 			const bindingId = bridge.create(sessionId, ownerId, folder);
 			return {
 				bindingId,
 				cwd: folder,
-				url: editorUrl(bindingId, folder)
+				url: editorUrl(base, bindingId, folder)
 			};
 		},
 		async watch({ sessionId, bindingId, revision }, signal) {
@@ -796,10 +676,9 @@ function rpcRoutes(services, bridge, codeServer) {
 		}
 	}));
 }
-/** The iframe URL, relative to the DSH page; its fragment tells the window's extension its binding. */
-function editorUrl(bindingId, cwd) {
-	const query = new URLSearchParams({ folder: cwd });
-	return `${RELAY_PREFIX.slice(1)}/?${query.toString()}#${BINDING_FRAGMENT}=${bindingId}`;
+/** The iframe URL; its fragment tells the window's extension its binding. */
+function editorUrl(base, bindingId, cwd) {
+	return `${base}?${new URLSearchParams({ folder: cwd }).toString()}#${BINDING_FRAGMENT}=${bindingId}`;
 }
 function asCodeServerError(error) {
 	if (error instanceof CodeServerError) return error;
@@ -842,6 +721,165 @@ async function localPath(services, path, base, type, signal) {
 	if (services.fs.processPathFromHostPath(processPath) !== processPath) throw new CodeServerError("different_host", "The session runs on another file system");
 	return realpath(processPath);
 }
+// src/host/relay.ts
+/** Credentials belong to the ingress, not to code-server. */
+const PRIVATE_HEADERS = /* @__PURE__ */ new Set(["cookie", "authorization"]);
+function forward(req, prefix, socketPath) {
+	const path = (req.url ?? "/").slice(prefix.length);
+	return request({
+		socketPath,
+		method: req.method,
+		path: path.startsWith("/") ? path : `/${path}`,
+		headers: Object.fromEntries(Object.entries(req.headers).filter(([name]) => !PRIVATE_HEADERS.has(name)))
+	});
+}
+/** Handler for HTTP requests below the prefix. */
+function relayRequests({ prefix, admit, start }) {
+	return async (req, res) => {
+		const refusal = admit(req);
+		if (refusal !== void 0) {
+			res.writeHead(refusal).end();
+			return;
+		}
+		let server;
+		try {
+			server = await start();
+		} catch (error) {
+			res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+			res.end(error instanceof Error ? error.message : "code-server is unavailable");
+			return;
+		}
+		const upstream = forward(req, prefix, server.socketPath);
+		upstream.on("response", (response) => {
+			res.writeHead(response.statusCode ?? 502, response.statusMessage, response.headers);
+			response.pipe(res);
+		});
+		upstream.on("error", () => {
+			if (res.headersSent) res.destroy();
+			else res.writeHead(502).end();
+		});
+		res.on("close", () => upstream.destroy());
+		req.pipe(upstream);
+	};
+}
+function refuse(socket, status) {
+	socket.end(`HTTP/1.1 ${status} ${STATUS_CODES[status] ?? ""}\r\n\r\n`);
+}
+/** Handler for WebSocket upgrades below the prefix. */
+function relayUpgrades({ prefix, admit, start }) {
+	return (req, socket, head) => {
+		const refusal = admit(req);
+		if (refusal !== void 0) return refuse(socket, refusal);
+		socket.on("error", () => socket.destroy());
+		start().then(({ socketPath }) => {
+			if (socket.destroyed) return;
+			const upstream = forward(req, prefix, socketPath);
+			upstream.on("upgrade", (response, upstreamSocket, upstreamHead) => {
+				const lines = [`HTTP/1.1 ${response.statusCode ?? 101} ${response.statusMessage ?? ""}`];
+				for (let index = 0; index < response.rawHeaders.length; index += 2) lines.push(`${response.rawHeaders[index] ?? ""}: ${response.rawHeaders[index + 1] ?? ""}`);
+				socket.write(`${lines.join("\r\n")}\r\n\r\n`);
+				if (upstreamHead.length > 0) socket.write(upstreamHead);
+				if (head.length > 0) upstreamSocket.write(head);
+				upstreamSocket.pipe(socket).pipe(upstreamSocket);
+				upstreamSocket.on("error", () => socket.destroy());
+				upstreamSocket.on("close", () => socket.destroy());
+				socket.on("close", () => upstreamSocket.destroy());
+			});
+			upstream.on("response", (response) => {
+				response.resume();
+				refuse(socket, response.statusCode ?? 502);
+			});
+			upstream.on("error", () => socket.destroy());
+			socket.on("close", () => upstream.destroy());
+			upstream.end();
+		}, () => refuse(socket, 502));
+	};
+}
+// src/host/ingress/desktop.ts
+const HOST = "127.0.0.1";
+var DesktopIngress = class {
+	#port;
+	#start;
+	#token = randomBytes(32).toString("base64url");
+	#listening;
+	/** @param port - 0 picks a free port, which changes the editor's origin on every run. */
+	constructor(port, start) {
+		this.#port = port;
+		this.#start = start;
+	}
+	/** The editor's address, listening from the first call on. */
+	async base() {
+		this.#listening ??= this.#listen().catch((error) => {
+			this.#listening = void 0;
+			throw error;
+		});
+		return `${(await this.#listening).origin}/${this.#token}/`;
+	}
+	async dispose() {
+		const listener = await this.#listening?.catch(() => void 0);
+		this.#listening = void 0;
+		if (listener === void 0) return;
+		const { server } = listener;
+		const closed = new Promise((resolve) => server.close(() => resolve()));
+		server.closeAllConnections();
+		await closed;
+	}
+	async #listen() {
+		let host = "";
+		const relay = {
+			prefix: `/${this.#token}`,
+			admit: (req) => this.#admit(req, host),
+			start: this.#start
+		};
+		const handle = relayRequests(relay);
+		const server = createServer$1((req, res) => void handle(req, res));
+		server.on("upgrade", relayUpgrades(relay));
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(this.#port, HOST, () => {
+				server.off("error", reject);
+				resolve();
+			});
+		}).catch((error) => {
+			if ((error instanceof Error && "code" in error ? error.code : void 0) !== "EADDRINUSE") throw error;
+			throw new CodeServerError("desktop_port_in_use", `${HOST}:${this.#port}`, { cause: error });
+		});
+		const address = server.address();
+		host = `${HOST}:${typeof address === "object" && address !== null ? address.port : this.#port}`;
+		return {
+			server,
+			origin: `http://${host}`
+		};
+	}
+	/** @param host - the listener's own host and port. */
+	#admit(req, host) {
+		if (req.headers.host !== host) return 403;
+		const token = Buffer.from((req.url ?? "").split("/", 2)[1] ?? "");
+		const expected = Buffer.from(this.#token);
+		return token.length === expected.length && timingSafeEqual(token, expected) ? void 0 : 404;
+	}
+};
+// src/host/ingress/dsh.ts
+const PREFIX = "/code-server";
+function dshIngress(ctx, start) {
+	const relay = {
+		prefix: PREFIX,
+		admit: (req) => ctx.connection.requestRejection({ headers: req.headers }),
+		start
+	};
+	ctx.effect(() => ctx.webServer.register({
+		kind: "prefix",
+		path: PREFIX,
+		handler: relayRequests(relay)
+	}), "code-server: DSH ingress");
+	return {
+		base: `${PREFIX.slice(1)}/`,
+		serveWebSocket: ({ commit }) => ctx.effect(() => ctx.webServer.registerUpgrade({
+			path: `${PREFIX}/stable-${commit}`,
+			handler: relayUpgrades(relay)
+		}), "code-server: DSH ingress WebSocket")
+	};
+}
 // src/host/services.ts
 const inject = [
 	"connection",
@@ -858,7 +896,8 @@ const name = "langify-code-server";
 const Config = Schema.object({
 	command: Schema.string().default("code-server").description("code-server executable name or path."),
 	userDataDir: Schema.string().default("").description("code-server's --user-data-dir. Empty uses its default."),
-	extensionsDir: Schema.string().default("").description("code-server's --extensions-dir. Empty uses its default.")
+	extensionsDir: Schema.string().default("").description("code-server's --extensions-dir. Empty uses its default."),
+	desktopPort: Schema.natural().max(65535).default(41820).description("Port on 127.0.0.1 where DSH Desktop loads the editor.")
 });
 async function apply(ctx, config) {
 	const runtimeDir = await mkdtemp(join(process.env.XDG_RUNTIME_DIR ?? tmpdir(), "dsh-code-server-"));
@@ -868,22 +907,21 @@ async function apply(ctx, config) {
 	}), "code-server: runtime directory");
 	const bridge = await Bridge.listen(join(runtimeDir, "bridge.sock"));
 	ctx.effect(() => () => bridge.dispose(), "code-server: bridge");
-	const admission = (request) => ctx.connection.requestRejection(request);
+	const start = () => codeServer.ensure();
+	const dsh = dshIngress(ctx, start);
+	const desktop = new DesktopIngress(config.desktopPort, start);
+	ctx.effect(() => () => desktop.dispose(), "code-server: Desktop ingress");
 	const codeServer = new CodeServer(ctx.subprocess, {
 		command: config.command,
 		userDataDir: config.userDataDir || void 0,
 		extensionsDir: config.extensionsDir || void 0,
 		env: { [SOCKET_ENV]: bridge.socketPath }
-	}, join(runtimeDir, "code-server.sock"), fileURLToPath(new URL("../extension/dsh-code-bridge.vsix", import.meta.url)), ({ socketPath, commit }) => ctx.effect(() => ctx.webServer.registerUpgrade({
-		path: `${RELAY_PREFIX}/stable-${commit}`,
-		handler: relayUpgrades(admission, socketPath)
-	}), "code-server: WebSocket relay"));
+	}, join(runtimeDir, "code-server.sock"), fileURLToPath(new URL("../extension/dsh-code-bridge.vsix", import.meta.url)), dsh.serveWebSocket);
 	ctx.effect(() => () => codeServer.dispose(), "code-server: process");
-	ctx.effect(() => ctx.webServer.register({
-		kind: "prefix",
-		path: RELAY_PREFIX,
-		handler: relayRequests(admission, () => codeServer.ensure())
-	}), "code-server: HTTP relay");
-	for (const route of rpcRoutes(ctx, bridge, codeServer)) ctx.effect(() => ctx.connection.fetch.register(route), `code-server: ${route.path}`);
+	const editors = {
+		dsh: async () => dsh.base,
+		desktop: () => desktop.base()
+	};
+	for (const route of rpcRoutes(ctx, bridge, codeServer, editors)) ctx.effect(() => ctx.connection.fetch.register(route), `code-server: ${route.path}`);
 }
 export { Config, apply, inject, name };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langify-org/dsh-code-server",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Edit the session's working folder in code-server inside DeepSeek Harness, served through DSH's authenticated web server",
   "keywords": [
     "code-server",