@aipanel/provider-deepseek 1.2.7 → 1.2.8

package/lib/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/lib/bridge-script.cjs

@@ -110,6 +110,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;
@@ -137,8 +142,40 @@ function generateBridgeScript(options = {}) {
     if (event.data.type === ${JSON.stringify(import_core.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(import_core.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(import_core.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/lib/constants.cjs

@@ -20,15 +20,13 @@ __export(constants_exports, {
   DEFAULT_DEEPSEEK_PROVIDER_OPTIONS: () => DEFAULT_DEEPSEEK_PROVIDER_OPTIONS,
   DSH_API_BASE: () => DSH_API_BASE,
   DSH_DEFAULT_PORT: () => DSH_DEFAULT_PORT,
-  DSH_HOST_EVENTS_PATH: () => DSH_HOST_EVENTS_PATH,
   DSH_LOOPBACK_HOST: () => DSH_LOOPBACK_HOST,
-  DSH_MUX_EVENTS_PATH: () => DSH_MUX_EVENTS_PATH,
+  DSH_REMOTE_MUX_PATH: () => DSH_REMOTE_MUX_PATH,
   DSH_STORAGE_KEYS: () => DSH_STORAGE_KEYS
 });
 module.exports = __toCommonJS(constants_exports);
 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 = {
@@ -40,7 +38,6 @@ const DSH_STORAGE_KEYS = {
   DIAGNOSTICS_ENABLED: "dsh.bridge.diagnostics.enabled"
 };
 const DEFAULT_DEEPSEEK_PROVIDER_OPTIONS = {
-  agentPreset: "code",
   // 对齐 opencode 的 enableLsp（默认 true）：诊断功能默认开启
   enableDiagnostics: true,
   // 对齐 opencode：自动诊断默认开启
@@ -51,8 +48,7 @@ const DEFAULT_DEEPSEEK_PROVIDER_OPTIONS = {
   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/lib/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/lib/deepseek-web.cjs

@@ -2,6 +2,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,16 +16,61 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var deepseek_web_exports = {};
 __export(deepseek_web_exports, {
+  LaunchToken: () => LaunchToken,
   startDeepSeekWeb: () => startDeepSeekWeb
 });
 module.exports = __toCommonJS(deepseek_web_exports);
 var import_execa = require("execa");
 var import_node = require("@aipanel/core/node");
 const log = (0, import_node.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);
@@ -63,8 +109,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 });
       (0, import_node.getProcessLogBuffer)().addProviderStdout(output);
@@ -81,5 +138,6 @@ function startDeepSeekWeb(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  LaunchToken,
   startDeepSeekWeb
 });

package/lib/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/lib/profile.cjs

@@ -42,7 +42,8 @@ function buildDshOverlay(options) {
     pluginAvailable = true,
     clientAvailable = true,
     autoDiagnose,
-    enableDiagnostics = true
+    enableDiagnostics = true,
+    eventsToken
   } = options;
   const mcpUrl = `http://127.0.0.1:${vitePort}${import_node.MCP_API_PATH}`;
   const rows = [];
@@ -68,7 +69,11 @@ function buildDshOverlay(options) {
       `        vitePort: ${vitePort}`,
       `        contextApiPath: ${JSON.stringify(import_node.CONTEXT_API_PATH)}`,
       `        enableDiagnostics: ${enableDiagnostics ? "true" : "false"}`,
-      ...autoDiagnose !== void 0 ? [`        autoDiagnose: ${autoDiagnose ? "true" : "false"}`] : []
+      ...autoDiagnose !== void 0 ? [`        autoDiagnose: ${autoDiagnose ? "true" : "false"}`] : [],
+      ...eventsToken ? [
+        `        eventsToken: ${JSON.stringify(eventsToken)}`,
+        `        eventsPath: ${JSON.stringify(import_node.HOST_EVENTS_API_PATH)}`
+      ] : []
     ].join("\n")
   );
   rows.push(

package/lib/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 工具与自动诊断逻辑。

package/lib/provider.cjs

@@ -23,6 +23,7 @@ __export(provider_exports, {
 });
 module.exports = __toCommonJS(provider_exports);
 const import_meta = {};
+var import_core = require("@aipanel/core");
 var import_node = require("@aipanel/core/node");
 var import_constants = require("./constants.cjs");
 var import_constants2 = require("./constants.cjs");
@@ -76,6 +77,18 @@ or run without installing:
       };
     }
     const version = await (0, import_system.getDeepSeekVersion)();
+    const compatible = version === null ? true : (0, import_system.isDeepSeekVersionAtLeast)(version);
+    if (compatible === false) {
+      return {
+        ok: false,
+        message: `DeepSeek Harness (dsh) ${version} is too old: this provider requires dsh >= ${import_system.MIN_DSH_VERSION} (browser-session auth / Remote RPC protocol).
+
+Please upgrade:
+
+  npm install -g @deepseek-ai/dsh@latest
+`
+      };
+    }
     return { ok: true, version: version ?? void 0 };
   }
   async start(options) {
@@ -116,18 +129,50 @@ or run without installing:
       pluginAvailable,
       clientAvailable,
       autoDiagnose: this.opts.autoDiagnose,
-      enableDiagnostics: this.opts.enableDiagnostics
+      enableDiagnostics: this.opts.enableDiagnostics,
+      // 宿主事件推送令牌（core 每轮启动随机）：随 plugin config 注入 dsh-plugin 用于回推鉴权
+      eventsToken: options.eventsToken
     });
     const patchPath = (0, import_profile.writeDshOverlay)(options.cwd, overlay);
+    const launchToken = new import_deepseek_web.LaunchToken();
+    this.api.setLaunchTokenSource(() => launchToken.wait());
     const proc = (0, import_deepseek_web.startDeepSeekWeb)({
       port: options.port,
       hostname: import_constants2.DSH_LOOPBACK_HOST,
       cwd: options.cwd,
       patchPath,
       home: this.opts.home,
-      verbose: options.verbose
+      verbose: options.verbose,
+      launchToken
     });
     this.process = proc;
+    let webAuthCookie;
+    try {
+      const token = await launchToken.wait();
+      this.api.setLaunchToken(token);
+      const maxAuthAttempts = 3;
+      for (let attempt = 1; ; attempt++) {
+        try {
+          await this.api.authenticate();
+          break;
+        } catch (e) {
+          if (attempt >= maxAuthAttempts) throw e;
+          log.debug("dsh browser-session auth bootstrap attempt failed, retrying", {
+            attempt,
+            error: e instanceof Error ? e.message : String(e)
+          });
+          await (0, import_core.sleep)(250 * attempt);
+        }
+      }
+      webAuthCookie = this.api.getAuthCookie();
+    } catch (e) {
+      log.warn(
+        "failed to establish dsh web browser-session auth; UI may show authentication required",
+        {
+          error: e instanceof Error ? e.message : String(e)
+        }
+      );
+    }
     const settings = this.buildSettingsToApply();
     if (Object.keys(settings).length > 0) {
       void this.api.applySettings(settings).catch((e) => {
@@ -137,7 +182,7 @@ or run without installing:
         });
       });
     }
