@aipanel/provider-deepseek 1.2.7 → 1.2.9

package/es/api.d.ts

@@ -7,30 +7,63 @@ 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 启动初期 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;
@@ -112,42 +213,14 @@ class DeepSeekAPI {
     timer.end("\u274C All retries exhausted");
     throw lastError;
   }
-  /**
-   * 通过 dsh settings.update 应用 providerOptions 指定的用户设置（逐命名空间幂等 patch）。
-   * dsh 启动初期 API 未就绪，整体带重试；单个命名空间不存在会导致该次调用失败重试。
-   */
-  async applySettings(sections, retries = DEFAULT_RETRIES) {
-    const namespaces = Object.keys(sections);
-    if (namespaces.length === 0) return;
-    const timer = log.timer("applySettings", { namespaces });
-    let lastError = null;
-    for (let i = 0; i < retries; i++) {
-      try {
-        log.debug(`Attempt ${i + 1}/${retries}`, { method: "settings.update", namespaces });
-        for (const [ns, patch] of Object.entries(sections)) {
-          await this.call("settings.update", { ns, patch });
-        }
-        timer.end(`Applied settings: ${namespaces.join(", ")}`);
-        return;
-      } catch (e) {
-        lastError = e instanceof Error ? e : new Error(String(e));
-        log.debug(`Attempt ${i + 1} failed: ${lastError.message}`, { method: "applySettings" });
-        if (i < retries - 1) {
-          await sleep(RETRY_DELAY);
-        }
-      }
-    }
-    timer.end("\u274C All retries exhausted");
-    throw lastError;
-  }
   /** 归档会话（dsh 无硬删除，仅归档；幂等） */
   async archiveSession(sessionId, retries = DEFAULT_RETRIES) {
     const timer = log.timer("archiveSession", { sessionId, retries });
     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 +236,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 +315,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/constants.d.ts

@@ -4,24 +4,18 @@
  */
 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 默认端口（未显式指定时） */
 export declare const DSH_DEFAULT_PORT = 3080;
-/** ==================== dsh localStorage 键 ==================== */
-export declare const DSH_STORAGE_KEYS: {
-    /** 当前选中会话（SPA 启动时据此恢复选中，无 URL 深链） */
-    readonly CURRENT_SESSION: "dsh.sessions.current";
-    /** 选中的页面元素（bridge 写入，dsh-client 的 @aipanel source 读取） */
-    readonly SELECTION: "dsh.bridge.selection";
-    /** 诊断功能开关标记（bridge 按 provider 配置写入，dsh-client 据此决定是否注册诊断视图） */
-    readonly DIAGNOSTICS_ENABLED: "dsh.bridge.diagnostics.enabled";
-};
 /** ==================== Provider 专属配置默认值 ==================== */
 export declare const DEFAULT_DEEPSEEK_PROVIDER_OPTIONS: DeepSeekProviderOptions;

package/es/constants.js

@@ -1,18 +1,8 @@
 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 = {
-  /** 当前选中会话（SPA 启动时据此恢复选中，无 URL 深链） */
-  CURRENT_SESSION: "dsh.sessions.current",
-  /** 选中的页面元素（bridge 写入，dsh-client 的 @aipanel source 读取） */
-  SELECTION: "dsh.bridge.selection",
-  /** 诊断功能开关标记（bridge 按 provider 配置写入，dsh-client 据此决定是否注册诊断视图） */
-  DIAGNOSTICS_ENABLED: "dsh.bridge.diagnostics.enabled"
-};
 const DEFAULT_DEEPSEEK_PROVIDER_OPTIONS = {
-  agentPreset: "code",
   // 对齐 opencode 的 enableLsp（默认 true）：诊断功能默认开启
   enableDiagnostics: true,
   // 对齐 opencode：自动诊断默认开启
@@ -22,8 +12,6 @@ export {
   DEFAULT_DEEPSEEK_PROVIDER_OPTIONS,
   DSH_API_BASE,
   DSH_DEFAULT_PORT,
-  DSH_HOST_EVENTS_PATH,
   DSH_LOOPBACK_HOST,
-  DSH_MUX_EVENTS_PATH,
-  DSH_STORAGE_KEYS
+  DSH_REMOTE_MUX_PATH
 };

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/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * DeepSeek Harness Web Provider
- * 实现 WebProvider 契约：进程管理、RPC 会话 API、桥接脚本、CLI 环境检查。
+ * 实现 WebProvider 契约：进程管理、RPC 会话 API、dsh 侧插件编排、CLI 环境检查。
  * 所有 dsh 专属类型与常量自包含于此包。
  */
 import type { ProviderInitContext, WebProvider } from "@aipanel/core";
@@ -10,7 +10,6 @@ export { DeepSeekAPI } from "./api";
 export type { DeepSeekWebProviderConfig, DeepSeekWebProviderDeps } from "./provider";
 export { startDeepSeekWeb, type DeepSeekWebOptions } from "./deepseek-web";
 export { buildDshOverlay, writeDshOverlay } from "./profile";
-export { generateBridgeScript, type BridgeScriptOptions } from "./bridge-script";
 export { checkDeepSeekInstalled, getDeepSeekVersion, killOrphanDeepSeekProcesses } from "./system";
 export { DEFAULT_DEEPSEEK_PROVIDER_OPTIONS, DSH_LOOPBACK_HOST, DSH_DEFAULT_PORT } from "./constants";
 export type { DeepSeekProviderOptions, DeepSeekPermissionPreset, DeepSeekBusyEnter, SessionSummary, WorkspaceView, SessionStreamEvent, ServerRequest, ServerResponse, ClientRequest, } from "./types";

package/es/index.js

@@ -10,7 +10,6 @@ function createProvider(ctx) {
 import { DeepSeekAPI } from "./api.js";
 import { startDeepSeekWeb } from "./deepseek-web.js";
 import { buildDshOverlay, writeDshOverlay } from "./profile.js";
-import { generateBridgeScript } from "./bridge-script.js";
 import { checkDeepSeekInstalled, getDeepSeekVersion, killOrphanDeepSeekProcesses } from "./system.js";
 import { DEFAULT_DEEPSEEK_PROVIDER_OPTIONS, DSH_LOOPBACK_HOST as DSH_LOOPBACK_HOST2, DSH_DEFAULT_PORT } from "./constants.js";
 export {
@@ -21,7 +20,6 @@ export {
   buildDshOverlay,
   checkDeepSeekInstalled,
   createProvider,
-  generateBridgeScript,
   getDeepSeekVersion,
   killOrphanDeepSeekProcesses,
   startDeepSeekWeb,