@aipanel/provider-deepseek 1.2.6 → 1.2.8

package/es/api.d.ts

@@ -7,30 +7,68 @@ import type { SessionSummary } from "./types";
 export declare class DeepSeekAPI {
     private hostname;
     private getWebPort;
+    /** dsh 启动打印的 launch token（browser-session 认证），由 provider 在捕获后写入 */
+    private launchToken?;
+    /** 启动早期等待 token 就绪的源（dsh 进程 stdout 的 LaunchToken.wait），未就绪时勿立即抛错 */
+    private launchTokenSource?;
+    /** browser-session 签名 Cookie（经 launch token 换取），dsh web 所有 /api 请求必须携带 */
+    private authCookie?;
+    /** 认证引导的幂等 Promise，避免并发多次换取 */
+    private authPromise?;
     constructor(hostname: string, getWebPort: () => number);
     /** 应用壳 URL（无 deepLink 能力，所有会话共用） */
     get shellUrl(): string;
+    /** 注入 dsh 启动时打印的 launch token（来自 deepseek-web 的 stdout 解析） */
+    setLaunchToken(token: string): void;
+    /**
+     * 绑定 launch token 等待源（dsh 进程 stdout 解析的 LaunchToken.wait）。
+     * 启动早期 widget 可能在 token 捕获前就发起 /api 请求，此时先等待 token 就绪而非抛错。
+     */
+    setLaunchTokenSource(source: () => Promise<string>): void;
+    /** 当前 browser-session Cookie（未认证时 undefined）；供代理向转发请求注入同一 Cookie */
+    getAuthCookie(): string | undefined;
+    /**
+     * 用 launch token 首次访问索引页换取 browser-session Cookie（dsh 0.1.2+ 的 browser-auth 门禁）。
+     * 幂等：已认证时直接返回。失败时抛错（调用方按需降级，不阻塞 dsh 启动）。
+     */
+    authenticate(): Promise<void>;
+    /**
+     * GET /?token=<launchToken>，从 303 响应捕获 Set-Cookie（browser-auth 用签名 cookie 换首访权限）。
+     * node:http 不自动跟随 303，因此能拿到该次响应的 Set-Cookie。
+     */
+    private bootstrapAuthCookie;
+    /** 确保已认证（未认证时先等待 launch token 就绪；无 token 来源才抛错） */
+    private ensureAuthenticated;
     /** 发起一次 unary RPC，返回 result.value（ok=false 时抛错） */
     private call;
     /**
-     * 列出当前项目目录下的会话。
-     * dsh 的 session.list 不提供按目录过滤，故结合 workspace.list（path→sessionIds）
-     * 与各会话的 cwd 字段，在本端合并去重出属于 projectDir 的会话集。
+     * 列出当前项目目录下的会话（可见性口径与 dsh UI 对齐）。
+     * 取 workspace/follow baseline（workspace.list 在 dsh 0.1.2+ 已移除）按 path 匹配工作区，
+     * 得 sessionIds 与全局 archivedSessionIds，再结合 session/list 的 cwd 过滤去重；
+     * 过滤规则同 dsh-client-ui-workspace 的 sessionVisible：
+     *   排除 origin=subagent 的子代理会话（UI 不单列）、排除归档；blank（未开过回合）仅当
+     *   sessionId === activeSessionId（当前选中会话，对应 UI 的 New Session 占位行）时展示。
      */
-    listSessions(projectDir: string, retries?: number): Promise<SessionSummary[]>;
+    listSessions(projectDir: string, activeSessionId?: string, retries?: number): Promise<SessionSummary[]>;
     /** 在当前目录下创建会话（dsh 仅返回 { sessionId, agentPreset? }，非完整 SessionSummary）。
-     * 关键：必须先确保 projectDir 对应的 workspace 存在（workspace.create 幂等 get-or-create），
-     * 再用 workspaceId 调 session.create。若只传 cwd，dsh 侧不会把会话挂到任何 workspace，
-     * 新会话会落到侧边栏"未分组"。 */
+     * 与旧逻辑一致：先确保 projectDir 对应的 workspace 存在（workspace/create 幂等 get-or-create），
+     * 再用 workspaceId 调 session/create，让新会话挂到该 workspace。 */
     createSession(projectDir: string, retries?: number): Promise<{
         sessionId: string;
     }>;
     /**
-     * 通过 dsh settings.update 应用 providerOptions 指定的用户设置（逐命名空间幂等 patch）。
+     * 通过 dsh settings/mutate 应用 providerOptions 指定的用户设置（逐命名空间幂等 patch）。
      * dsh 启动初期 API 未就绪，整体带重试；单个命名空间不存在会导致该次调用失败重试。
      */
     applySettings(sections: Record<string, Record<string, unknown>>, retries?: number): Promise<void>;
     /** 归档会话（dsh 无硬删除，仅归档；幂等） */
     archiveSession(sessionId: string, retries?: number): Promise<void>;
+    /**
+     * 取 workspace/follow 流的 baseline（等价旧 workspace.list 的快照：{ items, archivedSessionIds }）。
+     * dsh 0.1.2+ 无 workspace.list RPC，工作区发现走 /api/remote.mux 上的 workspace/follow 流。
+     * 直连 dsh web（webPort）并携带 browser-session Cookie（原生 WebSocket 支持自定义请求头），
+     * 打开流读到首个 baseline 帧即关闭；启动早期 webPort 已就绪，不存在代理时序竞态。
+     */
+    private fetchWorkspaceBaseline;
     private createHttpRequest;
 }