-    return { url: this.api.shellUrl, processHandle: proc };
+    return { url: this.api.shellUrl, processHandle: proc, webAuthCookie };
   }
   /** 把 providerOptions 配置映射为 dsh settings 命名空间 patch（仅含用户显式配置项） */
   buildSettingsToApply() {
@@ -169,8 +214,8 @@ or run without installing:
   async killOrphans() {
     return (0, import_system.killOrphanDeepSeekProcesses)();
   }
-  async listSessions(projectDir) {
-    const sessions = await this.api.listSessions(projectDir);
+  async listSessions(projectDir, activeSessionId) {
+    const sessions = await this.api.listSessions(projectDir, activeSessionId);
     const url = this.buildSessionUrl(projectDir, "");
     return sessions.map((s) => toChatSession(s, url));
   }
@@ -195,104 +240,12 @@ or run without installing:
     return `http://${import_constants2.DSH_LOOPBACK_HOST}:${this.deps.getProxyPort()}/`;
   }
   subscribeEvents(handler) {
-    const port = this.deps.getWebPort();
-    const base = `ws://${import_constants2.DSH_LOOPBACK_HOST}:${port}`;
-    const endpoints = [import_constants2.DSH_MUX_EVENTS_PATH, import_constants2.DSH_HOST_EVENTS_PATH];
-    log.debug("Subscribing to dsh event streams (WebSocket)", {
-      endpoints: endpoints.map((p) => base + p)
-    });
-    let aborted = false;
-    const sockets = /* @__PURE__ */ new Set();
-    const retryTimers = /* @__PURE__ */ new Set();
-    const cleanupAll = () => {
-      for (const timer of retryTimers) clearTimeout(timer);
-      retryTimers.clear();
-      for (const ws of sockets) {
-        try {
-          ws.close();
-        } catch {
-        }
-      }
-      sockets.clear();
-    };
-    const connect = (path, attempt = 0) => {
-      if (aborted) return;
-      let socket;
-      try {
-        socket = new WebSocket(base + path);
-      } catch (e) {
-        log.warn("dsh event WebSocket create failed", { path, error: String(e) });
-        scheduleReconnect(path, attempt + 1);
-        return;
-      }
-      sockets.add(socket);
-      socket.onmessage = (ev) => {
-        try {
-          const frame = JSON.parse(String(ev.data));
-          const event = mapEvent(frame);
-          if (event) handler(event);
-        } catch {
-        }
-      };
-      socket.onclose = () => {
-        sockets.delete(socket);
-        scheduleReconnect(path, attempt + 1);
-      };
-      socket.onerror = () => {
-        try {
-          socket.close();
-        } catch {
-        }
-      };
-    };
-    const scheduleReconnect = (path, attempt) => {
-      if (aborted) return;
-      const delays = [250, 500, 1e3, 2e3, 5e3];
-      const after = delays[Math.min(attempt, delays.length - 1)];
-      const timer = setTimeout(() => {
-        retryTimers.delete(timer);
-        connect(path);
-      }, after);
-      retryTimers.add(timer);
-    };
-    endpoints.forEach((p) => connect(p));
+    void handler;
+    log.debug("dsh \u4E8B\u4EF6\u7ECF\u5BBF\u4E3B\u63D2\u4EF6(dsh-plugin)\u4E2D\u7EE7\u63A8\u9001\uFF0Cprovider \u76F4\u8FDE\u4E8B\u4EF6\u901A\u9053\u4E3A\u7A7A");
     return () => {
-      aborted = true;
-      cleanupAll();
     };
   }
 }
