dsh-over-ssh 0.2.4 → 0.2.5

package/README.md

@@ -41,6 +41,28 @@ shell:
 
 不配也能用，只是 Web 终端永远开在本地（远程文件、远端执行、`@` 补全不受影响）。
 
+## 0.2.5 更新
+
+> 相对 npm 上的 **0.2.4** 的补丁版本，只有一处修复。
+
+- **修复：释放一条连接/删除一个会话，不再取消无关连接正在进行的重连。** transport 的"已释放代际"
+  原来是**全局**计数器：`release(连接 A)` 或删除任意会话都会让它自增，于是连接 B 正在 `discard` 旧
+  传输、准备重建的 `acquire()` 会拿到一次 `CANCELLED`，调用方无法把它与真实故障区分。现在按连接计数，
+  只有真正被释放的那条连接会取消自己的重建。同时补齐"重建窗口内删除本会话仍然取消"的判断：
+  该窗口里 slot 与 entry 都已删除、pending 尚未登记，新增 `#rebuilding` 记录在飞的 lane key，
+  `releaseSession` 依据 slots/entries/pending/rebuilding 四张表判断归属。
+- **修复：代理侧的编辑/补丁/删除/改名把版本守卫与读-改-写放进同一段临界区。** 之前只有 `fs.write`
+  内部的"校验 + rename"持路径条带锁：并发的 `fs.edit`/`fs.patch` 都能读到同一份旧内容，在 mtime 粒度粗的
+  文件系统上（`size:mtime` 版本串两次写之间不变）两边都会通过守卫、后者静默覆盖前者；在 ns 粒度上则表现
+  为并发编辑偶发 `E_VERSION_CONFLICT`。现在 `Edit`/`Patch` 的整段读-改-写、`Remove` 的校验+删除、
+  `Rename` 的源/目标（按字典序取锁，避免 A→B 与 B→A 互等）都在同一把路径锁里。
+- **修复：`fs.copy` / `fs.copyTree` 的目标侧判定与落地现在真的原子。** 旧实现先 `os.Stat(to)` 判断目标是否存在、
+  再拷临时文件、再 rename，三段之间没有按目标路径串行化：两个并发 `fs.copy(overwrite=false)` 能同时
+  看到"目标不存在"，于是两边都报成功、后者覆盖前者（实测 2 并发 = 2 次成功）。现在目标侧的检查与落地
+  在同一把路径锁里，实测并发下恰好 1 次成功、另一次 `E_VERSION_CONFLICT`。`fs.copyTree` 同样：
+  目标"不存在/为空"的判定与整棵拷贝同持目标锁，避免两棵交错的树同时落盘（旧行为下失败方还会报
+  `E_IO: mkdir ... file exists` 而不是契约里的 `E_VERSION_CONFLICT`）。
+
 ## 0.2.4 更新
 
 > 下面这些内容相对 npm 上的 **0.2.3** 一起生效。
@@ -132,11 +154,11 @@ shell:
 
 | 平台 | 字节 | sha256 |
 |---|---|---|
-| linux-amd64 | 5,591,200 | `c1b5e1ffcc9c7fd26e21140090dafec28f90a50fd3c5a3edb315d0165f84dc40` |
-| linux-arm64 | 5,243,040 | `524e8752ba5a63ac006d50f132f6286afa2ccfe55ed217d286e4ada361deea71` |
+| linux-amd64 | 5,595,296 | `38a32c04c60005cbe3688b05f56b2eed348e2d6de1b4d8dca925f203dd978ac2` |
+| linux-arm64 | 5,243,040 | `eb48c16da284caebd1de3656b3f8be7c7e8741d48bc20e012d07ecd7824d9ba4` |
 
-- 代理版本：`0.2.4-a7e77fb`
-- 源码提交：`a7e77fb`（Go 仓 `dsh-over-ssh-agent` 的这个提交）
+- 代理版本：`0.2.5-59d9305`
+- 源码提交：`59d9305`（Go 仓 `dsh-over-ssh-agent` 的这个提交）
 - 清单原文：包内 `agents/agent-manifest.json`
 - 核对：`sha256sum agents/<平台>/dsh-over-ssh-agent` 与上表比对；按上面的提交检出 Go 仓后
   `scripts/check.sh` 可重建同样的产物。

