dsh-code-server-app 0.3.11 → 0.3.13

package/README.en.md

@@ -206,35 +206,50 @@ only the editor knows, and lets editor gestures drive the current session.
 - **Everything is read-only**: the bridge never writes files, applies edits, or runs commands. The agent's writes
   still go through its own `fs` tools; the bridge only *knows about* them.
 - Status bar shows `$(plug) DSH` while connected (click it for the log in the "DSH Editor Bridge" output channel).
+- **The extension ships as a built-in** (fixed in 0.3.12): `dshcs-editor-bridge` is installed into
+  `<tree>/lib/vscode/extensions/` next to `dshcs-open-file`. 0.3.0–0.3.11 installed it as a *user* extension
+  instead, and the VS Code server marks any extension that sits in the user extensions folder but in no profile
+  manifest as removed (`.obsolete`, log line `Marked extension as removed`) and then skips it forever — re-marked on
+  every start, so **the bridge never reported any state**. To turn the bridge off use the plugin setting
+  `editorBridge=false` (no mount, no tools) rather than uninstalling the extension from the Extensions view.
 
-### The channels (since 0.3.9 they live on DSH's webServer under `/code-server-bridge`)
+### The channels (since 0.3.13 over **local IPC**: a Windows named pipe / unix socket)
 
 ```
 extension → host   POST /code-server-bridge/sync    one round trip: push editor state + take pending events
 extension → host   POST /code-server-bridge/ask     push an editor question into the current session
 extension → host   GET  /code-server-bridge/health  unauthenticated liveness probe
 extension → host   POST /code-server-bridge/event   extension reports open/close etc. (host log tail)
-host → extension   <extensionsDir>/.dshcs-bridge/bridge.json   base URL + token, re-read by the extension every 5s
+host → extension   <extensionsDir>/.dshcs-bridge/bridge.json   endpoint + token, re-read every 5s
+                   (the directory is announced via the host-injected `DSHCS_EXTENSIONS_DIR` — the extension lives in
+                   the built-in tree now, so it cannot derive it from its own path)
 ```
 
-> **Why not under `/api` (fixed in 0.3.9)**: Connection puts a Host/Origin/cookie fence on `/api`
-> (`requestRejection` in `packages/client/connection/src/index.ts` → 401 without a cookie), while the bridge's
-> client is a **Node process inside the extension host** — it can never hold a browser cookie, so its requests were
-> rejected before ever reaching the plugin's route. Measured on 0.3.7: the extension polled
-> `/api/code-server/bridge/sync` and got either 405 (it reached the launcher/VS Code instead) or 401 (the /api
-> fence) — the bridge had never actually synced. It now mounts on DSH's own webServer with its own token as the
-> only gate. The cost: the bridge needs DSH to provide `webServer` — **the web profile has it, desktop does not**.
-> On desktop the host writes no `bridge.json` (dormant beats pointing at a dead address) and says so in the log;
-> **file opening is unaffected** (it uses the signal file and works in every mode).
+Requests use `http.request({ socketPath })` (`fetch` has no socket support) and **no port is ever opened**.
+
+> **Why not HTTP (settled in 0.3.13, all three measured)**
+> 1. **Desktop has no HTTP surface at all**: the renderer calls `host.fetch()` through Electron IPC
+>    (`createSharedFetchHandler('/api')` in `apps/desktop-host/src/index.ts:308`) — an in-process call, unreachable
+>    from another process; the only HTTP a plugin can mount is the web profile's `webServer`.
+> 2. **`/api` cannot carry it either**: Connection puts a Host/Origin/cookie fence on `/api`
+>    (`requestRejection` in `packages/client/connection/src/index.ts` → 401 without a cookie), while the bridge's
+>    client is a **Node process inside the extension host** — it can never hold a browser cookie. Measured on 0.3.7:
+>    polling `/api/code-server/bridge/sync` returned either 405 (it reached the launcher/VS Code) or 401 (the fence)
+>    — the bridge had never actually synced.
+> 3. The two ends are **processes on the same machine** anyway (extension host ← the IDE the plugin spawned ← the
+>    plugin). Local IPC is strictly smaller than a port: no network surface, no Host/Origin confused-deputy path, and
+>    **web and desktop share one path**. Token auth stays (see below); the Windows pipe name carries a random suffix
+>    and the POSIX socket file is `chmod 0600`.
+>
+> History: 0.3.9–0.3.12 mounted it on DSH's `webServer` prefix — which left desktop permanently dormant.
 
 **Why state is pushed, not pulled**: the extension host is a child process of the VS Code server and **listens on
 no port** — the host cannot call into it. Editor state therefore rides the extension's own polling request, and
 the host caches it for the tools (at most one 600 ms cycle behind; older than 10 s and the tool says so instead
 of passing stale data off as fresh).
 
-**Why no SSE/WebSocket**: the extension host has no HTTP server of its own, and everything DSH can offer is
-request/response (the Connection fetch channel allows only `GET | HEAD | POST`; streaming would need the WS mux
-already owned by `dsh-api-gateway`). Polling also buys two useful properties: it is idempotent (a dropped event
+**Why no SSE/WebSocket**: the extension host has no HTTP server of its own; the bridge's shape is one
+request/response round trip every 600 ms. Polling also buys two useful properties: it is idempotent (a dropped event
 only costs one notification — the data always lives in the editor) and the cached state is inherently fresh.
 
 ### Security model (four invariants; read before touching `lib/bridge.mjs`)
@@ -584,7 +599,7 @@ Host/Origin fence and browser auth); in the desktop profile `apps/desktop-host`
 | POST | `/api/code-server/stop` | Stop and recycle the process tree |
 | POST | `/api/code-server/setup` | **Compatibility no-op**: since 0.1.36 dependencies are installed by the package manager, so this only re-runs the env self-check and returns |
 | POST | `/api/code-server/open-file` | body `{ file }` — writes the signal consumed by the built-in `dshcs-open-file` extension to open the file in code-server |
-| GET | `/code-server-bridge/health` | editor-bridge liveness (**unauthenticated**; no editor data). Mounted on DSH's webServer, not under `/api` |
+| GET | `/code-server-bridge/health` | editor-bridge liveness (**unauthenticated**; no editor data). Runs over **local IPC** (named pipe / unix socket), not under `/api`, and needs no `webServer` |
 | POST | `/code-server-bridge/sync` | editor bridge: the extension pushes state (`{context, diagnostics, workspace, at}`) and takes back events; `?since=<seq>` is the event cursor. Requires `x-dshcs-bridge-token`, and **any Origin header is 403** |
 | POST | `/code-server-bridge/ask` | editor bridge: push an editor question into the current session (`{text, file?, lineStart?, lineEnd?, selection?, languageId?}`); **409** when no session can receive it |
 | POST | `/code-server-bridge/event` | editor bridge: extension reports open/close and similar (host log tail). Requires the token |
@@ -602,7 +617,11 @@ Host/Origin fence and browser auth); in the desktop profile `apps/desktop-host`
 - The right-sidebar tab, guide entry box, file-address claim, and settings card behave the same as in web (code-server remains an
   iframe to the local `http://127.0.0.1:<port>`; the desktop renderer uses `webSecurity: true` with no CSP, so the cross-origin iframe loads).
   The desktop build ships `dsh-client-ui-sidebar-right` in its seed package set as well, so the 0.2.3 "right-sidebar DSH only" rule is
-  not a regression for desktop; the only difference is the missing `webServer`, where `serve: dsh` falls back to loopback.
+  not a regression for desktop; the only difference is the missing `webServer`, where `serve: dsh` falls back to loopback (that path
+  genuinely needs a webServer).
+- **The editor bridge works on desktop since 0.3.13**: it runs over local IPC (named pipe) and does not involve `webServer` at all —
+  the extension host is a child of the IDE the plugin itself spawned, so both ends are on the same machine. The host injects
+  `DSHCS_EXTENSIONS_DIR`, the extension finds `bridge.json`, and `/status` reports `bridge.supported=true` with the pipe name.
 - Install into the desktop profile through the **desktop plugin manager** (not the CLI, see below).
 - **Desktop installs face a 24-hour supply-chain policy (measured 2026-09-10; this is how 0.2.4 got installed)**:
   - the CLI path is unavailable: `dsh plugin --profile desktop …` is rejected (*"profile "desktop" is managed exclusively by the
@@ -663,13 +682,15 @@ What remains on the plugin side:
 
 ## Known limitations
 
-- **The editor bridge needs DSH to provide `webServer`** (corrected in 0.3.9): its client is a Node process inside
-  the extension host, which can only reach DSH over HTTP at DSH's own origin (the bridge mounts under
-  `BRIDGE_BASE` with its own token). **The web profile has webServer (both `serve: dsh` and loopback) → the bridge
-  works; desktop has none → it stays disabled** (`bridge.supported=false`, no `bridge.json` is written, one log
-  line explains it). **File opening is unaffected**: it uses the signal file and works regardless of mode.
-  Up to 0.3.7 the bridge was registered under `/api/code-server/bridge/*` and was killed by Connection's cookie
-  fence (401) — that was a bug.
+- **~~The editor bridge needs DSH to provide `webServer`~~ no longer true (fixed in 0.3.13)**: the bridge now runs
+  over **local IPC** (Windows named pipe / unix socket via `http.request({ socketPath })`), so **web and desktop share
+  one path**, with no `webServer` and no open port. History: 0.3.9–0.3.12 mounted it under DSH's webServer prefix
+  (⇒ desktop stayed dormant); up to 0.3.7 it was registered under `/api/code-server/bridge/*` and was killed by
+  Connection's cookie fence (401). **File opening** was never affected (it uses the signal file).
+- **`/code-server-bridge/health`'s `bridge` field does not mean the extension is running** (clarified in 0.3.12):
+  it only says the bridge *target* is configured. Whether the extension actually runs shows up in the exthost log
+  or by simply calling `editor_context` — 0.3.0–0.3.11 sat in the state "health says bridge:true, extension never
+  loaded" (cause above: the user-level install was marked `.obsolete`).
 - **Bridged state can lag by up to 600 ms**, and the tools say "stale" rather than serving data older than 10 s.
 - **Unsaved buffers are reported, not taken over.** The agent still edits via its own `fs` tools, i.e. against
   disk. What the bridge adds is a notice *before* writing a dirty file, a diff *after*, and a warning instead of