-function mapEvent(frame) {
-  if (!frame || typeof frame.method !== "string" || !frame.payload) return null;
-  const payload = frame.payload;
-  const sessionId = payload.sessionId ?? "";
-  switch (frame.method) {
-    case "host/session-status": {
-      if (!sessionId) return null;
-      const running = payload.running === true;
-      return { type: "session.status", sessionId, status: running ? "running" : "idle" };
-    }
-    case "session/event": {
-      const event = payload.event;
-      const type = event?.type ?? "";
-      if (!sessionId || !type) return null;
-      switch (type) {
-        case "assistant/message":
-        case "turn/end":
-          return { type: "thinking", sessionId, thinking: false };
-        case "assistant/chunk":
-        case "thinking/delta":
-        case "turn/start":
-        case "step/start":
-          return { type: "thinking", sessionId, thinking: true };
-        default:
-          return null;
-      }
-    }
-    default:
-      return null;
-  }
-}
 function toChatSession(s, url) {
   return {
     id: s.sessionId,
@@ -309,7 +262,7 @@ function resolveDeepSeekOptions(options) {
   return {
     ...import_constants.DEFAULT_DEEPSEEK_PROVIDER_OPTIONS,
     home: po.home ?? options.home,
-    agentPreset: po.agentPreset ?? options.agentPreset ?? import_constants.DEFAULT_DEEPSEEK_PROVIDER_OPTIONS.agentPreset,
+    agentPreset: po.agentPreset ?? options.agentPreset,
     permissionPreset: po.permissionPreset ?? options.permissionPreset,
     busyEnter: po.busyEnter ?? options.busyEnter,
     autoDiagnose: po.autoDiagnose ?? options.autoDiagnose ?? import_constants.DEFAULT_DEEPSEEK_PROVIDER_OPTIONS.autoDiagnose,

package/lib/provider.d.ts

@@ -38,7 +38,7 @@ export declare class DeepSeekWebProvider implements WebProvider {
     private buildSettingsToApply;
     stop(): Promise<void>;
     killOrphans(): Promise<number>;
-    listSessions(projectDir: string): Promise<ChatSession[]>;
+    listSessions(projectDir: string, activeSessionId?: string): Promise<ChatSession[]>;
     createSession(projectDir: string, title?: string): Promise<ChatSession>;
     deleteSession(sessionId: string): Promise<void>;
     buildSessionUrl(projectDir: string, sessionId: string): string;

package/lib/system.cjs

@@ -17,8 +17,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var system_exports = {};
 __export(system_exports, {
+  MIN_DSH_VERSION: () => MIN_DSH_VERSION,
   checkDeepSeekInstalled: () => checkDeepSeekInstalled,
   getDeepSeekVersion: () => getDeepSeekVersion,
+  isDeepSeekVersionAtLeast: () => isDeepSeekVersionAtLeast,
   killOrphanDeepSeekProcesses: () => killOrphanDeepSeekProcesses
 });
 module.exports = __toCommonJS(system_exports);
@@ -42,6 +44,45 @@ async function checkDeepSeekInstalled() {
     });
   });
 }
+const MIN_DSH_VERSION = "0.1.2-rc.1";
+function parseDshVersion(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(version.trim());
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    pre: match[4]
+  };
+}
+function isDeepSeekVersionAtLeast(version, minimum = MIN_DSH_VERSION) {
+  const a = parseDshVersion(version);
+  const b = parseDshVersion(minimum);
+  if (!a || !b) return null;
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] > b[key];
+  }
+  if (a.pre === void 0 && b.pre === void 0) return true;
+  if (a.pre === void 0) return true;
+  if (b.pre === void 0) return false;
+  const pa = a.pre.split(".");
+  const pb = b.pre.split(".");
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const x = pa[i];
+    const y = pb[i];
+    if (x === void 0) return true;
+    if (y === void 0) return false;
+    const xn = /^\d+$/.test(x) ? Number(x) : NaN;
+    const yn = /^\d+$/.test(y) ? Number(y) : NaN;
+    if (!Number.isNaN(xn) && !Number.isNaN(yn)) {
+      if (xn !== yn) return xn > yn;
+    } else if (x !== y) {
+      return x > y;
+    }
+  }
+  return true;
+}
 function getDeepSeekVersion() {
   return new Promise((resolve) => {
     const proc = (0, import_child_process.spawn)("dsh", ["--version"], { stdio: "pipe", shell: true });
@@ -189,7 +230,9 @@ function killOrphanProcessesOnUnix(resolve, timer) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MIN_DSH_VERSION,
   checkDeepSeekInstalled,
   getDeepSeekVersion,
+  isDeepSeekVersionAtLeast,
   killOrphanDeepSeekProcesses
 });

package/lib/system.d.ts

@@ -1,3 +1,10 @@
 export declare function checkDeepSeekInstalled(): Promise<boolean>;
+/** 本 provider 要求的 dsh 最低版本（0.1.2 起：browser-session 认证 + {args} Remote RPC + remote.mux，协议不向下兼容） */
+export declare const MIN_DSH_VERSION = "0.1.2-rc.1";
+/**
+ * 判定 version 是否 >= minimum（semver 风格，含 pre-release 比较：0.1.2 > 0.1.2-rc.1）。
+ * @returns true/false；任一版本无法解析时返回 null（调用方按"无法确认"放行）。
+ */
+export declare function isDeepSeekVersionAtLeast(version: string, minimum?: string): boolean | null;
 export declare function getDeepSeekVersion(): Promise<string | null>;
 export declare function killOrphanDeepSeekProcesses(): Promise<number>;