package/agents/agent-manifest.json

@@ -1,19 +1,19 @@
 {
   "version": 1,
-  "generatedAt": "2026-11-08T16:23:50.384Z",
-  "agentVersion": "0.2.4-a7e77fb",
-  "sourceCommit": "a7e77fb",
+  "generatedAt": "2026-11-08T23:42:20.933Z",
+  "agentVersion": "0.2.5-59d9305",
+  "sourceCommit": "59d9305",
   "artifacts": [
     {
       "platform": "linux-amd64",
       "path": "linux-amd64/dsh-over-ssh-agent",
-      "sha256": "c1b5e1ffcc9c7fd26e21140090dafec28f90a50fd3c5a3edb315d0165f84dc40",
-      "bytes": 5591200
+      "sha256": "38a32c04c60005cbe3688b05f56b2eed348e2d6de1b4d8dca925f203dd978ac2",
+      "bytes": 5595296
     },
     {
       "platform": "linux-arm64",
       "path": "linux-arm64/dsh-over-ssh-agent",
-      "sha256": "524e8752ba5a63ac006d50f132f6286afa2ccfe55ed217d286e4ada361deea71",
+      "sha256": "eb48c16da284caebd1de3656b3f8be7c7e8741d48bc20e012d07ecd7824d9ba4",
       "bytes": 5243040
     }
   ]

package/lib/index.js

@@ -1592,11 +1592,26 @@ var TransportService = class {
    */
   #retired = /* @__PURE__ */ new Set();
   /**
-   * Bumped by every explicit release. An `acquire()` that had to discard a lost transport checks this
-   * after the async discard: a release that arrived in that window must not be undone by recreating the
-   * lane. A global counter avoids a per-session map that would itself retain deleted session ids.
+   * Per-connection release counter: bumped by every explicit release of **that** connection.
+   *
+   * An `acquire()` that had to discard a lost transport checks it after the async discard: a release that
+   * arrived in that window must not be undone by recreating the lane.
+   *
+   * Keyed by connection id (not a single global counter): a global one meant that deleting any session, or
+   * releasing any *other* connection, cancelled an unrelated in-flight reconnect with `CANCELLED` — a
+   * spurious failure the caller could only interpret as a real one. The key space is the profile set
+   * (bounded), so this map cannot grow with sessions and cannot retain deleted session ids.
+   */
+  #releaseGeneration = /* @__PURE__ */ new Map();
+  /**
+   * Lane keys whose owning `acquire()` is between "the old transport is lost" and "the lanes were rebuilt".
+   *
+   * That window deletes the slot and the entry **before** it awaits the async discard, so neither table can
+   * say "this session is still being rebuilt here". Without it, a session deleted exactly then would not be
+   * recognised as the owner and its lane would be recreated (the bug `#releaseGeneration` exists to
+   * prevent). It is a set of *in-flight* keys, so it cannot grow.
    */
-  #releaseGeneration = 0;
+  #rebuilding = /* @__PURE__ */ new Set();
   constructor(options) {
     this.#selector = options.selector;
     this.#factories = options.factories;
@@ -1610,7 +1625,7 @@ var TransportService = class {
     const key = laneKey(profile.id, options);
     const lane = options?.lane ?? "interactive";
     const decided = this.#selector.decide(profile);
-    const releaseGeneration = this.#releaseGeneration;
+    const releaseGeneration = this.#generationOf(profile.id);
     if (lane === "stateful" && this.#statefulLaneLimit > 0 && !this.#entries.has(key) && !this.#pending.has(key) && this.#statefulLaneCount(profile.id, isWatchSessionKey(options?.sessionKey ?? "")) >= this.#statefulLaneLimit) {
       throw new SshDevError(
         "CONNECTION_INVALID",
@@ -1624,12 +1639,17 @@ var TransportService = class {
       if (decisionKey(existing.decision) === decisionKey(decided)) return existing;
     }
     if (existing !== void 0) {
-      await this.#discard(profile.id);
-      if (this.#releaseGeneration !== releaseGeneration) {
-        this.#forgetSlotIfIdle(profile.id, key);
-        throw new SshDevError("CANCELLED", `\u8FDE\u63A5\u5728\u91CD\u5EFA\u8FC7\u7A0B\u4E2D\u5DF2\u88AB\u91CA\u653E\uFF1A${profile.id}`, { connectionId: profile.id });
+      this.#rebuilding.add(key);
+      try {
+        await this.#discard(profile.id);
+        if (this.#generationOf(profile.id) !== releaseGeneration) {
+          this.#forgetSlotIfIdle(profile.id, key);
+          throw new SshDevError("CANCELLED", `\u8FDE\u63A5\u5728\u91CD\u5EFA\u8FC7\u7A0B\u4E2D\u5DF2\u88AB\u91CA\u653E\uFF1A${profile.id}`, { connectionId: profile.id });
+        }
+        this.#rememberSlot(profile.id, key);
+      } finally {
+        this.#rebuilding.delete(key);
       }
-      this.#rememberSlot(profile.id, key);
     }
     const inflight = this.#pending.get(key);
     if (inflight !== void 0) return inflight;
@@ -1677,9 +1697,43 @@ var TransportService = class {
     }
     return decisions;
   }
+  /**
+   * Connections that currently own (or are still building / tearing down) the stateful lane of one session.
+   *
+   * `#slots` alone is not enough: a reconnect deletes the slot **before** it awaits the async discard, so the
+   * release that happens in that window must still be recognised — otherwise the rebuild is not cancelled
+   * and an already-deleted session gets its lane back. Pending keys carry the connection id as their first
+   * `\u0000`-separated segment (see {@link laneKey}).
+   */
+  #connectionsOwningSessionLane(sessionKey2) {
+    const candidates = new Set(this.#slots.keys());
+    for (const entry of this.#entries.values()) {
+      if (entry.connectionId !== void 0) candidates.add(entry.connectionId);
+    }
+    for (const key of [...this.#pending.keys(), ...this.#rebuilding]) {
+      const separator = key.indexOf("\0");
+      if (separator > 0) candidates.add(key.slice(0, separator));
+    }
+    const found = /* @__PURE__ */ new Set();
+    for (const connectionId of candidates) {
+      const key = laneKey(connectionId, { lane: "stateful", sessionKey: sessionKey2 });
+      if (this.#pending.has(key) || this.#rebuilding.has(key) || this.#entries.has(key) || (this.#slots.get(connectionId)?.has(key) ?? false)) {
+        found.add(connectionId);
+      }
+    }
+    return found;
+  }
+  /** Current release counter of one connection. */
+  #generationOf(connectionId) {
+    return this.#releaseGeneration.get(connectionId) ?? 0;
+  }
+  /** Record one explicit release of a connection. */
+  #bumpGeneration(connectionId) {
+    this.#releaseGeneration.set(connectionId, this.#generationOf(connectionId) + 1);
+  }
   /** Dispose and forget **every lane** of one connection. */
   async release(connectionId) {
-    this.#releaseGeneration++;
+    this.#bumpGeneration(connectionId);
     await this.#discard(connectionId);
   }
   /** Number of cached/pending stateful lanes of one class (watch vs session) on one connection. */
@@ -1721,7 +1775,7 @@ var TransportService = class {
    * @param sessionKey - the DSH session id used when the stateful lane was acquired.
    */
   async releaseSession(sessionKey2) {
-    this.#releaseGeneration++;
+    const released = this.#connectionsOwningSessionLane(sessionKey2);
     const disposals = [];
     for (const [connectionId, keys] of [...this.#slots]) {
       for (const key of [...keys]) {
@@ -1742,11 +1796,12 @@ var TransportService = class {
       }
       if (keys.size === 0) this.#slots.delete(connectionId);
     }
+    for (const connectionId of released) this.#bumpGeneration(connectionId);
     await Promise.all(disposals);
   }
   /** Dispose every connection and lane (plugin unload, connection-service shutdown). */
   async disposeAll() {
-    this.#releaseGeneration++;
+    for (const connectionId of this.#slots.keys()) this.#bumpGeneration(connectionId);
     for (const key of this.#pending.keys()) this.#retired.add(key);
     await Promise.all([...this.#slots.keys()].map((id) => this.#discard(id)));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-over-ssh",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "SSH remote development for DeepSeek Harness: connections (key/password/ProxyJump/ssh config), remote files without sync, remote terminal, remote workspaces, remote @-completion, upload/download.",
   "type": "module",
   "main": "lib/index.js",