package/README.md

@@ -202,34 +202,46 @@ DSH 用**资源地址**命名文件,`openFile` 只负责把地址交给右侧栏
   桥只是"知道它写了什么"。
 - 编辑器侧的入口还有状态栏的 `$(plug) DSH`(连通时显示,点击打开日志),日志在输出面板
   「DSH Editor Bridge」里 —— 出问题时先看它。
+- **扩展装在内置目录**(0.3.12 修正):`dshcs-editor-bridge` 与 `dshcs-open-file` 一样装进
+  `<树>/lib/vscode/extensions/`。0.3.0–0.3.11 装的是用户级目录,而 VS Code 服务端会把
+  "在用户扩展目录里、不在任何 profile 清单里"的扩展标进 `.obsolete`(日志 `Marked extension as removed`)
+  并永远跳过它 —— 每一轮启动都再标一次,**桥因此从来没有上报过状态**。
+  要关掉桥请用插件设置 `editorBridge=false`(不挂桥、不注册工具),不要再指望在扩展视图里卸载它。
 
-### 三条通道(0.3.9 起走 DSH webServer 的 `/code-server-bridge`)
+### 三条通道(0.3.13 起走**本机 IPC**:Windows 命名管道 / unix socket)
 
 ```
 扩展 → host     POST /code-server-bridge/sync   一趟来回:上报编辑器状态 + 取回待处理事件
 扩展 → host     POST /code-server-bridge/ask    把编辑器里的提问投进当前会话
 扩展 → host     GET  /code-server-bridge/health 无鉴权探活(便于重启后一眼确认)
 扩展 → host     POST /code-server-bridge/event  扩展上报打开/关闭文件等(进 host 日志尾)
-host  → 扩展    <extensionsDir>/.dshcs-bridge/bridge.json  base URL + 令牌(扩展每 5s 重读)
+host  → 扩展    <extensionsDir>/.dshcs-bridge/bridge.json  端点 + 令牌(扩展每 5s 重读)
+                (目录由 host 注入的 `DSHCS_EXTENSIONS_DIR` 告知 —— 扩展装在内置目录里,自己推不出来)
 ```
 
-> **为什么不在 `/api` 下(0.3.9 修正)**:Connection 给 `/api` 装了 Host/Origin/cookie fence
-> (`packages/client/connection/src/index.ts` 里 `requestRejection` → 无 cookie 即 401),而桥的客户端
-> 是扩展宿主里的 **Node 进程** —— 它永远拿不到浏览器 cookie,请求在到达插件路由之前就被挡掉了。
-> 实测(0.3.7):扩展按 `/api/code-server/bridge/sync` 轮询,要么 405(打到 launcher/VS Code)、
-> 要么 401(打到 DSH 的 /api fence),**桥从来没有真正同步过**。
-> 现在桥挂在 DSH 自己的 webServer 前缀下,鉴权完全由桥自己的令牌承担(见下)。
-> 代价:桥需要 DSH 提供 `webServer` —— **web profile 有,desktop 没有**。
-> desktop 下 host 不写 `bridge.json`(宁可休眠,不可指向死地址),并在日志里说明;
-> **文件打开不受影响**(它走信号文件,与 serve 模式无关)。
+请求走 `http.request({ socketPath })`(`fetch` 不支持 socket),**不开任何端口**。
+
+> **为什么不是 HTTP(0.3.13 定论,三条都实测过)**
+> 1. **desktop 根本没有 HTTP 面**:渲染进程经 Electron IPC 调 `host.fetch()`
+>    (`apps/desktop-host/src/index.ts:308` 的 `createSharedFetchHandler('/api')`)—— 那是进程内函数调用,
+>    进程外不可达;插件能挂 HTTP 的只有 web profile 的 `webServer`。
+> 2. **`/api` 也不行**:Connection 给 `/api` 装了 Host/Origin/cookie fence
+>    (`packages/client/connection/src/index.ts` 里 `requestRejection` → 无 cookie 即 401),而桥的客户端
+>    是扩展宿主里的 **Node 进程** —— 它永远拿不到浏览器 cookie。实测(0.3.7):扩展按
+>    `/api/code-server/bridge/sync` 轮询,要么 405(打到 launcher/VS Code)、要么 401(打到 /api fence),
+>    **桥从来没有真正同步过**。
+> 3. 桥的两端本来就是**同一台机器上的两个进程**(扩展宿主 ← 插件 spawn 的 IDE ← 插件)。
+>    本机 IPC 比开端口更小:没有网络面、没有 Host/Origin 混淆代理问题,**web 与 desktop 走同一条路**。
+>    令牌校验照旧保留(见下),Windows 管道名带随机后缀、POSIX socket 文件 `chmod 0600`。
+>
+> 历史:0.3.9–0.3.12 挂在 DSH 的 `webServer` 前缀下 —— 于是 desktop 永远休眠(没有 webServer)。
 
 **为什么状态是"推"而不是"拉"**:扩展宿主是 VS Code server 的一个子进程,**不监听任何端口** ——
 host 反向请求不到它。所以编辑器状态只能在扩展主动发起的那趟轮询里带上来,host 缓存后给工具读
 (缓存滞后最多一个轮询周期 600ms,超过 10s 没更新就判为过期,工具会明说"状态已过期");
 
-**为什么不用 SSE/WebSocket**:扩展宿主里没有 HTTP 服务器,而 DSH 侧能给的无非是请求/响应
-(Connection 的 fetch 通道只允许 `GET | HEAD | POST`,流式要另走已被 `dsh-api-gateway` 占用的 WS mux)。
-轮询反而给了两条好性质:幂等(丢一次事件只是少一次提示,数据本身永远在编辑器里),以及状态天然最新(每趟都刷新)。
+**为什么不用 SSE/WebSocket**:扩展宿主里没有 HTTP 服务器,而桥的形态是"每 600ms 一趟请求/响应"。
+轮询给了两条好性质:幂等(丢一次事件只是少一次提示,数据本身永远在编辑器里),以及状态天然最新(每趟都刷新)。
 
 ### 安全模型(四条不变量,改 `lib/bridge.mjs` 之前先读)
 
