openship 0.6.9 → 0.7.1

package/dist/{chunk-UAWY6X7V.js → chunk-GPTBEPUE.js}

@@ -8,30 +8,32 @@ import {
 import {
   getTarCreateEnv,
   prepareSourceTarArgs
-} from "./chunk-VAI5VOOI.js";
+} from "./chunk-2YAY5XHK.js";
 import {
   connectSshClient,
   openDockerDialStdioChannel,
   openSftp,
   openSshUnixSocket,
   reconcileKnownHosts
-} from "./chunk-TAZZZKYO.js";
+} from "./chunk-TKK5NPDQ.js";
 import {
   LocalExecutor
-} from "./chunk-T6DVUX4F.js";
+} from "./chunk-KCMEWNP7.js";
 import {
   emitBufferedLines,
   flushBufferedLines,
   hasLocalCommand,
   logEntry,
   sq
-} from "./chunk-P7RCYELG.js";
+} from "./chunk-2BAKEGGF.js";
 import {
   HostChannelUnavailableError,
   SshDisconnectedError,
+  SshExecRequestError,
   commandForError,
-  isSshAuthError
-} from "./chunk-N5YZMO33.js";
+  isSshAuthError,
+  isSshExecRequestError
+} from "./chunk-L4DRH6ZA.js";
 import {
   HOST_CHANNEL_AUTH_REJECTED,
   HOST_CHANNEL_NOT_PROVISIONED,
@@ -42,13 +44,14 @@ import {
   hostChannelAccount,
   hostFirewallRule,
   safeErrorMessage
-} from "./chunk-WEZFTL4V.js";
+} from "./chunk-COI4VFRW.js";
 
 // ../../packages/adapters/src/system/executor.ts
 import { existsSync, readFileSync } from "fs";
 import { networkInterfaces } from "os";
 
 // ../../packages/adapters/src/system/ssh-executor.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { createReadStream } from "fs";
 import { mkdtemp as mkdtemp2, rm as fsRm2, stat } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
