[Init] Initial commit - NetMesh terminal manager

electron/bridges/sftpTransferSessionLease.cjs

@@ -0,0 +1,199 @@
+"use strict";
+
+/**
+ * Transfer-owned SFTP session leases (reference counting).
+ *
+ * File transfers borrow panel (or agent) sftpIds. Without leases, disconnecting
+ * the browser panel calls closeSftp and kills in-flight / paused transfers.
+ *
+ * Model:
+ * - acquire(sftpId, transferId) while a transfer uses that session
+ * - release when the transfer finishes, fails, or is cancelled
+ * - closeSftp with outstanding leases becomes a soft-close: the client stays
+ *   in sftpClients until the last transfer releases
+ * - when the last lease is released on a soft-closed session, the real close
+ *   runs (pendingHardClose callback / flag)
+ *
+ * This is intentionally independent of UI panels. Browse can go away; transfers
+ * keep their leased sessions until they complete.
+ */
+
+/**
+ * @typedef {object} SftpTransferSessionLeaseStore
+ * @property {(sftpId: string, transferId: string) => boolean} acquire
+ * @property {(sftpId: string, transferId: string) => { released: boolean, shouldHardClose: boolean, remaining: number }} release
+ * @property {(sftpId: string) => boolean} isHeld
+ * @property {(sftpId: string) => number} getLeaseCount
+ * @property {(sftpId: string) => string[]} listTransferIds
+ * @property {(sftpId: string) => boolean} markSoftClosed
+ * @property {(sftpId: string) => boolean} isSoftClosed
+ * @property {(sftpId: string) => number|undefined} getPendingHardCloseToken
+ * @property {(sftpId: string) => number|undefined} beginHardClose
+ * @property {(sftpId: string, closeToken: number) => boolean} commitHardClose
+ * @property {(sftpId: string) => boolean} isHardCloseCommitted
+ * @property {(sftpId: string) => void} clear
+ * @property {() => void} resetForTests
+ */
+
+/**
+ * @returns {SftpTransferSessionLeaseStore}
+ */
+function createSftpTransferSessionLeaseStore() {
+  /** @type {Map<string, Set<string>>} */
+  const leases = new Map();
+  /** @type {Set<string>} */
+  const softClosed = new Set();
+  /** @type {Map<string, { token: number, committed: boolean }>} */
+  const hardCloseClaims = new Map();
+  let nextHardCloseToken = 0;
+
+  function beginHardClose(sftpId) {
+    const existing = hardCloseClaims.get(sftpId);
+    if (existing) return existing.token;
+    nextHardCloseToken += 1;
+    hardCloseClaims.set(sftpId, {
+      token: nextHardCloseToken,
+      committed: false,
+    });
+    return nextHardCloseToken;
+  }
+
+  function getSet(sftpId) {
+    let set = leases.get(sftpId);
+    if (!set) {
+      set = new Set();
+      leases.set(sftpId, set);
+    }
+    return set;
+  }
+
+  return {
+    acquire(sftpId, transferId) {
+      if (!sftpId || !transferId) return false;
+      const closeClaim = hardCloseClaims.get(sftpId);
+      // Before commit, a directory walk's next child may cancel the deferred
+      // close and keep using the live session. After commit, the SSH/SFTP close
+      // has started and this client must never be lent again.
+      if (closeClaim?.committed) return false;
+      if (closeClaim) {
+        hardCloseClaims.delete(sftpId);
+        // The panel's close intent remains sticky across the cancelled close;
+        // the next last release must claim hard-close again.
+        softClosed.add(sftpId);
+      }
+      const set = getSet(sftpId);
+      const before = set.size;
+      set.add(String(transferId));
+      // Keep soft-close sticky. Panel already asked to tear down this session;
+      // new transfers may still borrow it, but the last release must hard-close.
+      // Clearing softClosed here previously leaked sockets forever after
+      // panel close + re-acquire + all transfers finishing.
+      return set.size > before;
+    },
+
+    release(sftpId, transferId) {
+      if (!sftpId || !transferId) {
+        return { released: false, shouldHardClose: false, remaining: 0 };
+      }
+      const set = leases.get(sftpId);
+      if (!set || !set.has(String(transferId))) {
+        return {
+          released: false,
+          shouldHardClose: softClosed.has(sftpId) && (!set || set.size === 0),
+          remaining: set ? set.size : 0,
+        };
+      }
+      set.delete(String(transferId));
+      const remaining = set.size;
+      if (remaining === 0) {
+        leases.delete(sftpId);
+        const shouldHardClose = softClosed.has(sftpId);
+        if (shouldHardClose) {
+          beginHardClose(sftpId);
+          softClosed.delete(sftpId);
+        }
+        return { released: true, shouldHardClose, remaining: 0 };
+      }
+      return { released: true, shouldHardClose: false, remaining };
+    },
+
+    isHeld(sftpId) {
+      if (!sftpId) return false;
+      const set = leases.get(sftpId);
+      return !!(set && set.size > 0);
+    },
+
+    getLeaseCount(sftpId) {
+      if (!sftpId) return 0;
+      return leases.get(sftpId)?.size ?? 0;
+    },
+
+    listTransferIds(sftpId) {
+      if (!sftpId) return [];
+      return [...(leases.get(sftpId) ?? [])];
+    },
+
+    /**
+     * Panel wants to close this session. If transfers still hold it, defer the
+     * real teardown until the last transfer releases.
+     * @returns {boolean} true when close was deferred (session stays open)
+     */
+    markSoftClosed(sftpId) {
+      if (!sftpId) return false;
+      if (!this.isHeld(sftpId)) {
+        softClosed.delete(sftpId);
+        return false;
+      }
+      softClosed.add(sftpId);
+      return true;
+    },
+
+    isSoftClosed(sftpId) {
+      return !!sftpId && softClosed.has(sftpId);
+    },
+
+    getPendingHardCloseToken(sftpId) {
+      return hardCloseClaims.get(sftpId)?.token;
+    },
+
+    beginHardClose(sftpId) {
+      if (!sftpId) return undefined;
+      return beginHardClose(sftpId);
+    },
+
+    commitHardClose(sftpId, closeToken) {
+      const claim = hardCloseClaims.get(sftpId);
+      if (!claim || claim.token !== closeToken || claim.committed || this.isHeld(sftpId)) {
+        return false;
+      }
+      claim.committed = true;
+      return true;
+    },
+
+    isHardCloseCommitted(sftpId) {
+      return hardCloseClaims.get(sftpId)?.committed === true;
+    },
+
+    clear(sftpId) {
+      if (!sftpId) return;
+      leases.delete(sftpId);
+      softClosed.delete(sftpId);
+      hardCloseClaims.delete(sftpId);
+    },
+
+    resetForTests() {
+      leases.clear();
+      softClosed.clear();
+      hardCloseClaims.clear();
+      nextHardCloseToken = 0;
+    },
+  };
+}
+
+/** Process-wide store shared by transferBridge and closeSftp. */
+const sftpTransferSessionLeaseStore = createSftpTransferSessionLeaseStore();
+
+module.exports = {
+  createSftpTransferSessionLeaseStore,
+  sftpTransferSessionLeaseStore,
+};