@@ -587,13 +599,14 @@ desktop profile 由 `apps/desktop-host` 把 `/api/*` 交给同一个 `createShar
 | POST | `/api/code-server/stop` | 停止并回收进程树 |
 | POST | `/api/code-server/setup` | **兼容空操作**:0.1.36 起依赖由包管理器安装,调用只重新自检 `env` 并返回 |
 | POST | `/api/code-server/open-file` | body `{ file }` — 写信号文件,由内置扩展 `dshcs-open-file` 在 code-server 中打开 |
-| GET | `/code-server-bridge/health` | 编辑器桥探活(**无鉴权**;只回答"桥活着吗",不含任何编辑器数据)。挂 DSH 的 webServer,不在 `/api` 下 |
+| GET | `/code-server-bridge/health` | 编辑器桥探活(**无鉴权**;只回答"桥活着吗",不含任何编辑器数据)。走**本机 IPC**(命名管道 / unix socket),不在 `/api` 下、也不需要 `webServer` |
 | POST | `/code-server-bridge/sync` | 编辑器桥:扩展上报状态(`{context, diagnostics, workspace, at}`)并取回事件;`?since=<seq>` 是事件游标。需 `x-dshcs-bridge-token`,**带 Origin 一律 403** |
 | POST | `/code-server-bridge/ask` | 编辑器桥:把编辑器里的提问投进当前会话(`{text, file?, lineStart?, lineEnd?, selection?, languageId?}`);没有可投递的会话时回 **409** |
 | POST | `/code-server-bridge/event` | 编辑器桥:扩展上报打开/关闭文件等(进 host 日志尾)。需令牌 |
 
 > 桥的四条路由都自带令牌鉴权(它们**不依赖** DSH 的 cookie fence —— 扩展宿主拿不到浏览器 cookie),
-> 且永远只读。这也是它们**不能**挂在 `/api` 下的原因(见「与 DSH 的协同」)。
+> 且永远只读。传输是本机 IPC(0.3.13 起),所以 **web 与 desktop 同一套**:
+> 端点由 host 写在 `bridge.json` 的 `pipe` 字段里,扩展用 `http.request({ socketPath })` 访问。
 
 > 除桥之外,插件不再注册任何插件自有 HTTP 路由;code-server 图标已内联为 data URI(client bundle 内),
 > 因此客户端不请求任何插件自有 HTTP 资源。
@@ -605,7 +618,10 @@ desktop profile 由 `apps/desktop-host` 把 `/api/*` 交给同一个 `createShar
 - 右侧栏标签、guide 入口框、文件地址认领、设置卡片在 desktop 下与 web 相同(code-server 仍是本机 `http://127.0.0.1:<port>` 的 iframe;
   桌面端 `webSecurity: true` 且页面无 CSP 限制,跨源 iframe 正常加载)。
   桌面端同样自带 `dsh-client-ui-sidebar-right`(见 desktop 构建 seed 包列表),因此 0.2.3 的
-  "只支持带右侧栏的 DSH" 对 desktop 不构成降级;唯一差别是 desktop 无 `webServer`,`serve: dsh` 会自动回退 loopback。
+  "只支持带右侧栏的 DSH" 对 desktop 不构成降级;`serve: dsh` 会自动回退 loopback(那条路确实需要 webServer)。
+- **编辑器桥在 desktop 下可用(0.3.13 起)**:桥走本机 IPC(命名管道),与 `webServer` 无关 ——
+  扩展宿主是插件自己 spawn 的 IDE 的子进程,两端都在同一台机器上。host 注入 `DSHCS_EXTENSIONS_DIR` 后
+  扩展即可找到 `bridge.json`;`/status` 的 `bridge.supported/endpoint` 在 desktop 下同样是 `true`/管道名。
 - 安装到 desktop profile:桌面端插件管理窗(**不是** CLI,见下)。
 - **桌面端安装的 24 小时供应链策略(实测,2026-09-10,已用它装上 0.2.4)**:
   - CLI 路径不可用:`dsh plugin --profile desktop …` 会被拒绝(*"profile "desktop" is managed exclusively by the Electron application"*),
@@ -645,12 +661,14 @@ desktop profile 由 `apps/desktop-host` 把 `/api/*` 交给同一个 `createShar
 
 ## 已知限制
 
-- **编辑器桥需要 DSH 提供 `webServer`**(0.3.9 修正):桥的客户端是扩展宿主里的 Node 进程,
-  它只能通过 HTTP 打到 DSH 自己的 origin(桥挂在 `BRIDGE_BASE` 前缀下,自带令牌鉴权)。
-  **web profile(`serve: dsh` 或 loopback 都行)有 webServer → 桥可用;desktop 没有 → 不启用**
-  (status 的 `bridge.supported=false`,host 不写 `bridge.json`,日志里说明一次)。
-  **文件打开不受影响**:它走信号文件,与 serve 模式和 webServer 都无关。
-  0.3.7 及以前把桥挂在 `/api/code-server/bridge/*`,被 Connection 的 cookie fence 401 挡死 —— 那是个 bug。
+- **~~编辑器桥需要 DSH 提供 `webServer`~~ 已不成立(0.3.13 修正)**:桥改走**本机 IPC**
+  (Windows 命名管道 / unix socket,`http.request({ socketPath })`),**web 与 desktop 同一套**,
+  不需要 `webServer`、也不开端口。历史:0.3.9–0.3.12 挂在 DSH 的 webServer 前缀下 ⇒ desktop 永远休眠;
+  0.3.7 及以前挂在 `/api/code-server/bridge/*` ⇒ 被 Connection 的 cookie fence 401 挡死。
+  **文件打开**从来不受影响(它走信号文件)。
+- **`/code-server-bridge/health` 的 `bridge` 字段不代表扩展在跑**(0.3.12 澄清):它只表示"桥的目标已就绪"。
+  扩展是否真的在跑,看 exthost 日志里有没有它的激活记录,或直接用 `editor_context` 试一次 ——
+  0.3.0–0.3.11 就是"health 说 bridge:true、扩展却从没被加载"的状态(原因见上:用户级安装被标 `.obsolete`)。
 - **桥的状态有最多 600ms 滞后**:扩展每 600ms 推一次;超过 10s 没更新时工具会明说"状态已过期"
   而不是拿旧数据当新数据(例如用户在 IDE 里关掉面板之后)。
 - **未保存缓冲区是"上报"而不是"接管"**:agent 仍然通过它自己的 `fs` 工具按磁盘内容编辑。

package/assets/extensions/dshcs-editor-bridge/extension.js

@@ -74,12 +74,6 @@ function log(message) {
   if (output !== null) output.appendLine(`[${new Date().toISOString()}] ${message}`);
 }
 
-/** 取扩展所在目录(桥配置与它同级:extensionsDir/.dshcs-bridge/)。 */
-function extensionDir() {
-  // __dirname = <extensionsDir>/dshcs-editor-bridge/lib  → 上溯两级即 extensionsDir
-  return path.resolve(__dirname, '..', '..');
-}
-
 /** 是否落在某个工作区文件夹内(不能把 workspaceFolder 之外的路径喂给 DSH)。 */
 function isInWorkspace(fsPath) {
   try {
@@ -359,7 +353,7 @@ async function pollOnce() {
   }
   if (!connected) {
     connected = true;
-    log(`已连接宿主 ${client.config.url}`);
+    log(`已连接宿主(${client.config.pipe})`);
     updateStatusBar();
   }
   lastPollAt = Date.now();
@@ -384,7 +378,7 @@ function updateStatusBar() {
   if (statusBar === null) return;
   if (connected && client !== null && client.config !== null) {
     statusBar.text = '$(plug) DSH';
-    statusBar.tooltip = `编辑器桥已连接:${client.config.url}\n上次轮询:${lastPollAt === 0 ? '—' : new Date(lastPollAt).toLocaleTimeString()}\n点击查看日志`;
+    statusBar.tooltip = `编辑器桥已连接:${client.config.pipe}\n上次轮询:${lastPollAt === 0 ? '—' : new Date(lastPollAt).toLocaleTimeString()}\n点击查看日志`;
     statusBar.command = 'dsh-code-server.showBridgeLog';
     statusBar.show();
   } else {
@@ -462,12 +456,15 @@ function activate(context) {
     vscode.workspace.registerTextDocumentContentProvider('dshcs-old', oldSideProvider),
   );
 
-  client = createClient({ extensionsDir: extensionDir() });
+  // 配置目录由 bridge-client 统一解析(host 注入的 DSHCS_EXTENSIONS_DIR → 自身位置反推)。
+  // **不要在这里自己算**:0.3.0–0.3.11 那段 `resolve(__dirname,'..','..')` 比 <extensionsDir>
+  // 还高一级,任何布局都读不到 bridge.json ⇒ 桥一直休眠(见 docs 第 18 节)。
+  client = createClient();
   if (client.refresh() === null) {
     log('未找到桥配置(休眠)。DSH 插件启用编辑器桥并启动 IDE 后,这里会自动连上。');
   } else {
     client.restore();
-    log(`发现桥配置:${client.config.url}`);
+    log(`发现桥配置:${client.config.pipe}`);
   }
 
   // host 请求时才现算,这里只维护"上次计数",用于日志与将来的变化上报。
@@ -514,9 +511,9 @@ function activate(context) {
   // 定期重读配置(令牌/端口轮换后最多 CONFIG_REREAD_MS 恢复)。
   const refreshTimer = setInterval(() => {
     if (client === null) return;
-    const before = client.config === null ? null : client.config.url;
+    const before = client.config === null ? null : client.config.pipe;
     const next = client.refresh();
-    const after = next === null ? null : next.url;
+    const after = next === null ? null : next.pipe;
     if (before !== after) {
       log(`桥目标变化:${before ?? '(休眠)'} → ${after ?? '(休眠)'}`);
       if (after !== null) client.restore();

package/assets/extensions/dshcs-editor-bridge/lib/bridge-client.js

@@ -6,59 +6,94 @@
 //
 // 三条通道里属于扩展的两条:
 //   1. 读 `<extensionsDir>/.dshcs-bridge/bridge.json` —— host 写,扩展**每次请求前重读**
-//      (host 重启会让端口与令牌轮换,而 IDE 进程可能被 adopt 继续活着,env 方案跟不上);
+//      (host 重启会让端点与令牌轮换,而 IDE 进程可能被 adopt 继续活着,env 方案跟不上);
 //   2. `POST <BRIDGE_BASE>/sync?since=N` —— **一趟来回同时做两件事**:
 //      把编辑器状态(活动文件/脏缓冲区/诊断)推给 host,并取回 host 推来的 agent 改动提示。
 //      为什么合并:扩展宿主里没有 HTTP 服务器,host 反向请求不到它,状态只能由扩展推上来;
 //      而轮询本来就在跑,合并成一个请求就省掉了第二个定时器与一次往返。
 //      带着 x-dshcs-bridge-token 头。
+//
+// **传输是本机 IPC(0.3.13 起)**:配置里的 `pipe` 是 Windows 命名管道名或 unix socket 路径,
+// 请求走 `http.request({ socketPath })`。不走 HTTP 的三个原因(都实测过):desktop 没有 HTTP 面
+// (渲染进程经 Electron IPC 调 host.fetch)、`/api` 有浏览器 cookie fence(扩展宿主拿不到 cookie)、
+// DSH 的 webServer 前缀只有 web profile 有。详见 lib/bridge-ipc.mjs 与 docs 第 19 节。
 
 'use strict';
 
 const fs = require('fs');
 const path = require('path');
+const http = require('http');
 
 /** 与 host 侧 lib/bridge.mjs 的常量保持一致(改动必须两边同步;scripts/test-bridge-extension.mjs
  *  里有一条一致性断言,会把两边的字面量放在一起比)。 */
 const BRIDGE_DIRNAME = '.dshcs-bridge';
 const BRIDGE_FILENAME = 'bridge.json';
-/** 桥的挂载前缀。**故意不在 `/api` 下**:那层有 Connection 的 cookie fence,扩展宿主(Node 进程)
- *  拿不到浏览器 cookie,请求会在到达插件路由之前被 401(0.3.9 修正)。 */
+/** 本机 IPC 上的路由前缀(不是 URL 前缀;语义见 lib/bridge.mjs)。 */
 const BRIDGE_BASE = '/code-server-bridge';
 const TOKEN_HEADER = 'x-dshcs-bridge-token';
 const STATE_FILENAME = 'extension-state.json';
 const REQUEST_TIMEOUT_MS = 3000;
 /** 轮询间隔:host 侧事件只是"去看一眼这个文件"的提示,600ms 足够且几乎无开销。 */
 const POLL_INTERVAL_MS = 600;
-/** 宿主配置重读间隔(令牌/端口轮换后最多这么久恢复)。 */
+/** 宿主配置重读间隔(端点/令牌轮换后最多这么久恢复)。 */
 const CONFIG_REREAD_MS = 5000;
 
+/** Windows 命名管道的统一前缀(`\\.\pipe\` 是本机命名空间)。 */
+const WIN_PIPE_PREFIX = '\\\\.\\pipe\\';
 
 const TOKEN_RE = /^[0-9A-Za-z_-]{16,128}$/;
 
-/** 桥配置路径;`extensionsDir` 可由调用方给(测试用),默认从 __dirname 反推。 */
+/** 端点形状校验:Windows 必须是命名管道名,其它平台必须像绝对路径。
+ *  (与 host 侧 lib/bridge-ipc.mjs 的 `isBridgeEndpoint` 同一条判定,两边各有实现、
+ *   一致性由 scripts/test-bridge-extension.mjs 的断言钉住 —— 扩展是随包分发的静态文件,
+ *   不能 import host 的代码。) */
+function isBridgeEndpoint(value) {
+  if (typeof value !== 'string' || value === '') return false;
+  if (process.platform === 'win32') return value.startsWith(WIN_PIPE_PREFIX);
+  return value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
+}
+
+
+/** 桥配置所在目录(=`<extensionsDir>/.dshcs-bridge`)。
+ *
+ *  取值顺序(0.3.12 修正 —— 这里以前写错了,是"桥永远休眠"的另一半原因):
+ *   1. **host 注入的 `DSHCS_EXTENSIONS_DIR`**(launcher 的 env 会被扩展宿主继承,与 dshcs-open-file
+ *      用 `DSHCS_OPEN_FILE_SIGNAL` 是同一套做法)。0.3.12 起桥扩展装在**内置**目录(树里),
+ *      与 <extensionsDir> 不再同级,只能靠 host 告诉它;
+ *   2. 调用方显式给的 `extensionsDir`(测试用);
+ *   3. 从本文件反推:`<extensionsDir>/dshcs-editor-bridge/lib/` 上溯两级。
+ *      —— 注意 `extension.js` 曾自己算过一次,算成了三级(比 <extensionsDir> 还高一级),
+ *      即使按老的用户级布局也读不到配置。计算只留在这里一处。
+ */
+function defaultExtensionsDir() {
+  const fromEnv = process.env.DSHCS_EXTENSIONS_DIR;
+  if (typeof fromEnv === 'string' && fromEnv.trim() !== '') return fromEnv;
+  return path.resolve(__dirname, '..', '..');
+}
+
+/** 桥配置路径;`extensionsDir` 可由调用方给(测试用),默认见 `defaultExtensionsDir`。 */
 function bridgeFile(extensionsDir) {
-  const dir = extensionsDir ?? path.resolve(__dirname, '..', '..');
+  const dir = extensionsDir ?? defaultExtensionsDir();
   return path.join(dir, BRIDGE_DIRNAME, BRIDGE_FILENAME);
 }
 
 /** 扩展自己的小状态文件(since 游标),与桥配置同目录。 */
 function stateFile(extensionsDir) {
-  const dir = extensionsDir ?? path.resolve(__dirname, '..', '..');
+  const dir = extensionsDir ?? defaultExtensionsDir();
   return path.join(dir, BRIDGE_DIRNAME, STATE_FILENAME);
 }
 
 /**
  * 读桥配置。
- * @returns {{url: string, token: string, pid: number|null}|null} null = 未配置/格式不对 → 休眠
+ * @returns {{pipe: string, token: string, pid: number|null}|null} null = 未配置/格式不对 → 休眠
  */
 function readBridgeConfig(extensionsDir) {
   try {
     const raw = JSON.parse(fs.readFileSync(bridgeFile(extensionsDir), 'utf8'));
     if (raw === null || typeof raw !== 'object') return null;
-    if (typeof raw.url !== 'string' || !/^http:\/\/(127\.0\.0\.1|localhost|\[::1\]):\d+$/.test(raw.url)) return null;
+    if (!isBridgeEndpoint(raw.pipe)) return null;
     if (!TOKEN_RE.test(String(raw.token))) return null;
-    return { url: raw.url, token: String(raw.token), pid: Number.isSafeInteger(raw.pid) ? raw.pid : null };
+    return { pipe: String(raw.pipe), token: String(raw.token), pid: Number.isSafeInteger(raw.pid) ? raw.pid : null };
   } catch {
     return null;
   }
@@ -91,22 +126,68 @@ function writeState(extensionsDir, state) {
 
 /** host 侧拒绝时的统一错误(带 status,便于区分 401/503/403)。 */
 class BridgeError extends Error {
-  constructor(message, status) {
+  constructor(message, status, code) {
     super(message);
     this.name = 'BridgeError';
     this.status = status;
+    /** 底层 IO 错误码(EPERM/ENOENT/ECONNREFUSED…);状态栏与日志据此区分"权限/不存在/没在跑"。 */
+    this.code = code;
   }
 }
 
+/**
+ * 默认传输:本机 IPC(Windows 命名管道 / unix socket)上的一个 HTTP 请求。
+ *
+ * 不用 `fetch`:WHATWG fetch 不支持 `socketPath`,而桥**必须**绕开网络栈
+ * (desktop 没有 HTTP 面;web 上走 HTTP 则要么撞 cookie fence、要么依赖 webServer)。
+ * 用 `http.request({socketPath})` 是 Node 里唯一干净的写法 —— 与 host 侧
+ * `lib/launcher.mjs` 的 `--pipe`、`lib/index.js` 的 `healthCheckPipe` 同一套。
+ *
+ * @param {{socketPath: string, path: string, method: string, headers: object,
+ *          body: string|null, timeoutMs: number}} options
+ * @returns {Promise<{status: number, json: unknown}>}
+ */
+function defaultRequest({ socketPath, path: routePath, method, headers, body, timeoutMs }) {
+  return new Promise((resolve, reject) => {
+    const payload = typeof body === 'string' && body !== '' ? Buffer.from(body, 'utf8') : null;
+    const req = http.request({
+      socketPath,
+      path: routePath,
+      method,
+      headers: payload === null ? headers : Object.assign({ 'content-length': String(payload.length) }, headers),
+      timeout: timeoutMs,
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => { chunks.push(chunk); });
+      res.on('error', reject);
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        let json = null;
+        try {
+          json = text === '' ? null : JSON.parse(text);
+        } catch {
+          json = null;
+        }
+        resolve({ status: res.statusCode === undefined ? 0 : res.statusCode, json });
+      });
+    });
+    req.on('timeout', () => { req.destroy(new Error(`请求超时(${timeoutMs}ms)`)); });
+    req.on('error', reject);
+    if (payload !== null) req.write(payload);
+    req.end();
+  });
+}
+
 /**
  * 造一个桥客户端。
  *
- * @param {{extensionsDir?: string, fetchImpl?: Function, now?: Function}} [options]
- *        `fetchImpl` / `now` 可注入,便于单测(默认用 Node 18+ 的全局 fetch)。
+ * @param {{extensionsDir?: string, requestImpl?: Function, now?: Function}} [options]
+ *        `requestImpl` / `now` 可注入,便于单测(默认走 `http.request({socketPath})`)。
  */
 function createClient(options) {
   const extensionsDir = options && options.extensionsDir !== undefined ? options.extensionsDir : undefined;
-  const fetchImpl = (options && options.fetchImpl) || ((...args) => fetch(...args));
+  /** 传输:本机 IPC 上的一个 HTTP 请求。注入点只在测试里用。 */
+  const requestImpl = (options && options.requestImpl) || defaultRequest;
   /** 当前配置(null = 休眠)。 */
   let config = null;
   /** 上次读配置的时间(避免每 600ms 都碰磁盘)。 */
@@ -119,8 +200,8 @@ function createClient(options) {
     if (!force && config !== null && now - configReadAt < CONFIG_REREAD_MS) return config;
     configReadAt = now;
     const next = readBridgeConfig(extensionsDir);
-    if (next !== null && config !== null && next.url !== config.url) {
-      // 端口/实例变了:游标失去意义(旧实例的事件不该在新实例上重放)。
+    if (next !== null && config !== null && next.pipe !== config.pipe) {
+      // 端点/实例变了:游标失去意义(旧实例的事件不该在新实例上重放)。
       since = 0;
     }
     if (next !== null && config !== null && next.pid !== config.pid) since = 0;
@@ -133,24 +214,21 @@ function createClient(options) {
     const current = refreshConfig(true);
     if (current === null) throw new BridgeError('编辑器桥未配置(休眠中)', 0);
     const headers = Object.assign({ [TOKEN_HEADER]: current.token }, (init && init.headers) || {});
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
     let response;
     try {
-      response = await fetchImpl(current.url + route, Object.assign({}, init, { headers, signal: controller.signal }));
+      response = await requestImpl({
+        socketPath: current.pipe,
+        path: route,
+        method: (init && init.method) || 'GET',
+        headers,
+        body: init && init.body !== undefined ? init.body : null,
+        timeoutMs: REQUEST_TIMEOUT_MS,
+      });
     } catch (error) {
-      throw new BridgeError(`无法连接宿主:${error && error.message ? error.message : String(error)}`, 0);
-    } finally {
-      clearTimeout(timer);
-    }
-    const text = await response.text();
-    let body = null;
-    try {
-      body = text === '' ? null : JSON.parse(text);
-    } catch {
-      body = null;
+      throw new BridgeError(`无法连接宿主:${error && error.message ? error.message : String(error)}`, 0, error && error.code ? error.code : undefined);
     }
-    if (!response.ok) {
+    const body = response !== null && typeof response.json === 'object' ? response.json : null;
+    if (response.status < 200 || response.status >= 300) {
       const reason = body !== null && typeof body.error === 'string' ? body.error : `HTTP ${response.status}`;
       throw new BridgeError(reason, response.status);
     }
@@ -201,7 +279,7 @@ function createClient(options) {
         }
         return { ok: true, events };
       } catch (error) {
-        return { ok: false, error: error.message, status: error.status };
+        return { ok: false, error: error.message, status: error.status, code: error.code };
       }
     },
     /** 把"选中内容 + 问题"投给 DSH 的当前会话。 */
@@ -236,6 +314,9 @@ module.exports = {
   CONFIG_REREAD_MS,
   REQUEST_TIMEOUT_MS,
   BridgeError,
+  isBridgeEndpoint,
+  defaultExtensionsDir,
+  defaultRequest,
   bridgeFile,
   stateFile,
   readBridgeConfig,

package/lib/bridge-ipc.mjs

@@ -0,0 +1,113 @@
+/**
+ * lib/bridge-ipc.mjs — 编辑器桥的传输层:本机 IPC(Windows 命名管道 / 其它平台 unix socket)。
+ *
+ * 为什么不走 HTTP(0.3.13 定论,三条都实测过):
+ *  1. **desktop 根本没有 HTTP 面**:渲染进程经 Electron IPC 调 `host.fetch()`
+ *     (`apps/desktop-host/src/index.ts:308` 的 `createSharedFetchHandler('/api')`),
+ *     那是**进程内函数调用**,进程外不可达;插件能挂 HTTP 的只有 web profile 的 `webServer`。
+ *  2. **`/api` 那条路即使有 webServer 也不行**:Connection 给 `/api` 装了浏览器 cookie fence
+ *     (`packages/client/connection/src/index.ts:128-134` 的 `requestRejection` → 401),
+ *     而桥的客户端是扩展宿主里的 **Node 进程**,永远拿不到浏览器 cookie。
+ *  3. 桥的双方本来就是**同一台机器上的两个进程**(扩展宿主 ← 插件 spawn 的 IDE ← 插件),
+ *     本机 IPC 比开端口更小:没有网络面、没有 Host/Origin 混淆代理问题。
+ *
+ * 与 `serve: dsh` 的 IDE 挂载同源:`net`/`http` 的 `listen(path)` + `http.request({socketPath})`
+ * 在本机已被验证可用(见 lib/launcher.mjs 的 `--pipe` 与 lib/index.js 的 `healthCheckPipe`)。
+ *
+ * 安全:令牌校验仍然保留(见 lib/bridge.mjs 的 `bridgeGuard`)。Windows 命名管道用随机后缀
+ * (不可猜),POSIX 上 socket 文件 `chmod 0600` 并在关闭时删除。
+ */
+
+import { chmodSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { join, dirname } from 'node:path';
+
+/** 命名管道的统一前缀(Windows;`\\.\pipe\` 是本机命名空间,不经过网络栈)。 */
+const WIN_PIPE_PREFIX = '\\\\.\\pipe\\';
+
+/** 本机 IPC 端点路径。Windows = 命名管道名;其它平台 = <dataRoot>/bridge-<pid>-<rand>.sock。 */
+export function bridgeEndpointPath(root, pid = process.pid, platform = process.platform) {
+  const rand = randomBytes(6).toString('hex');
+  if (platform === 'win32') return `${WIN_PIPE_PREFIX}dshcs-bridge-${pid}-${rand}`;
+  return join(root, `bridge-${pid}-${rand}.sock`);
+}
+
+/** 端点是不是本机 IPC(扩展侧与测试共用同一条判定)。 */
+export function isBridgeEndpoint(value, platform = process.platform) {
+  if (typeof value !== 'string' || value === '') return false;
+  if (platform === 'win32') return value.startsWith(WIN_PIPE_PREFIX);
+  return value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
+}
+
+/** POSIX 上清掉上一次崩溃留下的 socket 文件(24h 以前的;不碰别人正在用的)。
+ *  Windows 命名管道由内核回收,不需要清理。 */
+function sweepStaleSockets(root, log) {
+  let names;
+  try {
+    names = readdirSync(root);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  for (const name of names) {
+    if (!/^bridge-\d+-[0-9a-f]{12}\.sock$/.test(name)) continue;
+    const file = join(root, name);
+    try {
+      if (statSync(file).mtimeMs < cutoff) rmSync(file, { force: true });
+    } catch {
+      // 清理失败无关正确性(端点带随机后缀,不会撞名)
+    }
+  }
+}
+
+/**
+ * 起一个只服务桥路由的本机 IPC 监听口。
+ *
+ * @param {{socketPath: string, handler: (req: import('node:http').IncomingMessage,
+ *          res: import('node:http').ServerResponse) => unknown, log?: (message: string) => void}} options
+ * @returns {Promise<{path: string, close: () => Promise<void>}>} 监听成功后的句柄(失败则 reject)
+ */
+export function startBridgeListener({ socketPath, handler, log = () => {} }) {
+  const isWinPipe = socketPath.startsWith(WIN_PIPE_PREFIX);
+  if (!isBridgeEndpoint(socketPath)) {
+    return Promise.reject(new Error(`非法的桥端点路径:${socketPath}`));
+  }
+  if (!isWinPipe) {
+    sweepStaleSockets(dirname(socketPath), log);
+    // unix socket 文件必须先不存在,否则 listen 直接 EADDRINUSE(端点带随机后缀,撞名不可能)
+    try { rmSync(socketPath, { force: true }); } catch { /* ignore */ }
+  }
+  const server = createServer(handler);
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.removeListener('listening', onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.removeListener('error', onError);
+      server.on('error', (error) => log(`桥监听异常:${error && error.code ? error.code : error && error.message ? error.message : error}`));
+      if (!isWinPipe) {
+        try { chmodSync(socketPath, 0o600); } catch { /* 权限收紧失败不影响可用性 */ }
+      }
+      resolve({
+        path: socketPath,
+        close: () => new Promise((done) => {
+          server.close(() => {
+            if (!isWinPipe) {
+              try { rmSync(socketPath, { force: true }); } catch { /* ignore */ }
+            }
+            done();
+          });
+        }),
+      });
+    };
+    server.once('error', onError);
+    server.once('listening', onListening);
+    try {
+      server.listen(socketPath);
+    } catch (error) {
+      onError(error);
+    }
+  });
+}

package/lib/bridge.mjs

@@ -20,13 +20,14 @@
  * - **host → 扩展的"事件"**:同一个轮询的响应体(环形缓冲 + `since` 游标)。
  *   事件只是"去看一眼这个文件"的提示,不是数据。
  *
- * ## 认证(关键:桥绕开了 DSH 的 cookie fence,所以自带令牌)
+ * ## 认证(关键:桥绕开 DSH 的浏览器 fence,所以自带令牌)
  *
- * `/api/*` 的 Host/Origin/cookie 校验由 Connection 在分发前做
- * (`dsh-client-connection/lib/index.js`:`requestRejection` → 403 不可信 / 401 无 cookie)。
- * 扩展宿主是 Node 进程:`fetch` **不带 Origin**,Host 是 `127.0.0.1:<port>`(在 trustedHosts 内)
- * → 过 403;但它**拿不到浏览器 cookie** → 必然 401。所以桥路由必须自带独立令牌校验,
- * 且**不能**依赖 Connection 的认证。反过来,凭令牌就能调用,因此:
+ * **传输:本机 IPC**(0.3.13 起)—— Windows 命名管道 / 其它平台 unix socket,见 lib/bridge-ipc.mjs。
+ * 为什么不走 DSH 的 HTTP 面:`/api` 的 Host/Origin/cookie 校验由 Connection 在分发前做
+ * (`packages/client/connection/src/index.ts`:`requestRejection` → 403 不可信 / 401 无 cookie),
+ * 而扩展宿主是 Node 进程:`fetch` **不带 Origin**,但它**拿不到浏览器 cookie** → 必然 401;
+ * 挂 `webServer` 前缀(0.3.9–0.3.12)则只有 web profile 有 webServer,desktop 根本没有 HTTP 面。
+ * 桥两端本来就是同一台机器上的两个进程,所以传输用本机 IPC,鉴权仍走独立令牌:
  *
  * ## 安全不变量(改这个文件之前先读这四条)
  *
@@ -42,6 +43,7 @@
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { isBridgeEndpoint } from './bridge-ipc.mjs';
 
 /** 桥端点目录名(位于 extensionsDir 下 —— 扩展必须能读到它)。 */
 export const BRIDGE_DIRNAME = '.dshcs-bridge';
@@ -49,14 +51,15 @@ export const BRIDGE_DIRNAME = '.dshcs-bridge';
 /** 桥配置文件名。 */
 export const BRIDGE_FILENAME = 'bridge.json';
 
-/** 桥路由前缀。
+/** 桥路由路径前缀(本机 IPC 上的路径;**不是** URL 前缀)。
  *
  *  **故意不放在 `/api` 下(0.3.9 修正)**:Connection 给 `/api` 装了 Host/Origin/cookie fence
  *  (`packages/client/connection/src/index.ts`:`requestRejection` → 无 cookie 即 401),而桥的客户端是
  *  VS Code 扩展宿主里的一个 Node 进程 —— 它**永远拿不到浏览器 cookie**,请求在到达插件路由之前就被挡掉了。
  *  实测(0.3.7):扩展按 `/api/code-server/bridge/sync` 轮询,请求要么 405(打到 launcher/VS Code)、
  *  要么 401(打到 DSH 的 /api fence),桥从来没有真正同步过。
- *  现在挂到 DSH 自己的 webServer 前缀下,鉴权完全由桥自己的令牌承担(见下方安全不变量)。 */
+ *  0.3.9–0.3.12 挂在 DSH 的 webServer 前缀上(只有 web profile 有 webServer);
+ *  **0.3.13 起走本机 IPC**(Windows 命名管道 / unix socket),web 与 desktop 同一条路 —— 见 lib/bridge-ipc.mjs。 */
 export const BRIDGE_BASE = '/code-server-bridge';
 
 /** 事件环形缓冲上限:超出即丢最旧的(事件是提示,不是数据)。 */
@@ -81,32 +84,23 @@ export function mintBridgeToken() {
   return randomBytes(24).toString('base64url');
 }
 
-/**
- * 由实际监听地址算桥的基址。
- * @param {string} host 绑定地址(仅回环)
- * @param {number} port 实际端口
- */
-export function bridgeUrl(host, port) {
-  const h = host === '::1' ? '[::1]' : host;
-  return `http://${h}:${port}`;
-}
-
 /** 桥配置文件路径(`<extensionsDir>/.dshcs-bridge/bridge.json`)。 */
 export function bridgeFile(extensionsDir) {
   return path.join(extensionsDir, BRIDGE_DIRNAME, BRIDGE_FILENAME);
 }
 
 /**
- * 原子写桥配置。扩展每 5s 重读一次;需要时(端口/令牌变化)由 host 重写。
+ * 原子写桥配置。扩展每 5s 重读一次;需要时(端点/令牌变化)由 host 重写。
  * @param {string} extensionsDir 扩展目录
- * @param {{url: string, token: string, pid: number|null, startedAt: number|null}} value
+ * @param {{pipe: string, token: string, pid: number|null, startedAt: number|null}} value
  */
 export function writeBridgeConfig(extensionsDir, value) {
   const file = bridgeFile(extensionsDir);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const payload = JSON.stringify({
-    version: 1,
-    url: value.url,
+    version: 2,
+    /** 本机 IPC 端点(Windows 命名管道名 / 其它平台 unix socket 绝对路径)。0.3.13 起取代 `url`。 */
+    pipe: value.pipe,
     token: value.token,
     pid: value.pid,
     startedAt: value.startedAt,
@@ -134,12 +128,14 @@ export function removeBridgeConfig(extensionsDir) {
   }
 }
 
-/** 读回桥配置(诊断用;缺失或格式不对返回 null)。 */
+/** 读回桥配置(诊断用;缺失或格式不对返回 null)。
+ *  端点形状与扩展侧同判定(见 lib/bridge-ipc.mjs 的 `isBridgeEndpoint`):
+ *  Windows 必须是命名管道名,其它平台必须是绝对路径 —— 免得把一个写坏的端点当成有效配置。 */
 export function readBridgeConfig(extensionsDir) {
   try {
     const raw = JSON.parse(fs.readFileSync(bridgeFile(extensionsDir), 'utf8'));
     if (raw === null || typeof raw !== 'object') return null;
-    if (typeof raw.url !== 'string' || !TOKEN_RE.test(String(raw.token))) return null;
+    if (!isBridgeEndpoint(raw.pipe) || !TOKEN_RE.test(String(raw.token))) return null;
     return raw;
   } catch {
     return null;

package/lib/index.js

@@ -43,7 +43,6 @@ import {
   BRIDGE_DIRNAME,
   bodyWithinLimit,
   bridgeGuard,
-  bridgeUrl,
   createContextCache,
   createEventRing,
   mintBridgeToken,
@@ -51,6 +50,7 @@ import {
   removeBridgeConfig,
   writeBridgeConfig,
 } from './bridge.mjs';
+import { bridgeEndpointPath, startBridgeListener } from './bridge-ipc.mjs';
 import { registerEditorPrompt, registerEditorTools, setPromptLiveProbe } from './bridge-tools.mjs';
 import { deliverEditorPrompt } from './bridge-session.mjs';
 import { registerBridgeObserver } from './bridge-observe.mjs';
@@ -185,13 +185,13 @@ function launcherPath() {
 /** 扩展安装目标:`placement: 'builtin'` 时优先 VS Code「内置扩展」目录 = <树>/lib/vscode/extensions
  *  (位于程序内置目录的扩展被 VS Code 视为内置——用户视图显示为"内置",**不能卸载**);
  *  `placement: 'user'` 时只用 --extensions-dir(用户级扩展,可被用户禁用/卸载)。
- *  返回 { dst, builtin }——builtin=true 时是核心路径;找不到树时回退用户级。 */
-function extensionTarget(extensionsDir, name, placement = 'builtin') {
+ *  返回 { dst, builtin }——builtin=true 时是核心路径;找不到树时回退用户级。
+ *  `treeRoot` 可注入(测试用):默认 `vsRoot()`,注入后测试不会碰真实树。 */
+function extensionTarget(extensionsDir, name, placement = 'builtin', treeRoot = vsRoot()) {
   if (placement === 'builtin') {
     try {
-      const root = vsRoot();
-      if (root !== null) {
-        const vscodeExt = path.join(root, 'lib', 'vscode', 'extensions');
+      if (treeRoot !== null) {
+        const vscodeExt = path.join(treeRoot, 'lib', 'vscode', 'extensions');
         if (fs.existsSync(vscodeExt)) {
           return { dst: path.join(vscodeExt, name), builtin: true };
         }
@@ -203,12 +203,19 @@ function extensionTarget(extensionsDir, name, placement = 'builtin') {
 
 /** 树内自带扩展清单。
  *  - dshcs-open-file:host 信号文件 → VS Code 打开文件(可带行号)。**内置**(用户不需要看到它)。
- *  - dshcs-editor-bridge(0.3.0):编辑器桥的扩展侧。**必须用户级** —— 它是可选能力,
- *    用户得有办法一键禁用;内置扩展按 VS Code 语义不能禁用。代价是用户可能卸载它,
- *    这没关系:host 侧本来就按"桥不可用"降级。 */
+ *  - dshcs-editor-bridge(0.3.0):编辑器桥的扩展侧。**必须内置**(0.3.12 修正;0.3.0–0.3.11 是用户级)。
+ *    为什么"直接往 <extensions-dir> 拷目录"装不进用户级:VS Code 服务端启动时
+ *    `ExtensionsWatcher.initialize()` → `deleteExtensionsNotInProfiles()` 会把
+ *    「在用户扩展目录里、但不在任何 profile 的 extensions.json 里」的扩展写进 `<extensions-dir>/.obsolete`
+ *    (服务端日志 `Marked extension as removed dsh-code-server-app.dshcs-editor-bridge-0.1.0`),
+ *    扫描器从此不再看它;下一轮它自然又不在 profile 里 ⇒ **每启动一次就再标一次,自锁**。
+ *    实测(本机 profile,10 次启动 10 条标记)与源码位置:`out/server-main.js` 的
+ *    `ExtensionsWatcher#initialize` / `ExtensionsScannerService#setExtensionsForRemoval`。
+ *    内置目录(<树>/lib/vscode/extensions,与 dshcs-open-file 同处)不参与 profile 机制。
+ *    用户的"关掉它"由插件设置 `editorBridge=false`(不挂桥、不注册工具)承担,不再依赖 VS Code 的卸载。 */
 const BUNDLED_EXTENSIONS = [
   { name: 'dshcs-open-file', placement: 'builtin' },
-  { name: 'dshcs-editor-bridge', placement: 'user' },
+  { name: 'dshcs-editor-bridge', placement: 'builtin' },
 ];
 
 /** 递归列出扩展源目录里的文件(相对路径,posix 分隔)。
@@ -233,19 +240,56 @@ export function listExtensionFiles(srcDir) {
   return out;
 }
 
+/** 清掉 VS Code 写给本插件扩展的"已移除"标记(`<extensions-dir>/.obsolete`)。
+ *  机制:`ExtensionsWatcher.initialize()` 把"在用户扩展目录里、不在任何 profile 里"的扩展标成 removed,
+ *  扫描器随后永远跳过它 ⇒ **自锁**(见 BUNDLED_EXTENSIONS 的注释)。0.3.0–0.3.11 的桥扩展就卡在这里:
+ *  文件装全了、路由通了,扩展却一次都没被加载(`editor_context` 永远报"扩展还没有上报状态")。
+ *  别的扩展的条目原样保留;清空后直接删掉文件(VS Code 需要时会自己重建)。
+ *  导出供测试直接验。 */
+export function clearObsoleteMarkers(extensionsDir, ids) {
+  const file = path.join(extensionsDir, '.obsolete');
+  if (ids.length === 0 || !fs.existsSync(file)) return [];
+  let map;
+  try {
+    map = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return [];
+  }
+  if (map === null || typeof map !== 'object' || Array.isArray(map)) return [];
+  const cleared = [];
+  for (const key of Object.keys(map)) {
+    if (ids.some((id) => key === id || key.startsWith(`${id}-`))) {
+      delete map[key];
+      cleared.push(key);
+    }
+  }
+  if (cleared.length === 0) return [];
+  try {
+    if (Object.keys(map).length === 0) fs.rmSync(file, { force: true });
+    else fs.writeFileSync(file, JSON.stringify(map), 'utf8');
+  } catch {
+    // 清标记失败不该拦住安装:扩展仍会被扫描器跳过,但文件是新的(下次启动还会再试)
+  }
+  return cleared;
+}
+
 /** 内置扩展安装:每次启动调用 —— 缺失**或内容有变化**即同步(自愈,且插件升级后能更新已装的旧副本)。
  *  源目录里已不存在的文件会从目标里删掉(否则旧版本的 `lib/` 会一直留着)。
- *  同时清理"放错位置"的旧副本(用户级/内置两份同时存在会让 VS Code 打架)。
- *  导出供测试直接调(apply 期不装扩展,只有 start 才装)。 */
-export function installBundledExtensions(extensionsDir, userDataDir) {
+ *  同时清理"放错位置"的旧副本(用户级/内置两份同时存在会让 VS Code 打架),并清掉 `.obsolete` 自锁标记。
+ *  导出供测试直接调(apply 期不装扩展,只有 start 才装);`options.treeRoot` 供测试注入假树。 */
+export function installBundledExtensions(extensionsDir, userDataDir, options = {}) {
   const here = path.dirname(fileURLToPath(import.meta.url));
+  const treeRoot = options.treeRoot === undefined ? vsRoot() : options.treeRoot;
+  const managedIds = [];
   for (const ext of BUNDLED_EXTENSIONS) {
     try {
       const src = path.join(here, '..', 'assets', 'extensions', ext.name);
       const manifest = path.join(src, 'package.json');
       if (!fs.existsSync(manifest)) continue;
+      const manifestJson = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+      managedIds.push(`${manifestJson.publisher ?? 'dsh-code-server-app'}.${manifestJson.name ?? ext.name}`);
       const files = listExtensionFiles(src);
-      const target = extensionTarget(extensionsDir, ext.name, ext.placement);
+      const target = extensionTarget(extensionsDir, ext.name, ext.placement, treeRoot);
       const dst = target.dst;
       const stale = files.filter((name) => {
         const to = path.join(dst, name);
@@ -280,8 +324,8 @@ export function installBundledExtensions(extensionsDir, userDataDir) {
         };
         walkDst('');
       }
-      // 清理放错位置的副本:dshcs-open-file 的旧用户级副本 / 编辑器桥的错误内置副本。
-      const wrong = extensionTarget(extensionsDir, ext.name, ext.placement === 'builtin' ? 'user' : 'builtin');
+      // 清理放错位置的副本:编辑器桥的旧用户级副本(0.3.11 及更早)/ dshcs-open-file 的旧用户级副本。
+      const wrong = extensionTarget(extensionsDir, ext.name, ext.placement === 'builtin' ? 'user' : 'builtin', treeRoot);
       if (wrong.dst !== dst && fs.existsSync(wrong.dst)) {
         fs.rmSync(wrong.dst, { recursive: true, force: true });
         console.log(`[code-server] 清理放错位置的扩展副本 ${wrong.dst}(${ext.name} 应装在${target.builtin ? '内置' : '用户级'}目录)`);
@@ -292,6 +336,11 @@ export function installBundledExtensions(extensionsDir, userDataDir) {
       console.warn(`[code-server] bundled extension ${ext.name} install failed:`, err && err.message ? err.message : String(err));
     }
   }
+  const cleared = clearObsoleteMarkers(extensionsDir, managedIds);
+  if (cleared.length > 0) {
+    console.log(`[code-server] 清掉 VS Code 的"已移除"标记(.obsolete):${cleared.join(',')}`
+      + '(留着的话扫描器会永远跳过这些扩展,编辑器桥就永远没有状态)');
+  }
   void userDataDir;
 }
 
@@ -540,12 +589,17 @@ export async function apply(ctx, config) {
           if (next.editorBridge !== bridgeSetting) {
             bridgeSetting = next.editorBridge;
             console.log(`[code-server] editorBridge updated: ${bridgeSetting}`);
-            // 关掉 → 立刻下线(删配置 + 注销工具);开启 → 若 IDE 在跑就补一份配置。
+            // 关掉 → 立刻下线(关监听口 + 删配置 + 注销工具);开启 → 起监听口,IDE 在跑就补一份配置。
             if (bridgeSetting === false) {
               clearBridgeRuntime();
-            } else if (state.status === 'running' && state.pid !== null) {
-              bridgeToken ??= mintBridgeToken();
-              syncBridgeRuntime({ pid: state.pid, startedAt: state.startedAt });
+              void stopBridgeListener();
+            } else {
+              void ensureBridgeListener().then(() => {
+                if (state.status === 'running' && state.pid !== null) {
+                  bridgeToken ??= mintBridgeToken();
+                  syncBridgeRuntime({ pid: state.pid, startedAt: state.startedAt });
+                }
+              });
             }
           }
         }
@@ -640,27 +694,53 @@ export async function apply(ctx, config) {
 
   /** 本次启动生成的新桥令牌;null = 本实例没有令牌(adopt 旧实例时会回读 bridge.json)。 */
   let bridgeToken = null;
-  /** 桥的 webServer 挂载点(0.3.9)。null = 本部署没有可挂载的 HTTP 面(desktop)。 */
-  let bridgeMountDispose = null;
-  /** "桥不可用"只提示一次,避免每次起停都刷屏。 */
+  /** 桥的本机 IPC 监听口(0.3.13)。null = 未起(未启用/起失败)。*/
+  let bridgeListener = null;
+  /** 监听口启动中的 promise(避免并发起两次)。 */
+  let bridgeListenerStarting = null;
+  /** "桥监听起不来"只提示一次,避免每次起停都刷屏。 */
   let bridgeUnavailableLogged = false;
 
-  /** 扩展宿主(Node 进程)能到达的 DSH origin;null = 本部署没有这样的 HTTP 面。
+  /** 桥的传输是**本机 IPC**(Windows 命名管道 / 其它平台 unix socket),不是 HTTP。
    *
-   *  为什么不能用 launcher 的 host:port(0.3.7 的错误做法):launcher 只服务 workbench,
-   *  **没有任何 `/api` 路由** —— 实测 `POST http://127.0.0.1:8090/<path-token>/api/code-server/bridge/sync`
-   *  会穿透到 VS Code server 并得到 405。
-   *  为什么也不能挂在 `/api` 下(0.3.7 的第二个错误):Connection 给 `/api` 装了 cookie fence
-   *  (`packages/client/connection/src/index.ts`:`requestRejection` → 401),而扩展宿主是 Node 进程、
-   *  永远拿不到浏览器 cookie ⇒ 请求在到达插件路由之前就被 401 掉了。
-   *  所以桥改挂 DSH 自己的 webServer 前缀(`BRIDGE_BASE`),自带令牌校验(见 bridge.mjs 的安全不变量)。 */
-  function bridgeOrigin() {
-    if (webServerSvc === undefined || bridgeMountDispose === null) return null;
-    const port = typeof webServerSvc.port === 'number' ? webServerSvc.port : null;
-    if (port === null || !Number.isSafeInteger(port) || port <= 0) return null;
-    const raw = typeof webServerSvc.config?.host === 'string' ? webServerSvc.config.host : '';
-    const host = raw === '' || raw === '0.0.0.0' || raw === '::' ? '127.0.0.1' : raw;
-    return bridgeUrl(host, port);
+   *  为什么不走 HTTP(0.3.13 定论,三条都实测过):
+   *   ① launcher 的 host:port 只服务 workbench,没有任何桥路由(0.3.7 的实测:405);
+   *   ② `/api` 有 Connection 的浏览器 cookie fence,扩展宿主是 Node 进程、拿不到 cookie(0.3.7–0.3.9);
+   *   ③ 挂 DSH 的 `webServer` 前缀(0.3.9–0.3.12)只有 **web profile** 有 —— desktop 的渲染进程
+   *      经 Electron IPC 调 `host.fetch()`(`apps/desktop-host/src/index.ts:308`),**根本没有 HTTP 面**。
+   *  桥的双方本来就是同一台机器上的两个进程,本机 IPC 让 web 与 desktop 走**同一条**路。
+   *  详见 lib/bridge-ipc.mjs 顶部。 */
+  function ensureBridgeListener() {
+    if (bridgeListener !== null) return Promise.resolve(bridgeListener);
+    if (bridgeListenerStarting !== null) return bridgeListenerStarting;
+    const socketPath = bridgeEndpointPath(bridgeRoot, process.pid);
+    bridgeListenerStarting = startBridgeListener({
+      socketPath,
+      handler: nodeRouteFromFetch((url, method, headers, body) => dispatchBridge(url, method, headers, body)),
+      log: (message) => console.warn(`[code-server] ${message}`),
+    }).then((handle) => {
+      bridgeListener = handle;
+      bridgeListenerStarting = null;
+      console.log(`[code-server] 编辑器桥监听就绪:${handle.path}(本机 IPC,桥令牌鉴权)`);
+      return handle;
+    }).catch((error) => {
+      bridgeListenerStarting = null;
+      if (!bridgeUnavailableLogged) {
+        bridgeUnavailableLogged = true;
+        console.warn(`[code-server] 编辑器桥监听失败,桥不启用:${error && error.code ? error.code : error && error.message ? error.message : error}`
+          + '(文件打开走信号文件,不受影响)');
+      }
+      return null;
+    });
+    return bridgeListenerStarting;
+  }
+
+  /** 关掉本机 IPC 监听口(禁用桥 / 插件卸载)。 */
+  function stopBridgeListener() {
+    const handle = bridgeListener;
+    bridgeListener = null;
+    if (handle === null) return Promise.resolve();
+    return handle.close().catch(() => {});
   }
 
   /** 桥的四条路由(后缀 → Fetch 风格 handler)。做成函数而非常量:handler 声明在文件后段,
@@ -674,7 +754,7 @@ export async function apply(ctx, config) {
     ];
   }
 
-  /** 把 Fetch 风格 handler 适配成 DSH webServer 的 Node 路由(req/res ⇄ Request/Response)。 */
+  /** 把 Fetch 风格 handler 适配成本机 IPC 监听口的 Node 路由(req/res ⇄ Request/Response)。 */
   function nodeRouteFromFetch(dispatch) {
     return async (req, res) => {
       try {
@@ -735,53 +815,44 @@ export async function apply(ctx, config) {
     isLive: () => bridgeMeta !== null && !bridgeContext.isStale(),
   });
 
-  /** 同步桥运行时:写入/更新 bridge.json,并(就绪时)注册编辑器工具。
-   *  端口、令牌、pid 三者任一变化都重写 —— 扩展每 5s 重读,故不需要任何推送。
-   *  **没有扩展可达的 origin 时(desktop)不写配置**,并清掉可能遗留的旧配置(宁可休眠,不可指向死地址)。 */
+  /** 同步桥运行时:写入/更新 bridge.json(端点 = 本机 IPC 路径 + 令牌 + pid)。
+   *  端点、令牌、pid 三者任一变化都重写 —— 扩展每 5s 重读,故不需要任何推送。
+   *  监听口起不来时**不写配置**(宁可休眠,不可指向死端点),并说明一次。 */
   function syncBridgeRuntime({ pid, startedAt }) {
     if (!bridgeEnabled()) return;
-    const base = bridgeOrigin();
-    if (base === null) {
+    const handle = bridgeListener;
+    if (handle === null) {
       if (bridgeMeta !== null) {
         bridgeMeta = null;
-        try { removeBridgeConfig(bridgeExtensionsDir); } catch { /* 删不掉也不影响:扩展会因不可达而休眠 */ }
-      }
-      if (!bridgeUnavailableLogged) {
-        bridgeUnavailableLogged = true;
-        console.warn('[code-server] 编辑器桥:本部署没有扩展可达的 HTTP 面(desktop 无 webServer)→ 桥不启用'
-          + '(文件打开走信号文件,不受影响)');
+        try { removeBridgeConfig(bridgeExtensionsDir); } catch { /* 删不掉也不影响:扩展会因端点在而连不上 */ }
       }
       return;
     }
     bridgeToken ??= mintBridgeToken();
-    const changed = bridgeMeta === null || bridgeMeta.url !== base || bridgeMeta.token !== bridgeToken || bridgeMeta.pid !== pid;
-    bridgeMeta = { url: base, token: bridgeToken, pid, startedAt: startedAt ?? null };
+    const changed = bridgeMeta === null || bridgeMeta.pipe !== handle.path || bridgeMeta.token !== bridgeToken || bridgeMeta.pid !== pid;
+    bridgeMeta = { pipe: handle.path, token: bridgeToken, pid, startedAt: startedAt ?? null };
     try {
-      writeBridgeConfig(bridgeExtensionsDir, { url: base, token: bridgeToken, pid, startedAt: startedAt ?? null });
+      writeBridgeConfig(bridgeExtensionsDir, { pipe: handle.path, token: bridgeToken, pid, startedAt: startedAt ?? null });
     } catch (err) {
       console.warn(`[code-server] 编辑器桥配置写入失败(${bridgeExtensionsDir}):${err && err.message ? err.message : err}`);
       return;
     }
     if (changed) {
-      // 只打印"已启用",不打印令牌本身(与 path-token 同一决策)。
-      console.log(`[code-server] 编辑器桥:已启用(${base}${BRIDGE_BASE},令牌文件 ${path.join(bridgeMetaDir, 'bridge.json')})`);
+      // 只打印端点与配置文件位置,不打印令牌本身(与 path-token 同一决策)。
+      console.log(`[code-server] 编辑器桥:已启用(${handle.path}${BRIDGE_BASE}/*,令牌文件 ${path.join(bridgeMetaDir, 'bridge.json')})`);
     }
     ensureBridgeTools();
   }
 
   /**
-   * 接管实例时对齐桥令牌:磁盘上已有配置且基址一致 → 沿用(避免无谓轮换打乱正在运行的扩展);
+   * 接管实例时对齐桥令牌:磁盘上已有配置、端点一致且是本机 IPC → 沿用(避免无谓轮换打乱正在运行的扩展);
    * 否则 mint 新的(扩展下次轮询就会读到新的 bridge.json,一次请求的失败无所谓)。
    */
   function adoptBridgeRuntime(pid, startedAt) {
     if (!bridgeEnabled()) return;
-    const base = bridgeOrigin();
-    if (base === null) {
-      syncBridgeRuntime({ pid, startedAt });
-      return;
-    }
     const existing = readBridgeConfig(bridgeExtensionsDir);
-    bridgeToken = existing !== null && existing.url === base && TOKEN_RE.test(String(existing.token))
+    const endpoint = bridgeListener === null ? null : bridgeListener.path;
+    bridgeToken = existing !== null && endpoint !== null && existing.pipe === endpoint && TOKEN_RE.test(String(existing.token))
       ? String(existing.token)
       : mintBridgeToken();
     syncBridgeRuntime({ pid, startedAt });
@@ -811,7 +882,7 @@ export async function apply(ctx, config) {
     return null;
   }
 
-  /** 桥就绪时注册编辑器工具;`tools` / `defineTool` 缺失时静默退化为"只有 HTTP 面"。 */
+  /** 桥就绪时注册编辑器工具;`tools` / `defineTool` 缺失时静默退化为"只有本机 IPC 面"。 */
   function ensureBridgeTools() {
     if (bridgeMeta === null || bridgeToolDispose !== null) return;
     Promise.resolve(registerEditorTools(ctx, {
@@ -820,7 +891,7 @@ export async function apply(ctx, config) {
     }))
       .then((dispose) => {
         if (dispose === null) {
-          console.log('[code-server] 编辑器桥:工具服务不可用,仅提供 HTTP 面(editor_context/editor_diagnostics 未注册)');
+          console.log('[code-server] 编辑器桥:工具服务不可用,仅提供本机 IPC 面(editor_context/editor_diagnostics 未注册)');
           return;
         }
         // 期间桥可能已经被停掉(IDE 退出):立刻回滚,避免留下永远不可用的工具。
@@ -854,19 +925,6 @@ export async function apply(ctx, config) {
       dshMount = null;
       console.error(`[code-server] serve=dsh 挂载失败(将回退 loopback):${error && error.message ? error.message : error}`);
     }
-    // 编辑器桥(0.3.9):挂在自己的前缀上,自带令牌 —— 走 /api 会被 Connection 的 cookie fence 401
-    // (扩展宿主是 Node 进程,没有浏览器 cookie),详见 bridgeOrigin() 的注释。
-    try {
-      bridgeMountDispose = wsCtx.webServer.register({
-        kind: 'prefix',
-        path: BRIDGE_BASE,
-        handler: nodeRouteFromFetch((url, method, headers, body) => dispatchBridge(url, method, headers, body)),
-      });
-      console.log(`[code-server] 编辑器桥挂载就绪:${BRIDGE_BASE}/* (DSH webServer,桥令牌鉴权)`);
-    } catch (error) {
-      bridgeMountDispose = null;
-      console.warn(`[code-server] 编辑器桥挂载失败(桥不可用):${error && error.message ? error.message : error}`);
-    }
   });
 
   ctx.effect(() => () => {
@@ -876,11 +934,11 @@ export async function apply(ctx, config) {
     }
   }, 'code-server: dsh mount');
 
-  ctx.effect(() => () => {
-    if (bridgeMountDispose === null) return;
-    try { bridgeMountDispose(); } catch { /* ignore */ }
-    bridgeMountDispose = null;
-  }, 'code-server: bridge mount');
+  // 编辑器桥的本机 IPC 监听口(web 与 desktop 同一套;不依赖 webServer,见 ensureBridgeListener)。
+  ctx.effect(() => {
+    if (bridgeEnabled()) void ensureBridgeListener();
+    return () => { void stopBridgeListener(); };
+  }, 'code-server: bridge ipc listener');
 
   /** 回环模式的客户端 URL:随机端口 + 路径令牌(令牌是 URL 路径的一段,浏览器会把子请求与 WS
    *  一并带过去 —— 这正是不走 VS Code 自带 cookie 令牌的原因,见 launcher 文件头"安全模型")。 */
@@ -919,8 +977,10 @@ export async function apply(ctx, config) {
         enabled: bridgeEnabled(),
         live: bridgeMeta !== null,
         toolsRegistered: bridgeToolDispose !== null,
-        supported: state.serve === 'loopback',
-        url: bridgeMeta === null ? null : bridgeMeta.url,
+        /** 端点已就绪(本机 IPC 监听口在)。0.3.13 起 web 与 desktop 都是 true(不再依赖 webServer)。 */
+        supported: bridgeListener !== null,
+        /** 本机 IPC 端点(命名管道 / unix socket);null = 监听口没起来。 */
+        endpoint: bridgeListener === null ? null : bridgeListener.path,
         file: path.join(bridgeMetaDir, 'bridge.json'),
       },
       env: state.env,
@@ -1209,6 +1269,11 @@ export async function apply(ctx, config) {
     const env = { ...process.env };
     // 内置扩展信号文件路径(host → 扩展 打开文件)
     env.DSHCS_OPEN_FILE_SIGNAL = openFileSignalPath(userDataDir);
+    // 扩展目录(host → 扩展 找桥配置 `/.dshcs-bridge/bridge.json`)。
+    // **必须注入**:0.3.12 起桥扩展装在**内置**目录(树里),与 <extensionsDir> 不同级,
+    // 扩展再也不能靠"自己的路径上溯两级"找到配置(0.3.0–0.3.11 那个上溯是错的,多上溯了一级,
+    // 就算装在用户级也读不到配置 ⇒ 桥一直是休眠态)。
+    env.DSHCS_EXTENSIONS_DIR = extensionsDir;
     // ?v= 缓存击穿标记:按"插件版本 + VS Code 树"生成 —— 只在真升级时让渲染器丢掉旧 bundle,
     // 平时正常命中缓存(workbench.js 有 18MB,每次启动都重拉不划算)。
     env.DSHCS_HTML_TAG = `${pluginVersion()}-${productPath() ?? 'dev'}`.replace(/[^A-Za-z0-9._-]/g, '');
@@ -1485,11 +1550,13 @@ export async function apply(ctx, config) {
 
   async function handleBridgeHealth() {
     // 无鉴权:只回一句"桥活着吗",不含任何编辑器数据(便于重启后一眼确认)。
+    // 注意:bridge=true 只表示"配置已就绪",**不代表扩展在跑**(见 README 已知限制)。
     return jsonResponse({
       ok: true,
       bridge: bridgeMeta !== null,
       pid: state.pid,
-      url: bridgeMeta === null ? null : bridgeMeta.url,
+      transport: 'ipc',
+      endpoint: bridgeMeta === null ? null : bridgeMeta.pipe,
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-code-server-app",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "VS Code (from a code-server release) inside DSH: a right-sidebar tab driven by the plugin's own launcher over the in-process VS Code server (lib/launcher.mjs). Since 0.3.0 the bundle also ships an editor bridge (assets/extensions/dshcs-editor-bridge): a read-only channel between the in-tree VS Code extension host and DSH, giving the agent what only the editor knows (unsaved buffers, language-server diagnostics, the active selection) and letting editor gestures drive the session. The tab claims DSH file addresses (dsh-resource://file/**) by file type (setting claimExtensions), so the product's own produced-file chips, delivered-file previews and inline prose mentions open in the workbench. The IDE is a resident surface moved with Element.moveBefore instead of being remounted, so switching sidebar tabs no longer reloads it. Opening the tab switches the right sidebar to fullscreen by default (setting fullscreenOnOpen). Following a workspace switch is lightweight: the workbench re-navigates with the new ?folder= and the IDE process is not restarted (since 0.2.12). Requires a DSH with the right-sidebar services (sidebarRightTabs/sidebarRight, >= 0.1.5-alpha.1); older DSH versions get a single upgrade notice on the settings page and no other UI. Two serving modes: loopback port (default) or same-origin mount on DSH's own webServer (/code-server, protected by ctx.connection.requestRejection). No code-server Node layer, no argon2, no C++ toolchain.",
   "homepage": "https://github.com/jinsiyu/dsh-code-server-app",
   "repository": {
@@ -39,6 +39,7 @@
     "lib/client.js",
     "lib/claim-types.js",
     "lib/bridge.mjs",
+    "lib/bridge-ipc.mjs",
     "lib/bridge-tools.mjs",
     "lib/bridge-session.mjs",
     "lib/bridge-observe.mjs",

package/vendor/VENDOR.json

@@ -3,7 +3,7 @@
   "vscodeVersion": "1.137.0",
   "productPath": "stable-b11dabdaca0d3369986975be285db92c8795cea5",
   "layout": "vscode-only",
-  "preparedAt": "2026-09-12T17:06:47.539Z",
+  "preparedAt": "2026-09-13T05:03:27.361Z",
   "source": "registry",
   "node": "v24.21.0",
   "platform": "win32",