@@ -250,6 +253,19 @@ async function uploadFileWithRsync(localFile, remoteFile, deps, onLog, opts) {
 
 // ../../packages/adapters/src/system/ssh-executor.ts
 var remoteDirname = posix.dirname;
+var SFTP_OPERATION_TIMEOUT_MS = 3e4;
+var CHANNEL_CLOSE_GRACE_MS = 750;
+var TRANSPORT_CLOSE_GRACE_MS = 250;
+function tagExecRequestError(error) {
+  return error.message === "Unable to exec" ? new SshExecRequestError(error) : error;
+}
+function abortError(operation, signal) {
+  const reason = signal.reason;
+  const suffix = reason instanceof Error && reason.message ? `: ${reason.message}` : "";
+  const error = new Error(`SSH ${operation} cancelled${suffix}`);
+  error.name = "AbortError";
+  return error;
+}
 function clampWindow(value, fallback, min, max) {
   if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
   return Math.max(min, Math.min(max, Math.floor(value)));
@@ -259,10 +275,19 @@ var SshExecutor = class _SshExecutor {
   connecting = null;
   /** One shared SFTP subsystem channel per client — see sftp(). */
   sftpChannel = null;
+  sftpWrapper = null;
+  /** All requests cancelled on one shared channel join the same close/reset
+   * barrier, so the second listener cannot miss the first listener's `close`
+   * event and needlessly wait for the force-reset deadline. */
+  sftpQuiescence = /* @__PURE__ */ new WeakMap();
   config;
+  /** Deployment cancellation belongs to an async call tree, not to this pooled
+   * executor instance.  AsyncLocalStorage prevents one deployment from making
+   * unrelated users of the same SSH connection inherit its signal. */
+  abortScope = new AsyncLocalStorage();
   /** Subscribers notified when the transport drops (see onDisconnect). */
   disconnectListeners = /* @__PURE__ */ new Set();
-  /** In-flight cancelable ops — each entry aborts ONE exec/stream on a drop,
+  /** In-flight cancelable ops — each entry aborts ONE exec/stream/SFTP request on a drop,
    *  so a dead channel fails fast instead of hanging to its command timeout. */
   inflight = /* @__PURE__ */ new Set();
   /** Reverse-forward handlers keyed by the remote bound port (see reverseForward). */
@@ -275,15 +300,66 @@ var SshExecutor = class _SshExecutor {
     }
     this.config = config;
   }
+  runWithAbortSignal(signal, fn) {
+    if (signal.aborted) return Promise.reject(abortError("operation", signal));
+    return this.abortScope.run(signal, async () => {
+      this.throwIfAborted("operation");
+      return fn();
+    });
+  }
+  operationSignal() {
+    return this.abortScope.getStore();
+  }
+  throwIfAborted(operation, signal = this.operationSignal()) {
+    if (signal?.aborted) throw abortError(operation, signal);
+  }
+  resolvedSignal(explicit) {
+    const ambient = this.operationSignal();
+    if (!explicit || explicit === ambient) return ambient ?? explicit;
+    if (!ambient) return explicit;
+    return AbortSignal.any([explicit, ambient]);
+  }
+  /** A handshake is already bounded by ssh2's readyTimeout.  A deployment
+   * cancellation may stop waiting sooner because no remote mutation can have
+   * started before connect() resolves; the shared attempt is left alive for an
+   * unrelated/following caller instead of tearing down pooled state. */
+  awaitConnection(attempt) {
+    const signal = this.operationSignal();
+    if (!signal) return attempt;
+    this.throwIfAborted("connection", signal);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (act) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        act();
+      };
+      const onAbort = () => finish(() => reject(abortError("connection", signal)));
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      attempt.then(
+        (client) => finish(() => resolve(client)),
+        (error) => finish(() => reject(error))
+      );
+    });
+  }
   async connect() {
-    if (this.client) return this.client;
-    if (this.connecting) return this.connecting;
+    if (this.client) {
+      this.throwIfAborted("connection");
+      return this.client;
+    }
+    if (this.connecting) return this.awaitConnection(this.connecting);
     const attempt = (async () => {
       const client = await connectSshClient(this.config);
       const onTransportDown = (cause) => {
         if (this.client !== client) return;
         this.client = null;
         this.sftpChannel = null;
+        this.sftpWrapper = null;
         this.handleDisconnect(cause);
       };
       client.on("close", () => onTransportDown());
@@ -297,7 +373,7 @@ var SshExecutor = class _SshExecutor {
       if (this.connecting === attempt) this.connecting = null;
     };
     attempt.then(clearMemo, clearMemo);
-    return attempt;
+    return this.awaitConnection(attempt);
   }
   /**
    * Subscribe to transport-level disconnects. Returns an unsubscribe fn.
@@ -318,6 +394,15 @@ var SshExecutor = class _SshExecutor {
     const err = new SshDisconnectedError(
       cause?.message ? `SSH connection lost: ${cause.message}` : "SSH connection lost"
     );
+    this.rejectInflight(err);
+    for (const cb of [...this.disconnectListeners]) {
+      try {
+        cb(err);
+      } catch {
+      }
+    }
+  }
+  rejectInflight(err) {
     const aborts = [...this.inflight];
     this.inflight.clear();
     for (const abort of aborts) {
@@ -326,12 +411,136 @@ var SshExecutor = class _SshExecutor {
       } catch {
       }
     }
-    for (const cb of [...this.disconnectListeners]) {
+  }
+  async waitForChannelClose(channel, close) {
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (closed) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        channel.removeListener("close", onClose);
+        channel.removeListener("error", onError);
+        resolve(closed);
+      };
+      const onClose = () => finish(true);
+      const onError = () => {
+      };
+      const timer = setTimeout(() => finish(false), CHANNEL_CLOSE_GRACE_MS);
+      timer.unref?.();
+      channel.once("close", onClose);
+      channel.once("error", onError);
       try {
-        cb(err);
+        close();
       } catch {
+        finish(false);
       }
+    });
+  }
+  /** Hard transport reset used only when a channel cannot prove it closed.
+   * Every operation on that transport is rejected before we return, and a
+   * later operation must establish a fresh connection. */
+  async forceResetTransport(client, cause) {
+    if (this.client !== client) return;
+    this.client = null;
+    this.connecting = null;
+    this.sftpChannel = null;
+    this.sftpWrapper = null;
+    if (this.reverseListenerClient === client) this.reverseListenerClient = null;
+    this.rejectInflight(
+      new SshDisconnectedError(`SSH connection reset to quiesce an operation: ${cause.message}`)
+    );
+    let closed = false;
+    const closePromise = new Promise((resolve) => {
+      const done = () => {
+        if (closed) return;
+        closed = true;
+        resolve();
+      };
+      client.once("close", done);
+      client.once("end", done);
+    });
+    try {
+      client.end();
+    } catch {
     }
+    try {
+      client.destroy();
+    } catch {
+    }
+    await Promise.race([
+      closePromise,
+      new Promise((resolve) => {
+        const timer = setTimeout(resolve, TRANSPORT_CLOSE_GRACE_MS);
+        timer.unref?.();
+      })
+    ]);
+  }
+  quiesceSftp(client, wrapper, cause) {
+    if (wrapper) {
+      const existing = this.sftpQuiescence.get(wrapper);
+      if (existing) return existing;
+    }
+    const quiescence = this.quiesceSftpOnce(client, wrapper, cause);
+    if (wrapper) this.sftpQuiescence.set(wrapper, quiescence);
+    return quiescence;
+  }
+  async quiesceSftpOnce(client, wrapper, cause) {
+    if (!wrapper || this.sftpWrapper === wrapper) {
+      this.sftpChannel = null;
+      this.sftpWrapper = null;
+    }
+    if (wrapper) {
+      const closed = await this.waitForChannelClose(wrapper, () => wrapper.end());
+      if (closed) return;
+    }
+    await this.forceResetTransport(client, cause);
+  }
+  awaitSftpOpen(opening, client) {
+    const signal = this.operationSignal();
+    this.throwIfAborted("SFTP channel open", signal);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let terminating = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.inflight.delete(abort);
+        signal?.removeEventListener("abort", onSignalAbort);
+      };
+      const finish = (act) => {
+        if (settled || terminating) return;
+        settled = true;
+        cleanup();
+        act();
+      };
+      const terminate = (error) => {
+        if (settled || terminating) return;
+        terminating = true;
+        cleanup();
+        const settle = () => {
+          settled = true;
+          reject(error);
+        };
+        void this.forceResetTransport(client, error).then(settle, settle);
+      };
+      const abort = (error) => terminate(error);
+      const onSignalAbort = () => terminate(abortError("SFTP channel open", signal));
+      const timer = setTimeout(
+        () => terminate(new Error(`SFTP channel open timed out after ${SFTP_OPERATION_TIMEOUT_MS}ms`)),
+        SFTP_OPERATION_TIMEOUT_MS
+      );
+      timer.unref?.();
+      this.inflight.add(abort);
+      signal?.addEventListener("abort", onSignalAbort, { once: true });
+      if (signal?.aborted) {
+        onSignalAbort();
+        return;
+      }
+      opening.then(
+        (wrapper) => finish(() => resolve(wrapper)),
+        (error) => finish(() => reject(error))
+      );
+    });
   }
   /**
    * One SFTP subsystem channel per client, opened lazily and shared by every
@@ -344,26 +553,39 @@ var SshExecutor = class _SshExecutor {
    */
   async sftp() {
     const client = await this.connect();
-    if (this.sftpChannel) return this.sftpChannel;
+    this.throwIfAborted("SFTP channel open");
+    if (this.sftpChannel) return this.awaitSftpOpen(this.sftpChannel, client);
     const opening = openSftp(client).then((wrapper) => {
+      if (this.client !== client || this.sftpChannel !== opening) {
+        try {
+          wrapper.end();
+        } catch {
+        }
+        throw new SshDisconnectedError("SFTP channel opened after its SSH transport was reset");
+      }
       const drop = () => {
-        if (this.sftpChannel === opening) this.sftpChannel = null;
+        if (this.sftpChannel === opening) {
+          this.sftpChannel = null;
+          this.sftpWrapper = null;
+        }
       };
       wrapper.once("close", drop);
       wrapper.once("error", drop);
+      this.sftpWrapper = wrapper;
       return wrapper;
     });
     opening.catch(() => {
       if (this.sftpChannel === opening) this.sftpChannel = null;
     });
     this.sftpChannel = opening;
-    return opening;
+    return this.awaitSftpOpen(opening, client);
   }
   /** Close + forget the shared SFTP channel (frees its session) without
    *  touching the SSH client, so file ops can reopen on the same connection. */
   dropSftp() {
     const ch = this.sftpChannel;
     this.sftpChannel = null;
+    this.sftpWrapper = null;
     if (ch) ch.then((w) => {
       try {
         w.end();
@@ -382,6 +604,10 @@ var SshExecutor = class _SshExecutor {
         this.client.end();
       } catch {
       }
+      try {
+        this.client.destroy();
+      } catch {
+      }
       this.client = null;
     }
     this.connecting = null;
@@ -398,25 +624,28 @@ var SshExecutor = class _SshExecutor {
     if (this.inflight.size > 0) this.dropSftp();
     else this.resetConnection();
   }
-  /** Returns true if the error is an SSH channel-open failure. */
+  /** Returns true if the error is an SSH channel-open or channel-exec failure. */
   static isChannelError(err) {
     if (!(err instanceof Error)) return false;
+    if (isSshExecRequestError(err)) return true;
     const msg = err.message.toLowerCase();
     return msg.includes("channel open failure") || msg.includes("open failed");
   }
   /**
    * Run an operation, and if it fails opening an SSH channel on a half-dead
    * cached connection ("Channel open failure: open failed" — common after the
-   * idle timeout drops the socket), drop the connection and retry ONCE on a
-   * fresh one. This is why `exec` survives a stale connection; the SFTP-based
-   * ops (writeFile/readFile/exists) must go through it too, or a deploy's route
+   * idle timeout drops the socket), recover channel capacity and retry ONCE.
+   * An idle connection is replaced; a busy one stays alive so its other command
+   * is not aborted (see recoverFromChannelError). The SFTP-based ops
+   * (writeFile/readFile/exists) must go through this too, or a deploy's route
    * write fails spuriously and only succeeds on a manual redeploy.
    */
   async withChannelRetry(fn) {
+    this.throwIfAborted("operation");
     try {
       return await fn();
     } catch (err) {
-      if (_SshExecutor.isChannelError(err)) {
+      if (_SshExecutor.isChannelError(err) && !this.operationSignal()?.aborted) {
         this.recoverFromChannelError();
         return fn();
       }
@@ -431,26 +660,65 @@ var SshExecutor = class _SshExecutor {
   async _exec(command, opts) {
     const client = await this.connect();
     const timeout = opts?.timeout ?? 3e4;
+    const signal = this.operationSignal();
+    this.throwIfAborted("command", signal);
     return new Promise((resolve, reject) => {
       let settled = false;
+      let terminating = false;
       let timer = null;
-      const abort = (err) => finish(() => reject(err));
-      const finish = (act) => {
-        if (settled) return;
-        settled = true;
+      let channel = null;
+      const cleanup = () => {
         if (timer) clearTimeout(timer);
         this.inflight.delete(abort);
+        signal?.removeEventListener("abort", onSignalAbort);
+      };
+      const finish = (act) => {
+        if (settled || terminating) return;
+        settled = true;
+        cleanup();
         act();
       };
+      const terminate = (error) => {
+        if (settled || terminating) return;
+        terminating = true;
+        cleanup();
+        const quiesce = (async () => {
+          if (channel) {
+            const closed = await this.waitForChannelClose(channel, () => channel.close());
+            if (!closed) await this.forceResetTransport(client, error);
+          } else {
+            await this.forceResetTransport(client, error);
+          }
+        })();
+        const settle = () => {
+          settled = true;
+          reject(error);
+        };
+        void quiesce.then(settle, settle);
+      };
+      const abort = (err) => terminate(err);
+      const onSignalAbort = () => terminate(abortError("command", signal));
       this.inflight.add(abort);
+      signal?.addEventListener("abort", onSignalAbort, { once: true });
+      if (signal?.aborted) {
+        onSignalAbort();
+        return;
+      }
       timer = setTimeout(
-        () => finish(
-          () => reject(new Error(`Command timed out after ${timeout}ms: ${commandForError(command)}`))
-        ),
+        () => terminate(new Error(`Command timed out after ${timeout}ms: ${commandForError(command)}`)),
         timeout
       );
+      timer.unref?.();
       client.exec(_SshExecutor.ENV_PREFIX + command, (err, stream) => {
-        if (err) return finish(() => reject(err));
+        if (err) return finish(() => reject(tagExecRequestError(err)));
+        channel = stream;
+        if (terminating) {
+          try {
+            stream.close();
+          } catch {
+          }
+          return;
+        }
         let stdout = "";
         let stderr = "";
         stream.on("data", (data) => {
@@ -459,6 +727,7 @@ var SshExecutor = class _SshExecutor {
         stream.stderr.on("data", (data) => {
           stderr += data.toString();
         });
+        stream.on("error", (error) => finish(() => reject(error)));
         stream.on("close", (code) => {
           finish(() => {
             if (code !== 0) {
@@ -471,10 +740,11 @@ var SshExecutor = class _SshExecutor {
     });
   }
   streamExec(command, onLog, opts) {
-    return this._streamExec(command, onLog, opts).catch((err) => {
-      if (_SshExecutor.isChannelError(err)) {
+    const scopedOpts = { ...opts, signal: this.resolvedSignal(opts?.signal) };
+    return this._streamExec(command, onLog, scopedOpts).catch((err) => {
+      if (_SshExecutor.isChannelError(err) && !scopedOpts.signal?.aborted) {
         this.recoverFromChannelError();
-        return this._streamExec(command, onLog, opts);
+        return this._streamExec(command, onLog, scopedOpts);
       }
       throw err;
     });
@@ -484,33 +754,56 @@ var SshExecutor = class _SshExecutor {
     const signal = opts?.signal;
     return new Promise((resolve, reject) => {
       let settled = false;
+      let terminating = false;
       const chunks = [];
-      const abort = (err) => finish(() => reject(err));
-      const finish = (act) => {
-        if (settled) return;
-        settled = true;
+      let channel = null;
+      const cleanup = () => {
         this.inflight.delete(abort);
         signal?.removeEventListener("abort", onSignalAbort);
+      };
+      const finish = (act) => {
+        if (settled || terminating) return;
+        settled = true;
+        cleanup();
         act();
       };
-      this.inflight.add(abort);
-      let channel = null;
-      const onSignalAbort = () => {
-        finish(() => resolve({ code: 0, output: chunks.join("") }));
-        try {
-          channel?.close();
-        } catch {
-        }
+      const terminate = (error, intentional) => {
+        if (settled || terminating) return;
+        terminating = true;
+        cleanup();
+        const quiesce = (async () => {
+          if (channel) {
+            const closed = await this.waitForChannelClose(channel, () => channel.close());
+            if (!closed) await this.forceResetTransport(client, error);
+          } else {
+            await this.forceResetTransport(client, error);
+          }
+        })();
+        const settle = () => {
+          settled = true;
+          if (intentional) resolve({ code: 0, output: chunks.join("") });
+          else reject(error);
+        };
+        void quiesce.then(settle, settle);
       };
+      const abort = (err) => terminate(err, false);
+      const onSignalAbort = () => terminate(abortError("streaming command", signal), true);
+      this.inflight.add(abort);
+      signal?.addEventListener("abort", onSignalAbort, { once: true });
       if (signal?.aborted) {
-        finish(() => resolve({ code: 0, output: "" }));
+        onSignalAbort();
         return;
       }
       client.exec(_SshExecutor.ENV_PREFIX + command, (err, stream) => {
-        if (err) return finish(() => reject(err));
+        if (err) return finish(() => reject(tagExecRequestError(err)));
         channel = stream;
-        if (signal?.aborted) return onSignalAbort();
-        signal?.addEventListener("abort", onSignalAbort, { once: true });
+        if (terminating || signal?.aborted) {
+          try {
+            stream.close();
+          } catch {
+          }
+          return;
+        }
         const onChunk = (data, level) => {
           const text = data.toString();
           if (!text) return;
@@ -519,6 +812,7 @@ var SshExecutor = class _SshExecutor {
         };
         stream.on("data", (data) => onChunk(data, "info"));
         stream.stderr.on("data", (data) => onChunk(data, "warn"));
+        stream.on("error", (error) => finish(() => reject(error)));
         let exitCode = null;
         stream.on("exit", (code) => {
           exitCode = code;
@@ -540,7 +834,62 @@ var SshExecutor = class _SshExecutor {
       });
     });
   }
-  async writeFile(path, content) {
+  /** Turn ssh2's callback-only SFTP request into a bounded operation.  A lost
+   * callback used to leave the compose deploy promise and its host mutex tail
+   * pending forever.  Cancellation/timeout closes the shared subsystem first;
+   * if close itself wedges, the parent SSH transport is destroyed before this
+   * promise rejects. */
+  runSftpRequest(client, sftp, operation, start) {
+    const signal = this.operationSignal();
+    this.throwIfAborted(operation, signal);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let terminating = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.inflight.delete(abort);
+        signal?.removeEventListener("abort", onSignalAbort);
+      };
+      const finish = (act) => {
+        if (settled || terminating) return;
+        settled = true;
+        cleanup();
+        act();
+      };
+      const terminate = (error) => {
+        if (settled || terminating) return;
+        terminating = true;
+        cleanup();
+        const settle = () => {
+          settled = true;
+          reject(error);
+        };
+        void this.quiesceSftp(client, sftp, error).then(settle, settle);
+      };
+      const abort = (error) => terminate(error);
+      const onSignalAbort = () => terminate(abortError(operation, signal));
+      const timer = setTimeout(
+        () => terminate(new Error(`${operation} timed out after ${SFTP_OPERATION_TIMEOUT_MS}ms`)),
+        SFTP_OPERATION_TIMEOUT_MS
+      );
+      timer.unref?.();
+      this.inflight.add(abort);
+      signal?.addEventListener("abort", onSignalAbort, { once: true });
+      if (signal?.aborted) {
+        onSignalAbort();
+        return;
+      }
+      try {
+        start((error, value) => {
+          if (error) finish(() => reject(error));
+          else finish(() => resolve(value));
+        });
+      } catch (error) {
+        finish(() => reject(error));
+      }
+    });
+  }
+  async writeFile(path, content, opts) {
     const dir = remoteDirname(path);
     try {
       await this.exec(`mkdir -p ${sq(dir)}`);
@@ -548,12 +897,21 @@ var SshExecutor = class _SshExecutor {
     }
     return this.withChannelRetry(async () => {
       const sftp = await this.sftp();
-      return new Promise((resolve, reject) => {
-        sftp.writeFile(path, content, { encoding: "utf-8" }, (err) => {
-          if (err) reject(err);
-          else resolve();
-        });
+      const client = this.client;
+      if (!client) throw new SshDisconnectedError("SSH connection lost before SFTP write");
+      const write = (data, mode) => this.runSftpRequest(client, sftp, `SFTP write ${path}`, (done) => {
+        sftp.writeFile(path, data, { encoding: "utf-8", mode }, (err) => done(err));
       });
+      const chmod2 = (mode) => this.runSftpRequest(client, sftp, `SFTP chmod ${path}`, (done) => {
+        sftp.chmod(path, mode, (err) => done(err));
+      });
+      if (opts?.mode !== void 0) {
+        await write("", opts.mode);
+        await chmod2(opts.mode);
+        await write(content);
+      } else {
+        await write(content);
+      }
     });
   }
   async rename(from, to) {
@@ -562,10 +920,11 @@ var SshExecutor = class _SshExecutor {
   async readFile(path) {
     return this.withChannelRetry(async () => {
       const sftp = await this.sftp();
-      return new Promise((resolve, reject) => {
+      const client = this.client;
+      if (!client) throw new SshDisconnectedError("SSH connection lost before SFTP read");
+      return this.runSftpRequest(client, sftp, `SFTP read ${path}`, (done) => {
         sftp.readFile(path, { encoding: "utf-8" }, (err, data) => {
-          if (err) reject(err);
-          else resolve(data.toString());
+          done(err, data?.toString());
         });
       });
     });
@@ -573,9 +932,11 @@ var SshExecutor = class _SshExecutor {
   async exists(path) {
     return this.withChannelRetry(async () => {
       const sftp = await this.sftp();
-      return new Promise((resolve) => {
+      const client = this.client;
+      if (!client) throw new SshDisconnectedError("SSH connection lost before SFTP stat");
+      return this.runSftpRequest(client, sftp, `SFTP stat ${path}`, (done) => {
         sftp.stat(path, (err) => {
-          resolve(!err);
+          done(null, !err);
         });
       });
     });
@@ -833,6 +1194,7 @@ var SshExecutor = class _SshExecutor {
   async dispose() {
     this.connecting = null;
     this.sftpChannel = null;
+    this.sftpWrapper = null;
     this.reverseHandlers.clear();
     this.reverseListenerClient = null;
     if (this.client) {
@@ -976,6 +1338,7 @@ var SshExecutor = class _SshExecutor {
 };
 
 // ../../packages/adapters/src/system/system-ssh-executor.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import { execFile as execFile2, spawn as spawn2 } from "child_process";
 import { once } from "events";
 import { mkdtemp as mkdtemp3, rm as fsRm3, stat as stat2, unlink } from "fs/promises";
@@ -1090,6 +1453,13 @@ async function openSystemSshReverseTunnel(opts) {
 // ../../packages/adapters/src/system/system-ssh-executor.ts
 var execFileAsync2 = promisify2(execFile2);
 var remoteDirname2 = posix2.dirname;
+function abortError2(operation, signal) {
+  const reason = signal.reason;
+  const suffix = reason instanceof Error && reason.message ? `: ${reason.message}` : "";
+  const error = new Error(`SSH ${operation} cancelled${suffix}`);
+  error.name = "AbortError";
+  return error;
+}
 function clampWindow2(value, fallback, min, max) {
   if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
   return Math.max(min, Math.min(max, Math.floor(value)));
@@ -1103,6 +1473,7 @@ function describeSshFailure(stderr, fallback) {
 }
 var SystemSshExecutor = class _SystemSshExecutor {
   config;
+  abortScope = new AsyncLocalStorage2();
   controlPath = makeControlPath();
   /** Resolves once the ControlMaster connection is established. */
   masterPromise = null;
@@ -1119,6 +1490,25 @@ var SystemSshExecutor = class _SystemSshExecutor {
     }
     this.config = config;
   }
+  runWithAbortSignal(signal, fn) {
+    if (signal.aborted) return Promise.reject(abortError2("operation", signal));
+    return this.abortScope.run(signal, async () => {
+      this.throwIfAborted("operation");
+      return fn();
+    });
+  }
+  operationSignal() {
+    return this.abortScope.getStore();
+  }
+  resolvedSignal(explicit) {
+    const ambient = this.operationSignal();
+    if (!explicit || explicit === ambient) return ambient ?? explicit;
+    if (!ambient) return explicit;
+    return AbortSignal.any([explicit, ambient]);
+  }
+  throwIfAborted(operation, signal = this.operationSignal()) {
+    if (signal?.aborted) throw abortError2(operation, signal);
+  }
   baseArgs() {
     return buildBaseSshArgs(this.config, this.controlPath);
   }
@@ -1199,7 +1589,10 @@ var SystemSshExecutor = class _SystemSshExecutor {
   }
   /** Run a remote command, resolving with stdout/stderr/exit code (never rejects on non-zero). */
   async runSsh(remoteCommand, opts) {
+    const signal = this.operationSignal();
+    this.throwIfAborted("command", signal);
     await this.ensureMaster();
+    this.throwIfAborted("command", signal);
     return new Promise((resolve, reject) => {
       const child = spawn2("ssh", [...this.baseArgs(), sshTarget(this.config), remoteCommand], {
         env: sshChildEnv(this.config),
@@ -1208,7 +1601,25 @@ var SystemSshExecutor = class _SystemSshExecutor {
       let stdout = "";
       let stderr = "";
       let timedOut = false;
+      let settled = false;
       let timer = null;
+      const cleanup = () => {
+        if (timer) clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const finish = (act) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        act();
+      };
+      const onAbort = () => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
       if (opts?.timeout) {
         timer = setTimeout(() => {
           timedOut = true;
@@ -1223,16 +1634,21 @@ var SystemSshExecutor = class _SystemSshExecutor {
         stderr += d.toString();
       });
       child.on("error", (e) => {
-        if (timer) clearTimeout(timer);
-        reject(new Error(`ssh failed to start: ${e.message}`));
+        finish(() => reject(new Error(`ssh failed to start: ${e.message}`)));
       });
       child.on("close", (code) => {
-        if (timer) clearTimeout(timer);
         const c = code ?? 1;
         void this.maybeSignalDisconnect(c).catch(() => {
         });
-        resolve({ stdout, stderr, code: c, timedOut });
+        finish(() => {
+          if (signal?.aborted) reject(abortError2("command", signal));
+          else resolve({ stdout, stderr, code: c, timedOut });
+        });
       });
+      if (signal?.aborted) {
+        onAbort();
+        return;
+      }
       if (opts?.input !== void 0) {
         child.stdin.write(opts.input);
       }
@@ -1253,7 +1669,7 @@ var SystemSshExecutor = class _SystemSshExecutor {
   }
   async streamExec(command, onLog, opts) {
     await this.ensureMaster();
-    const signal = opts?.signal;
+    const signal = this.resolvedSignal(opts?.signal);
     if (signal?.aborted) return { code: 0, output: "" };
     return new Promise((resolve) => {
       const child = spawn2(
@@ -1290,8 +1706,10 @@ var SystemSshExecutor = class _SystemSshExecutor {
       });
     });
   }
-  async writeFile(path, content) {
-    const remoteCommand = `mkdir -p ${sq(remoteDirname2(path))} && cat > ${sq(path)}`;
+  async writeFile(path, content, opts) {
+    const target = sq(path);
+    const prepare = opts?.mode === void 0 ? `cat > ${target}` : `: > ${target} && chmod ${opts.mode.toString(8)} ${target} && cat > ${target}`;
+    const remoteCommand = `mkdir -p ${sq(remoteDirname2(path))} && ${prepare}`;
     const res = await this.runSsh(remoteCommand, { input: content });
     if (res.code !== 0) {
       throw new Error(res.stderr.trim() || `Failed to write ${path} (exit ${res.code})`);
@@ -1691,7 +2109,7 @@ async function verifyHostChannelAuth(config) {
   let hint = null;
   let forwarding = "unknown";
   try {
-    const { connectSshClient: connectSshClient2 } = await import("./ssh-client-2XWZCMGI.js");
+    const { connectSshClient: connectSshClient2 } = await import("./ssh-client-FZDWP5PQ.js");
     const client = await connectSshClient2({
       host: config.host,
       port: config.port,