package/es/api.js

@@ -5,32 +5,130 @@ import http from "http";
 import { randomUUID } from "node:crypto";
 import { DEFAULT_RETRIES, RETRY_DELAY, sleep } from "@aipanel/core";
 import { PerformanceTimer, createLogger } from "@aipanel/core/node";
-import { DSH_API_BASE } from "./constants.js";
+import { DSH_API_BASE, DSH_REMOTE_MUX_PATH } from "./constants.js";
 const log = createLogger("DeepSeekAPI");
 class DeepSeekAPI {
   constructor(hostname, getWebPort) {
     __publicField(this, "hostname", hostname);
     __publicField(this, "getWebPort", getWebPort);
+    /** dsh 启动打印的 launch token（browser-session 认证），由 provider 在捕获后写入 */
+    __publicField(this, "launchToken");
+    /** 启动早期等待 token 就绪的源（dsh 进程 stdout 的 LaunchToken.wait），未就绪时勿立即抛错 */
+    __publicField(this, "launchTokenSource");
+    /** browser-session 签名 Cookie（经 launch token 换取），dsh web 所有 /api 请求必须携带 */
+    __publicField(this, "authCookie");
+    /** 认证引导的幂等 Promise，避免并发多次换取 */
+    __publicField(this, "authPromise");
   }
   /** 应用壳 URL（无 deepLink 能力，所有会话共用） */
   get shellUrl() {
     return `http://${this.hostname}:${this.getWebPort()}`;
   }
+  /** 注入 dsh 启动时打印的 launch token（来自 deepseek-web 的 stdout 解析） */
+  setLaunchToken(token) {
+    this.launchToken = token;
+  }
+  /**
+   * 绑定 launch token 等待源（dsh 进程 stdout 解析的 LaunchToken.wait）。
+   * 启动早期 widget 可能在 token 捕获前就发起 /api 请求，此时先等待 token 就绪而非抛错。
+   */
+  setLaunchTokenSource(source) {
+    this.launchTokenSource = source;
+  }
+  /** 当前 browser-session Cookie（未认证时 undefined）；供代理向转发请求注入同一 Cookie */
+  getAuthCookie() {
+    return this.authCookie;
+  }
+  /**
+   * 用 launch token 首次访问索引页换取 browser-session Cookie（dsh 0.1.2+ 的 browser-auth 门禁）。
+   * 幂等：已认证时直接返回。失败时抛错（调用方按需降级，不阻塞 dsh 启动）。
+   */
+  async authenticate() {
+    if (this.authCookie) return;
+    if (!this.authPromise) {
+      this.authPromise = this.bootstrapAuthCookie().then(
+        (cookie) => {
+          this.authCookie = cookie;
+          log.debug("dsh browser-session authenticated");
+        },
+        (err) => {
+          this.authPromise = void 0;
+          throw err;
+        }
+      );
+    }
+    return this.authPromise;
+  }
+  /**
+   * GET /?token=<launchToken>，从 303 响应捕获 Set-Cookie（browser-auth 用签名 cookie 换首访权限）。
+   * node:http 不自动跟随 303，因此能拿到该次响应的 Set-Cookie。
+   */
+  bootstrapAuthCookie() {
+    if (!this.launchToken) {
+      return Promise.reject(new Error("dsh API authenticate called before setLaunchToken"));
+    }
+    const token = this.launchToken;
+    return new Promise((resolve, reject) => {
+      const req = http.request(
+        {
+          hostname: this.hostname,
+          port: this.getWebPort(),
+          path: `/?token=${encodeURIComponent(token)}`,
+          method: "GET",
+          headers: { Accept: "text/html" }
+        },
+        (res) => {
+          const setCookie = res.headers["set-cookie"];
+          const cookies = Array.isArray(setCookie) ? setCookie : setCookie ? [setCookie] : [];
+          res.resume();
+          if (cookies.length > 0) {
+            resolve(cookies[0].split(";")[0].trim());
+            return;
+          }
+          reject(
+            new Error(
+              `dsh auth bootstrap failed (status ${res.statusCode}, no Set-Cookie); token may be invalid`
+            )
+          );
+        }
+      );
+      req.on("error", (e) => reject(e instanceof Error ? e : new Error(String(e))));
+      req.end();
+    });
+  }
+  /** 确保已认证（未认证时先等待 launch token 就绪；无 token 来源才抛错） */
+  async ensureAuthenticated() {
+    if (this.authCookie) return;
+    if (!this.launchToken) {
+      if (this.launchTokenSource) {
+        this.launchToken = await this.launchTokenSource();
+      }
+      if (!this.launchToken) {
+        throw new Error("dsh API not authenticated: launch token not available");
+      }
+    }
+    await this.authenticate();
+  }
   /** 发起一次 unary RPC，返回 result.value（ok=false 时抛错） */
-  async call(method, payload = {}) {
+  async call(method, args = {}) {
+    await this.ensureAuthenticated();
     const message = {
       type: "client-request",
       rpcId: randomUUID(),
       method,
-      payload
+      payload: { args }
     };
+    const headers = { "Content-Type": "application/json" };
+    if (this.authCookie) {
+      headers.Cookie = this.authCookie;
+    }
     const response = await this.createHttpRequest(
       {
         hostname: this.hostname,
         port: this.getWebPort(),
         path: `${DSH_API_BASE}/${method}`,
         method: "POST",
-        headers: { "Content-Type": "application/json" }
+        headers
       },
       JSON.stringify(message)
     );
@@ -43,24 +141,28 @@ class DeepSeekAPI {
     return response.result.value;
   }
   /**
-   * 列出当前项目目录下的会话。
-   * dsh 的 session.list 不提供按目录过滤，故结合 workspace.list（path→sessionIds）
-   * 与各会话的 cwd 字段，在本端合并去重出属于 projectDir 的会话集。
+   * 列出当前项目目录下的会话（可见性口径与 dsh UI 对齐）。
+   * 取 workspace/follow baseline（workspace.list 在 dsh 0.1.2+ 已移除）按 path 匹配工作区，
+   * 得 sessionIds 与全局 archivedSessionIds，再结合 session/list 的 cwd 过滤去重；
+   * 过滤规则同 dsh-client-ui-workspace 的 sessionVisible：
+   *   排除 origin=subagent 的子代理会话（UI 不单列）、排除归档；blank（未开过回合）仅当
+   *   sessionId === activeSessionId（当前选中会话，对应 UI 的 New Session 占位行）时展示。
    */
-  async listSessions(projectDir, retries = DEFAULT_RETRIES) {
-    const timer = log.timer("listSessions", { projectDir, retries });
+  async listSessions(projectDir, activeSessionId, retries = DEFAULT_RETRIES) {
+    const timer = log.timer("listSessions", { projectDir, activeSessionId, retries });
     let lastError = null;
     for (let i = 0; i < retries; i++) {
       try {
-        log.debug(`Attempt ${i + 1}/${retries}`, { method: "session.list", projectDir });
-        const workspaces = await this.call("workspace.list");
+        log.debug(`Attempt ${i + 1}/${retries}`, { method: "session/list", projectDir });
+        const workspaces = await this.fetchWorkspaceBaseline();
         const matchedWorkspace = workspaces.items.find((w) => w.path === projectDir);
         const ownedByWorkspace = new Set(matchedWorkspace?.sessionIds ?? []);
         const archived = new Set(workspaces.archivedSessionIds);
-        const sessions = await this.call("session.list");
+        const sessions = await this.call("session/list", { _request: {} });
         const all = sessions.items;
         const filtered = all.filter((s) => {
-          if (s.blank) return false;
+          if (s.origin === "subagent") return false;
+          if (s.blank && s.sessionId !== activeSessionId) return false;
           if (archived.has(s.sessionId)) return false;
           if (ownedByWorkspace.has(s.sessionId)) return true;
           if (s.cwd && s.cwd === projectDir) return true;
@@ -81,23 +183,22 @@ class DeepSeekAPI {
     throw lastError;
   }
   /** 在当前目录下创建会话（dsh 仅返回 { sessionId, agentPreset? }，非完整 SessionSummary）。
-   * 关键：必须先确保 projectDir 对应的 workspace 存在（workspace.create 幂等 get-or-create），
-   * 再用 workspaceId 调 session.create。若只传 cwd，dsh 侧不会把会话挂到任何 workspace，
-   * 新会话会落到侧边栏"未分组"。 */
+   * 与旧逻辑一致：先确保 projectDir 对应的 workspace 存在（workspace/create 幂等 get-or-create），
+   * 再用 workspaceId 调 session/create，让新会话挂到该 workspace。 */
   async createSession(projectDir, retries = DEFAULT_RETRIES) {
     const timer = log.timer("createSession", { projectDir, retries });
     let lastError = null;
     for (let i = 0; i < retries; i++) {
       try {
         log.debug(`Attempt ${i + 1}/${retries}`, {
-          method: "session.create",
+          method: "session/create",
           projectDir
         });
-        const { workspace } = await this.call("workspace.create", {
-          path: projectDir
+        const { workspace } = await this.call("workspace/create", {
+          request: { path: projectDir }
         });
-        const session = await this.call("session.create", {
-          workspaceId: workspace.workspaceId
+        const session = await this.call("session/create", {
+          request: { workspaceId: workspace.workspaceId }
         });
         timer.end(`Created session: ${session.sessionId}`);
         return session;
@@ -113,7 +214,7 @@ class DeepSeekAPI {
     throw lastError;
   }
   /**
-   * 通过 dsh settings.update 应用 providerOptions 指定的用户设置（逐命名空间幂等 patch）。
+   * 通过 dsh settings/mutate 应用 providerOptions 指定的用户设置（逐命名空间幂等 patch）。
    * dsh 启动初期 API 未就绪，整体带重试；单个命名空间不存在会导致该次调用失败重试。
    */
   async applySettings(sections, retries = DEFAULT_RETRIES) {
@@ -123,9 +224,14 @@ class DeepSeekAPI {
     let lastError = null;
     for (let i = 0; i < retries; i++) {
       try {
-        log.debug(`Attempt ${i + 1}/${retries}`, { method: "settings.update", namespaces });
+        log.debug(`Attempt ${i + 1}/${retries}`, { method: "settings/mutate", namespaces });
         for (const [ns, patch] of Object.entries(sections)) {
-          await this.call("settings.update", { ns, patch });
+          const ops = Object.entries(patch).map(([key, value]) => ({
+            op: "set",
+            path: [key],
+            value
+          }));
+          await this.call("settings/mutate", { ns, ops });
         }
         timer.end(`Applied settings: ${namespaces.join(", ")}`);
         return;
@@ -146,8 +252,8 @@ class DeepSeekAPI {
     let lastError = null;
     for (let i = 0; i < retries; i++) {
       try {
-        log.debug(`Attempt ${i + 1}/${retries}`, { method: "workspace.archiveSession" });
-        await this.call("workspace.archiveSession", { sessionId });
+        log.debug(`Attempt ${i + 1}/${retries}`, { method: "workspace/archiveSession" });
+        await this.call("workspace/archiveSession", { request: { sessionId } });
         timer.end(`Archived session: ${sessionId}`);
         return;
       } catch (e) {
@@ -163,6 +269,76 @@ class DeepSeekAPI {
     timer.end("\u274C All retries exhausted");
     throw lastError;
   }
+  /**
+   * 取 workspace/follow 流的 baseline（等价旧 workspace.list 的快照：{ items, archivedSessionIds }）。
+   * dsh 0.1.2+ 无 workspace.list RPC，工作区发现走 /api/remote.mux 上的 workspace/follow 流。
+   * 直连 dsh web（webPort）并携带 browser-session Cookie（原生 WebSocket 支持自定义请求头），
+   * 打开流读到首个 baseline 帧即关闭；启动早期 webPort 已就绪，不存在代理时序竞态。
+   */
+  async fetchWorkspaceBaseline() {
+    await this.ensureAuthenticated();
+    return new Promise((resolve, reject) => {
+      const cookie = this.authCookie;
+      if (!cookie) {
+        reject(new Error("dsh workspace baseline unavailable: not authenticated"));
+        return;
+      }
+      const url = `ws://${this.hostname}:${this.getWebPort()}${DSH_REMOTE_MUX_PATH}`;
+      const ws = new WebSocket(url, {
+        headers: { Cookie: cookie }
+      });
+      const streamId = randomUUID();
+      let settled = false;
+      const finish = (err, value) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        try {
+          ws.close();
+        } catch {
+        }
+        if (err) reject(err);
+        else resolve(value);
+      };
+      const timer = setTimeout(
+        () => finish(new Error("dsh workspace baseline fetch timed out")),
+        15e3
+      );
+      ws.onopen = () => {
+        try {
+          ws.send(
+            JSON.stringify({
+              type: "open",
+              streamId,
+              endpoint: "workspace/follow",
+              payload: { args: {} }
+            })
+          );
+        } catch (e) {
+          finish(e instanceof Error ? e : new Error(String(e)));
+        }
+      };
+      ws.onmessage = (ev) => {
+        try {
+          const msg = JSON.parse(String(ev.data));
+          if (!msg || msg.streamId !== streamId) return;
+          if (msg.type === "item" && msg.value?.type === "baseline" && msg.value.value) {
+            finish(void 0, {
+              items: msg.value.value.items ?? [],
+              archivedSessionIds: msg.value.value.archivedSessionIds ?? []
+            });
+          } else if (msg.type === "error") {
+            finish(new Error(`dsh workspace/follow failed: ${msg.error?.message ?? "unknown"}`));
+          }
+        } catch {
+        }
+      };
+      ws.onerror = () => finish(new Error("dsh workspace baseline WebSocket error"));
+      ws.onclose = () => {
+        if (!settled) finish(new Error("dsh workspace baseline WebSocket closed before baseline"));
+      };
+    });
+  }
   createHttpRequest(options, body) {
     const timer = new PerformanceTimer("HTTP Request", {
       operation: `${options.method || "GET"} ${options.path}`
@@ -172,13 +348,25 @@ class DeepSeekAPI {
         let data = "";
         res.on("data", (chunk) => data += chunk);
         res.on("end", () => {
+          const status = res.statusCode ?? 0;
+          if (status < 200 || status >= 300) {
+            timer.end(`\u274C HTTP ${status}`);
+            reject(
+              new Error(
+                `dsh HTTP ${status} on ${options.method ?? "GET"} ${options.path}: ${(data || "(empty body)").substring(0, 200)}`
+              )
+            );
+            return;
+          }
           try {
             const result = JSON.parse(data);
-            timer.end(`\u2713 Status: ${res.statusCode}`);
+            timer.end(`\u2713 Status: ${status}`);
             resolve(result);
           } catch {
             timer.end("\u274C JSON parse error");
-            reject(new Error(`JSON parse error: ${data.substring(0, 100)}`));
+            reject(
+              new Error(`dsh HTTP ${status}: response is not JSON: ${data.substring(0, 200)}`)
+            );
           }
         });
       });

package/es/bridge-script.js

@@ -88,6 +88,11 @@ function generateBridgeScript(options = {}) {
     } catch (e) { /* ignore */ }
   }
 
+  // === \u9009\u62E9\u6A21\u5F0F\u72B6\u6001 ===
+  // \u8BB0\u5F55\u5BBF\u4E3B\u662F\u5426\u5904\u4E8E"\u9009\u62E9\u5143\u7D20"\u6A21\u5F0F\uFF1A\u9009\u62E9\u6A21\u5F0F\u5F00\u542F\u65F6\uFF0Ciframe \u5185\u6355\u83B7\u7684 Esc \u5E94\u4F18\u5148
+  // \u8F6C\u53D1\u7ED9\u5BBF\u4E3B\u9000\u51FA\u9009\u62E9\u6A21\u5F0F\uFF0C\u5E76\u541E\u6389\u672C\u9875\u81EA\u8EAB\u7684\u6309\u952E\u5904\u7406\uFF08\u5982\u505C\u6B62\u751F\u6210/\u5173\u95ED\u5F39\u5C42\uFF09\u3002
+  let isInSelectMode = false;
+
   // === \u6D88\u606F\u76D1\u542C ===
   window.addEventListener("message", function(event) {
     if (!event.data) return;
@@ -115,8 +120,40 @@ function generateBridgeScript(options = {}) {
     if (event.data.type === ${JSON.stringify(WIDGET_MSG.INSERT_FILE_PART)}) {
       pushSelection(event.data.element);
     }
+
+    // \u6838\u5FC3\u5C42\u901A\u77E5\uFF1A\u9009\u62E9\u5143\u7D20\u6A21\u5F0F\u53D8\u5316\uFF08\u66F4\u65B0\u672C\u5730\u72B6\u6001\uFF0C\u4F9B\u952E\u76D8\u8F6C\u53D1\u5224\u65AD\u662F\u5426\u541E\u6389\u672C\u9875 Esc \u5904\u7406\uFF09
+    if (event.data.type === ${JSON.stringify(WIDGET_MSG.SELECT_MODE_CHANGE)}) {
+      isInSelectMode = event.data.selectMode === true;
+    }
   });
 
+  // === \u952E\u76D8\u4E8B\u4EF6\u8F6C\u53D1\uFF08\u9000\u51FA/\u5207\u6362\u9009\u62E9\u6A21\u5F0F\uFF09 ===
+  // \u4E0E opencode bridge \u4E00\u81F4\uFF1Aiframe \u5185\u7684 keydown \u4E0D\u4F1A\u5192\u6CE1\u5230\u5BBF\u4E3B\u6587\u6863\uFF08\u8DE8\u6587\u6863\u4E8B\u4EF6\u9694\u79BB\uFF09\uFF0C
+  // \u56E0\u6B64\u5F53\u7126\u70B9\u5728\u804A\u5929 iframe \u5185\u65F6\uFF0C\u5BBF\u4E3B App \u6536\u4E0D\u5230 Esc / Ctrl+P\uFF0C\u5BFC\u81F4\uFF1A
+  //   - \u9009\u62E9\u5143\u7D20\u6A21\u5F0F\u5F00\u542F\u65F6\u6309 Esc \u65E0\u6CD5\u9000\u51FA\uFF08\u88AB dsh \u81EA\u8EAB\u6309\u952E\u5904\u7406\u541E\u6389\u6216\u76F4\u63A5\u4E22\u5931\uFF09\uFF1B
+  //   - \u5149\u6807\u5728\u804A\u5929\u8F93\u5165\u6846\u65F6\u65E0\u6CD5\u7528 Ctrl+P \u8FDB\u5165\u9009\u62E9\u5143\u7D20\u6A21\u5F0F\u3002
+  // \u6B64\u5904\u7528\u6355\u83B7\u9636\u6BB5\u76D1\u542C Esc / Ctrl+P \u5E76\u8F6C\u53D1\u4E3A KEYDOWN \u6D88\u606F\u7ED9\u5BBF\u4E3B App\uFF08App.vue \u636E\u6B64
+  // \u9000\u51FA/\u5207\u6362\u9009\u62E9\u6A21\u5F0F\uFF09\u3002\u9009\u62E9\u6A21\u5F0F\u5F00\u542F\u65F6\u4F18\u5148\u9000\u51FA\uFF1ApreventDefault + stopPropagation\uFF0C
+  // \u907F\u514D dsh \u81EA\u8EAB\u5BF9 Esc \u7684\u5904\u7406\u62A2\u8D70\u6309\u952E\u3002
+  window.addEventListener("keydown", function(event) {
+    if (event.key === "Escape" || (event.ctrlKey && event.key.toLowerCase() === "p")) {
+      if (isInSelectMode) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      if (window.parent !== window) {
+        window.parent.postMessage({
+          type: ${JSON.stringify(WIDGET_MSG.KEYDOWN)},
+          key: event.key,
+          ctrlKey: event.ctrlKey,
+          metaKey: event.metaKey,
+          shiftKey: event.shiftKey,
+          altKey: event.altKey
+        }, "*");
+      }
+    }
+  }, true);
+
   // === \u5C31\u7EEA\u901A\u77E5 ===
   // \u4E0D\u518D\u7528 MutationObserver \u6BCF\u5E27\u53D1 READY\uFF08\u90A3\u4F1A\u5728 dsh \u521A\u6E32\u67D3\u3001\u76EE\u6807\u4F1A\u8BDD\u5C1A\u672A\u6FC0\u6D3B\u65F6\u5C31
   // \u63D0\u524D\u653E\u884C loading\uFF09\u3002\u6539\u4E3A\u76D1\u542C dsh-client \u63D2\u4EF6\u5728"\u76EE\u6807\u4F1A\u8BDD\u6FC0\u6D3B\u4E14\u6E32\u67D3\u7A33\u5B9A"\u540E\u6D3E\u53D1\u7684

package/es/constants.d.ts

@@ -4,12 +4,15 @@
  */
 import type { DeepSeekProviderOptions } from "./types";
 /** ==================== dsh API ==================== */
-/** dsh 所有 RPC 路径前缀（POST /api/<method>、GET /api/events.mux） */
+/** dsh 所有 RPC 路径前缀（POST /api/<endpoint>） */
 export declare const DSH_API_BASE = "/api";
-/** mux 事件流端点（会话级聚合流，含 session/event 可推导 thinking/streaming） */
-export declare const DSH_MUX_EVENTS_PATH = "/api/events.mux";
-/** host 事件流端点（host 级，含 host/session-status.running 运行态开关） */
-export declare const DSH_HOST_EVENTS_PATH = "/api/events.host";
+/**
+ * Remote mux WebSocket 端点（dsh 0.1.2+）。
+ * 旧版 /api/events.mux、/api/events.host 与 workspace.list RPC 已移除：
+ * 会话/工作区能力改经此 mux 以流方式订阅（workspace/follow baseline、session/follow、
+ * 转发事件 $events 等），unary RPC 则保持 POST /api/<endpoint>。
+ */
+export declare const DSH_REMOTE_MUX_PATH = "/api/remote.mux";
 /** dsh 唯一允许的绑定主机字面量（服务 schema 只接受 127.0.0.1 / 0.0.0.0） */
 export declare const DSH_LOOPBACK_HOST = "127.0.0.1";
 /** dsh web 默认端口（未显式指定时） */

package/es/constants.js

@@ -1,6 +1,5 @@
 const DSH_API_BASE = "/api";
-const DSH_MUX_EVENTS_PATH = "/api/events.mux";
-const DSH_HOST_EVENTS_PATH = "/api/events.host";
+const DSH_REMOTE_MUX_PATH = "/api/remote.mux";
 const DSH_LOOPBACK_HOST = "127.0.0.1";
 const DSH_DEFAULT_PORT = 3080;
 const DSH_STORAGE_KEYS = {
@@ -12,7 +11,6 @@ const DSH_STORAGE_KEYS = {
   DIAGNOSTICS_ENABLED: "dsh.bridge.diagnostics.enabled"
 };
 const DEFAULT_DEEPSEEK_PROVIDER_OPTIONS = {
-  agentPreset: "code",
   // 对齐 opencode 的 enableLsp（默认 true）：诊断功能默认开启
   enableDiagnostics: true,
   // 对齐 opencode：自动诊断默认开启
@@ -22,8 +20,7 @@ export {
   DEFAULT_DEEPSEEK_PROVIDER_OPTIONS,
   DSH_API_BASE,
   DSH_DEFAULT_PORT,
-  DSH_HOST_EVENTS_PATH,
   DSH_LOOPBACK_HOST,
-  DSH_MUX_EVENTS_PATH,
+  DSH_REMOTE_MUX_PATH,
   DSH_STORAGE_KEYS
 };

package/es/deepseek-web.d.ts

@@ -1,4 +1,22 @@
 import { type ResultPromise } from "execa";
+/**
+ * dsh 启动时打印的 launch token 捕获器。
+ * dsh web 升级后在索引页与 /api 走 browser-session 认证：启动成功会在 stdout 打印
+ * `dsh web: http://127.0.0.1:3080/?token=<launchToken>`，首次访问需携带该 token 换取签名 cookie。
+ * 本类在子进程 stdout 就该 URL 打洞解析 token，供 DeepSeekAPI 与代理做认证。
+ */
+export declare class LaunchToken {
+    private token?;
+    /** 首次超时后缓存失败：本启动已不可能再打印 token，后续 wait 直接快速失败 */
+    private failure?;
+    private waiters;
+    /** 从子进程输出写入已解析的 token（幂等：只接受第一个） */
+    set(token: string): void;
+    /** 已解析的 token（未就绪时 undefined） */
+    get(): string | undefined;
+    /** 等待 token 就绪（默认 20s 超时；未打印则抛错并快速失败，调用方降级处理） */
+    wait(timeoutMs?: number): Promise<string>;
+}
 export interface DeepSeekWebOptions {
     /** 服务端口 */
     port: number;
@@ -12,6 +30,8 @@ export interface DeepSeekWebOptions {
     home?: string;
     /** 启用 verbose 模式 */
     verbose?: boolean;
+    /** launch token 捕获器：进程 stdout 解析出 ?token= 后写入，供认证使用 */
+    launchToken?: LaunchToken;
 }
 /**
  * 启动 dsh web 服务。

package/es/deepseek-web.js

@@ -1,8 +1,54 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { execa } from "execa";
 import { createLogger, getProcessLogBuffer } from "@aipanel/core/node";
 const log = createLogger("DeepSeekWeb");
+class LaunchToken {
+  constructor() {
+    __publicField(this, "token");
+    /** 首次超时后缓存失败：本启动已不可能再打印 token，后续 wait 直接快速失败 */
+    __publicField(this, "failure");
+    __publicField(this, "waiters", []);
+  }
+  /** 从子进程输出写入已解析的 token（幂等：只接受第一个） */
+  set(token) {
+    if (this.token !== void 0) return;
+    this.token = token;
+    this.failure = void 0;
+    for (const w of this.waiters) {
+      clearTimeout(w.timer);
+      w.resolve(token);
+    }
+    this.waiters = [];
+  }
+  /** 已解析的 token（未就绪时 undefined） */
+  get() {
+    return this.token;
+  }
+  /** 等待 token 就绪（默认 20s 超时；未打印则抛错并快速失败，调用方降级处理） */
+  wait(timeoutMs = 2e4) {
+    if (this.token !== void 0) return Promise.resolve(this.token);
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const err = new Error(
+          `dsh launch token was not captured from stdout within ${timeoutMs}ms (dsh >= 0.1.2 should print the "dsh web: http://127.0.0.1:<port>/?token=..." URL)`
+        );
+        this.failure = err;
+        for (const w of this.waiters) {
+          clearTimeout(w.timer);
+          w.reject(err);
+        }
+        this.waiters = [];
+        reject(err);
+      }, timeoutMs);
+      this.waiters.push({ resolve, reject, timer });
+    });
+  }
+}
 function startDeepSeekWeb(options) {
-  const { port, hostname, cwd, patchPath, home, verbose } = options;
+  const { port, hostname, cwd, patchPath, home, verbose, launchToken } = options;
   const args = ["--profile", "web"];
   if (patchPath) {
     args.push("--patch", patchPath);
@@ -41,8 +87,19 @@ function startDeepSeekWeb(options) {
   }).catch((e) => {
     log.error("[dsh spawn failed]", { error: e instanceof Error ? e.message : String(e) });
   });
+  let stdoutBuffer = "";
   proc.stdout?.on("data", (data) => {
-    const output = data.toString().trim();
+    const chunk = data.toString();
+    stdoutBuffer += chunk;
+    if (stdoutBuffer.length > 4096) stdoutBuffer = stdoutBuffer.slice(-4096);
+    if (launchToken && !launchToken.get()) {
+      const match = stdoutBuffer.match(/[?&]token=([A-Za-z0-9_-]+)/);
+      if (match) {
+        launchToken.set(match[1]);
+        log.debug("[dsh] captured launch token");
+      }
+    }
+    const output = chunk.trim();
     if (output) {
       log.debug("[dsh stdout]", { output });
       getProcessLogBuffer().addProviderStdout(output);
@@ -58,5 +115,6 @@ function startDeepSeekWeb(options) {
   return proc;
 }
 export {
+  LaunchToken,
   startDeepSeekWeb
 };

package/es/profile.d.ts

@@ -11,6 +11,12 @@ export declare function buildDshOverlay(options: {
      * undefined 时不写入 overlay，由 dsh-plugin 回退到 OPENCODE_ENABLE_LINT=1（与 opencode 一致）。
      */
     autoDiagnose?: boolean;
+    /**
+     * 宿主事件推送令牌（core 每轮启动随机）：随 plugin config 注入 dsh-plugin，
+     * 使其把归一化 ProviderEvent POST 到 core 的 HOST_EVENTS_API_PATH。
+     * 缺省（undefined）时不写该配置行，事件中继不启用（兼容未升级的 dsh-plugin）。
+     */
+    eventsToken?: string;
     /**
      * 诊断功能总开关（provider option enableDiagnostics）。
      * true（默认，对齐 opencode enableLsp）时 host 插件注册 run_diagnostics 工具与自动诊断逻辑。