@aipanel/provider-deepseek 1.2.7 → 1.2.8

package/es/profile.js

@@ -4,6 +4,7 @@ import {
   AIPANEL_CACHE_DIR,
   MCP_API_PATH,
   CONTEXT_API_PATH,
+  HOST_EVENTS_API_PATH,
   createLogger
 } from "@aipanel/core/node";
 const log = createLogger("DeepSeekProfile");
@@ -14,7 +15,8 @@ function buildDshOverlay(options) {
     pluginAvailable = true,
     clientAvailable = true,
     autoDiagnose,
-    enableDiagnostics = true
+    enableDiagnostics = true,
+    eventsToken
   } = options;
   const mcpUrl = `http://127.0.0.1:${vitePort}${MCP_API_PATH}`;
   const rows = [];
@@ -40,7 +42,11 @@ function buildDshOverlay(options) {
       `        vitePort: ${vitePort}`,
       `        contextApiPath: ${JSON.stringify(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(HOST_EVENTS_API_PATH)}`
+      ] : []
     ].join("\n")
   );
   rows.push(

package/es/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/es/provider.js

@@ -1,14 +1,21 @@
 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 { sleep } from "@aipanel/core";
 import { createLogger } from "@aipanel/core/node";
 import { DEFAULT_DEEPSEEK_PROVIDER_OPTIONS } from "./constants.js";
-import { DSH_LOOPBACK_HOST, DSH_MUX_EVENTS_PATH, DSH_HOST_EVENTS_PATH } from "./constants.js";
+import { DSH_LOOPBACK_HOST } from "./constants.js";
 import { DeepSeekAPI } from "./api.js";
 import { generateBridgeScript } from "./bridge-script.js";
-import { startDeepSeekWeb } from "./deepseek-web.js";
+import { LaunchToken, startDeepSeekWeb } from "./deepseek-web.js";
 import { buildDshOverlay, writeDshOverlay } from "./profile.js";
-import { checkDeepSeekInstalled, getDeepSeekVersion, killOrphanDeepSeekProcesses } from "./system.js";
+import {
+  checkDeepSeekInstalled,
+  getDeepSeekVersion,
+  isDeepSeekVersionAtLeast,
+  killOrphanDeepSeekProcesses,
+  MIN_DSH_VERSION
+} from "./system.js";
 import {
   DSH_CLIENT_PACKAGE,
   DSH_PLUGIN_PACKAGE,
@@ -60,6 +67,18 @@ or run without installing:
       };
     }
     const version = await getDeepSeekVersion();
+    const compatible = version === null ? true : isDeepSeekVersionAtLeast(version);
+    if (compatible === false) {
+      return {
+        ok: false,
+        message: `DeepSeek Harness (dsh) ${version} is too old: this provider requires dsh >= ${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) {
@@ -100,18 +119,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 = writeDshOverlay(options.cwd, overlay);
+    const launchToken = new LaunchToken();
+    this.api.setLaunchTokenSource(() => launchToken.wait());
     const proc = startDeepSeekWeb({
       port: options.port,
       hostname: 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 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) => {
@@ -121,7 +172,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() {
@@ -153,8 +204,8 @@ or run without installing:
   async killOrphans() {
     return 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));
   }
@@ -179,104 +230,12 @@ or run without installing:
     return `http://${DSH_LOOPBACK_HOST}:${this.deps.getProxyPort()}/`;
   }
   subscribeEvents(handler) {
-    const port = this.deps.getWebPort();
-    const base = `ws://${DSH_LOOPBACK_HOST}:${port}`;
-    const endpoints = [DSH_MUX_EVENTS_PATH, 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,
@@ -293,7 +252,7 @@ function resolveDeepSeekOptions(options) {
   return {
     ...DEFAULT_DEEPSEEK_PROVIDER_OPTIONS,
     home: po.home ?? options.home,
-    agentPreset: po.agentPreset ?? options.agentPreset ?? 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 ?? DEFAULT_DEEPSEEK_PROVIDER_OPTIONS.autoDiagnose,

package/es/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>;

package/es/system.js

@@ -18,6 +18,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 = spawn("dsh", ["--version"], { stdio: "pipe", shell: true });
@@ -164,7 +203,9 @@ function killOrphanProcessesOnUnix(resolve, timer) {
   });
 }
 export {
+  MIN_DSH_VERSION,
   checkDeepSeekInstalled,
   getDeepSeekVersion,
+  isDeepSeekVersionAtLeast,
   killOrphanDeepSeekProcesses
 };

package/lib/api.cjs

@@ -42,26 +42,124 @@ 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 = import_http.default.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: (0, import_node_crypto.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: `${import_constants.DSH_API_BASE}/${method}`,
         method: "POST",
-        headers: { "Content-Type": "application/json" }
+        headers
       },
       JSON.stringify(message)
     );
@@ -74,24 +172,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 = import_core.DEFAULT_RETRIES) {
-    const timer = log.timer("listSessions", { projectDir, retries });
+  async listSessions(projectDir, activeSessionId, retries = import_core.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;
@@ -112,23 +214,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 = import_core.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;
@@ -144,7 +245,7 @@ class DeepSeekAPI {
     throw lastError;
   }
   /**
-   * 通过 dsh settings.update 应用 providerOptions 指定的用户设置（逐命名空间幂等 patch）。
+   * 通过 dsh settings/mutate 应用 providerOptions 指定的用户设置（逐命名空间幂等 patch）。
    * dsh 启动初期 API 未就绪，整体带重试；单个命名空间不存在会导致该次调用失败重试。
    */
   async applySettings(sections, retries = import_core.DEFAULT_RETRIES) {
@@ -154,9 +255,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;
@@ -177,8 +283,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) {
@@ -194,6 +300,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()}${import_constants.DSH_REMOTE_MUX_PATH}`;
+      const ws = new WebSocket(url, {
+        headers: { Cookie: cookie }
+      });
+      const streamId = (0, import_node_crypto.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 import_node.PerformanceTimer("HTTP Request", {
       operation: `${options.method || "GET"} ${options.path}`
@@ -203,13 +379,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)}`)
+            );
           }
         });
       });