lark-remote 0.5.3 → 0.5.5

package/dist/instance-lock.js

@@ -14,8 +14,20 @@
  * 与 killOrphan 的差异：killOrphan 是 fail-closed（身份不明就不杀进程），
  * 这里是 fail-open（身份不明就认定锁还活着，绝不 clobber 无法证伪的锁）。
  * 两者方向相反，因此身份判定取三态而不是布尔。
+ *
+ * 陈旧锁接管是「原子改名 + 复核」两步：
+ * 旧实现 read→isHeldByLive→unlink→create 四个动作不是原子的，两个进程可以
+ * 先后 unlink 掉对方刚创建的锁，双双认为自己持锁。现在改成：
+ *   1. `rename(lock → quarantine.<pid>.<rand>)`：rename 是原子的，同一时刻
+ *      只有一个进程能把当前锁文件「夺走」；
+ *   2. 复核夺到的 quarantine 内容——它可能已经不是刚才读到的陈旧锁（原持有者
+ *      恰好释放、其它进程刚创建），活的就原地 link 回去并拒绝；
+ *   3. 确认陈旧后才 `open(..., 'wx')` 建新锁；拿到 EEXIST 说明别的进程抢先，
+ *      重新读取并按「活锁 → 拒绝 / 陈旧 → 下一轮」处理（有限重试 + 退避）。
+ * 任何一步失败都不会直接 unlink 当前锁，避免把别人刚建好的锁删掉。
  */
 import fs from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import path from 'node:path';
 import { bestEffortUnlink } from './common/fs.js';
 import { isWin32 } from './platform/select.js';
@@ -29,6 +41,15 @@ export class InstanceAlreadyRunningError extends Error {
         this.lockPath = lockPath;
     }
 }
+/** 陈旧锁接管的最大轮次（每轮都是「读 → 原子改名 → 复核 → 尝试创建」）。 */
+const MAX_ACQUIRE_ATTEMPTS = 10;
+/** 每轮退避 5–25ms（含抖动），让并发启动的进程错开而不是持续碰撞。 */
+function acquireBackoffMs() {
+    return 5 + Math.floor(Math.random() * 20);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 /**
  * Probe whether a pid is alive.
  *  - process.kill(pid, 0) returning normally → alive.
@@ -71,49 +92,54 @@ export class InstanceLock {
      */
     async acquire() {
         fs.mkdirSync(path.dirname(this.lockPath), { recursive: true });
-        // Atomic create-with-exclusive: 'wx' fails if file already exists.
-        // This eliminates the TOCTOU race between readPid+verification
-        // and writeFileSync in the previous implementation.
-        try {
-            const fd = fs.openSync(this.lockPath, 'wx');
-            fs.writeSync(fd, this.lockContents(process.pid));
-            fs.closeSync(fd);
-        }
-        catch (err) {
-            if (err.code === 'EEXIST') {
-                // Lock file exists — check if the owner is still alive
-                const { pid, name } = this.readPidAndName();
-                if (pid && (await this.isHeldByLiveInstance(pid, name))) {
-                    throw new InstanceAlreadyRunningError(pid, this.lockPath);
-                }
-                // Stale lock: remove and retry once
-                bestEffortUnlink(this.lockPath);
-                try {
-                    const fd = fs.openSync(this.lockPath, 'wx');
-                    fs.writeSync(fd, this.lockContents(process.pid));
-                    fs.closeSync(fd);
-                }
-                catch (retryErr) {
-                    if (retryErr.code === 'EEXIST') {
-                        // Another process created the lock between unlink and retry.
-                        // Bounded retry (max 1): give up rather than recurse.
-                        const { pid, name } = this.readPidAndName();
-                        if (pid && (await this.isHeldByLiveInstance(pid, name))) {
-                            throw new InstanceAlreadyRunningError(pid, this.lockPath);
-                        }
-                        // New lock is also stale — give up rather than recurse.
-                        throw new InstanceAlreadyRunningError(pid ?? -1, this.lockPath);
-                    }
-                    throw retryErr;
-                }
+        for (let attempt = 0; attempt < MAX_ACQUIRE_ATTEMPTS; attempt++) {
+            // 1) 原子创建：'wx' 在文件已存在时失败，正常路径一步到位。
+            if (this.tryCreate())
+                return;
+            // 2) 锁已存在：活的就拒绝，无法证伪也拒绝（fail-open）。
+            const owner = this.readPidAndName(this.lockPath);
+            if (owner.pid && (await this.isHeldByLiveInstance(owner.pid, owner.name))) {
+                throw new InstanceAlreadyRunningError(owner.pid, this.lockPath);
+            }
+            // 3) 判为陈旧：原子地把当前锁文件改名到 quarantine（不直接 unlink）。
+            const quarantine = `${this.lockPath}.stale-${process.pid}-${randomBytes(6).toString('hex')}`;
+            try {
+                fs.renameSync(this.lockPath, quarantine);
             }
-            else {
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    // 别的进程先一步夺走/释放了锁：重新进入创建竞争。
+                    await sleep(acquireBackoffMs());
+                    continue;
+                }
                 throw err;
             }
+            // 4) 复核夺到的锁：读→rename 之间可能已被新实例替换成活锁。
+            // 内容与刚才读到的陈旧锁一致 = 同一个文件，直接沿用第 2 步的裁决（陈旧），
+            // 不重复查身份（win32 上每次身份查询要拉 PowerShell）。
+            const stolen = this.readPidAndName(quarantine);
+            const unchanged = stolen.pid === owner.pid && stolen.name === owner.name;
+            if (!unchanged && stolen.pid && (await this.isHeldByLiveInstance(stolen.pid, stolen.name))) {
+                this.restoreQuarantine(quarantine);
+                throw new InstanceAlreadyRunningError(stolen.pid, this.lockPath);
+            }
+            // 5) 确属陈旧：创建新锁。失败 = 别的进程在 rename 与 create 之间抢先。
+            const created = this.tryCreate();
+            bestEffortUnlink(quarantine);
+            if (created)
+                return;
+            const winner = this.readPidAndName(this.lockPath);
+            if (winner.pid && (await this.isHeldByLiveInstance(winner.pid, winner.name))) {
+                throw new InstanceAlreadyRunningError(winner.pid, this.lockPath);
+            }
+            await sleep(acquireBackoffMs());
         }
+        // 有限重试耗尽：仍然拿不到，按「有（可能是陈旧的）锁存在」报错，
+        // 不递归、不无界重试（并发启动风暴下宁可失败也不双开）。
+        throw new InstanceAlreadyRunningError(this.readPidAndName(this.lockPath).pid ?? -1, this.lockPath);
     }
     release() {
-        const { pid } = this.readPidAndName();
+        const { pid } = this.readPidAndName(this.lockPath);
         if (pid === process.pid) {
             bestEffortUnlink(this.lockPath);
         }
@@ -151,17 +177,62 @@ export class InstanceLock {
     lockContents(pid) {
         return `${pid}\n${binaryName(process.execPath)}`;
     }
-    readPidAndName() {
-        if (!fs.existsSync(this.lockPath))
+    /** 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。 */
+    tryCreate() {
+        try {
+            const fd = fs.openSync(this.lockPath, 'wx');
+            try {
+                fs.writeSync(fd, this.lockContents(process.pid));
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            return true;
+        }
+        catch (err) {
+            if (err.code === 'EEXIST')
+                return false;
+            throw err;
+        }
+    }
+    /**
+     * 把夺来的活锁放回原位。优先 `link`（目标已存在会失败，不会覆盖更新的锁），
+     * 再删 quarantine。目标已被更新锁占据时放弃恢复——此时当前锁文件属于一个
+     * 活实例，拒绝取锁仍然是对的。
+     */
+    restoreQuarantine(quarantine) {
+        try {
+            fs.linkSync(quarantine, this.lockPath);
+        }
+        catch {
+            // EEXIST：已有更新的锁（不要覆盖）；文件系统不支持 hardlink 时目标通常
+            // 仍不存在，退化为 rename 恢复（目标已存在则不碰）。
+            if (!fs.existsSync(this.lockPath)) {
+                try {
+                    fs.renameSync(quarantine, this.lockPath);
+                }
+                catch {
+                    /* 放弃恢复：当前锁文件仍可能属于一个活实例，拒绝取锁是对的。 */
+                }
+            }
+        }
+        bestEffortUnlink(quarantine);
+    }
+    /** 读取锁文件内容（无副作用：不再在读取失败时 unlink 当前锁）。 */
+    readPidAndName(file) {
+        let raw;
+        try {
+            raw = fs.readFileSync(file, 'utf-8').trim();
+        }
+        catch {
             return { pid: undefined, name: undefined };
-        const raw = fs.readFileSync(this.lockPath, 'utf-8').trim();
+        }
         const [pidStr, ...nameParts] = raw.split('\n');
         const pid = Number(pidStr);
         const name = nameParts.join('\n') || undefined;
         if (Number.isInteger(pid) && pid > 0 && name)
             return { pid, name };
-        // Malformed or missing name — treat as corrupt, unlink and return undefined
-        bestEffortUnlink(this.lockPath);
+        // Malformed or missing name — treat as corrupt/stale (caller quarantines it).
         return { pid: undefined, name: undefined };
     }
     /**

package/dist/router/config/dsh.d.ts

@@ -1,51 +1,81 @@
 /**
  * DshConfigBuilder — /config card fields for the DSH agent.
  *
- * DSH (DeepSeek Harness) is an HTTP-only agent. Beyond the Web Host base URL it
- * exposes three runtime-configurable knobs — preset, model, reasoning effort.
+ * DSH (DeepSeek Harness) is an HTTP-only agent. The card exposes the Web Host
+ * base URL plus preset/provider/model/reasoning-effort knobs. The launch token
+ * is a YAML-only fallback and is never rendered or saved through the card.
  *
- * 清单来源分两期：
- * - 动态清单（当前实现）：打开 /config 前通过 `llm.models` / `agentPreset.list`
- *   预取（Router 调 `prefetch()`），失败/离线回退下方固定兜底清单，卡不依赖
+ * 清单来源：
+ * - 动态清单：打开 /config 前通过 `session/modelCatalog` / `agentPresets/list`
+ *   预取（Router 调 `prefetch()`），失败/离线回退固定兜底清单，卡不依赖
  *   DSH 服务在线。
- * - 三个可选字段用空字符串哨兵表示「跟随服务端默认」：select 的 value `''`
- *   在 handleFieldChange 中被转成 undefined patch（router 删除键），config.yaml
- *   不写该键 = 服务端默认。
+ * - provider / model / reasoningEffort 用空字符串哨兵表示「跟随默认」：select
+ *   的 value `''` 在 handleFieldChange 中被转成 undefined patch（router 删除
+ *   键），config.yaml 不写该键 = 服务端默认。
+ * - provider 没有哨兵：旧配置没有 provider 时按 `deepseek-official` 生效，
+ *   与 runner 的兼容规则一致。provider 清单不硬编码，来自服务端目录。
  */
 import type { AgentConfigCardBuilder, ConfigField } from './types.js';
 import { type AppConfig } from '../../config/index.js';
-import type { DshModelCatalogValue, DshPresetListValue } from '../../runner/dsh/types.js';
+import type { DshModelCatalogValue, DshPermissionCatalogValue, DshPresetListValue } from '../../runner/dsh/types.js';
 /** DshConfigBuilder 预取只依赖的 client 方法子集。 */
 export interface DshCatalogClient {
     listModels(): Promise<DshModelCatalogValue>;
     listPresets(): Promise<DshPresetListValue>;
+    listPermissionPresets(): Promise<DshPermissionCatalogValue>;
 }
 export declare class DshConfigBuilder implements AgentConfigCardBuilder {
-    /** 最近一次预取用的 host；host 变更时缓存失效（下一张卡重新拉取）。 */
+    /** 最近一次预取用的 host；host 变更时缓存失效。 */
     private prefetchHost;
     private modelCatalog;
     private presets;
+    private permissionCatalog;
     /** 可注入 client 工厂（测试用）；默认生产实现。 */
     private readonly clientFactory;
-    constructor(clientFactory?: (baseUrl: string) => DshCatalogClient);
-    /** 异步预取模型/预设目录（§4.2 二期动态清单）。失败/离线静默回退固定兜底清单，
-     *  卡不依赖 DSH 服务在线；同一 host 只拉一次，避免每次刷卡重复请求。 */
-    prefetch(host?: string): Promise<void>;
+    constructor(clientFactory?: (baseUrl: string, token?: string, credentialsFile?: string) => DshCatalogClient);
+    /**
+     * 异步预取模型/预设目录。失败/离线静默回退固定兜底清单，卡不依赖 DSH
+     * 服务在线。`force` 用于打开 /config 时强制刷新（在 DSH Web UI 新增
+     * provider 后不需要重启 lark-remote）。三个请求并行，最坏等待一个超时。
+     */
+    prefetch(host?: string, token?: string, credentialsFile?: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
     /** 同步注入 catalog/presets（测试用，替代异步 prefetch；标记 prefetchHost 使
      *  后续 prefetch 短路，避免测试误触发网络请求）。 */
-    setCatalog(catalog: DshModelCatalogValue, presets?: DshPresetListValue): void;
-    /** 展平 llm.models 各 provider group 的模型 id；无 catalog 时回退固定清单。 */
-    private modelOptions;
+    setCatalog(catalog: DshModelCatalogValue, presets?: DshPresetListValue, permissionCatalog?: DshPermissionCatalogValue): void;
+    /** Provider 下拉：目录 groups + 当前值兜底；离线时只保留当前值。 */
+    private providerOptions;
+    /**
+     * 当前 provider 的模型清单。目录在线但该 provider 不在目录中时返回空列表
+     * （不把 DeepSeek 模型冒充成其他 provider 的模型）；目录离线时用固定兜底。
+     */
+    private modelOptionsFor;
+    private modelValues;
+    /** Provider 的默认模型：目录默认值属于该 provider 时优先，否则首个模型。 */
+    private defaultModelFor;
+    /**
+     * 模型可用的推理档位。目录在线时严格按模型声明：模型没有 reasoning 元数据
+     * 就返回空（只留「跟随模型默认」），避免把 A 模型的档位塞给 B 模型。
+     */
+    private effortOptionsFor;
     /** preset 清单；无 presets 时回退固定清单。显示名优先用 preset.yml 的 name。 */
     private presetOptions;
-    /** 模型在 catalog 中声明的推理档位；无 catalog/模型不在目录时回退固定档位。 */
-    private effortOptionsForModel;
+    /** 权限预设清单；配置默认只允许 defaultOptions（auto 只适用于当前会话）。 */
+    private permissionOptions;
+    /** “跟随服务端默认”文案带上实际默认值，避免用户不知道默认是什么。 */
+    private permissionDefaultText;
     buildFields(displayConfig: AppConfig): ConfigField[];
     handleFieldChange(key: string, value: unknown, config: AppConfig): Array<{
         key: string;
         value: unknown;
     }>;
-    /** 切到 newModel 后的档位补丁：当前档位仍被新模型支持 → 不产出；否则用新模型
-     *  目录中位；无目录/空列表 → undefined（清空 = 跟随服务端默认）。 */
+    /** 切 provider 后的联动：provider → 新 provider 的默认/首个模型 → 合法档位。 */
+    private providerChangePatches;
+    /**
+     * 切到 (provider, newModel) 后的档位补丁：当前档位仍被新模型支持 → 不产出；
+     * 否则用新模型目录中位；目录离线 → 不产出（保留现状，由服务端校验）；
+     * 模型无 reasoning 元数据 → 清空档位（跟随模型默认）。
+     */
     private effortPatchForModel;
 }