@rakay-technology/kraft 0.7.4

package/dist/chunk-MOLPYPVH.js

@@ -0,0 +1,2529 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  probeTcpDetailed
+} from "./chunk-ZVFS4LUA.js";
+import {
+  getTarCreateEnv,
+  prepareSourceTarArgs
+} from "./chunk-XGCG4MD5.js";
+import {
+  connectSshClient,
+  openDockerDialStdioChannel,
+  openSftp,
+  openSshUnixSocket,
+  reconcileKnownHosts
+} from "./chunk-HMJUFZK7.js";
+import {
+  LocalExecutor
+} from "./chunk-XVKUFMIB.js";
+import {
+  HostChannelUnavailableError,
+  SshDisconnectedError,
+  SshExecRequestError,
+  commandForError,
+  isSshAuthError,
+  isSshExecRequestError
+} from "./chunk-3CJLKL6E.js";
+import {
+  emitBufferedLines,
+  flushBufferedLines,
+  hasLocalCommand,
+  logEntry,
+  sq
+} from "./chunk-MNV2QFHW.js";
+import {
+  HOST_CHANNEL_AUTH_REJECTED,
+  HOST_CHANNEL_NOT_PROVISIONED,
+  HOST_CHANNEL_UNPROVISIONED,
+  TRANSFER_EXCLUDES,
+  explainHostChannelCause,
+  formatBytes,
+  hostChannelAccount,
+  hostFirewallRule,
+  safeErrorMessage
+} from "./chunk-PVOWHIND.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";
+import { join as join2, posix } from "path";
+
+// ../../packages/adapters/src/system/remote-transfer.ts
+import { spawn } from "child_process";
+import { createWriteStream } from "fs";
+import {
+  chmod,
+  mkdtemp,
+  rm as fsRm,
+  writeFile as fsWriteFile
+} from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+function packLocalArchive(tarArgs, outFile) {
+  return new Promise((resolve, reject) => {
+    const tar = spawn("tar", tarArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: getTarCreateEnv()
+    });
+    const out = createWriteStream(outFile);
+    let stderr = "";
+    let tarCode = null;
+    let tarClosed = false;
+    let outClosed = false;
+    const settle = () => {
+      if (!tarClosed || !outClosed) return;
+      if (tarCode === 0) resolve();
+      else
+        reject(
+          new Error(
+            `tar failed (exit ${tarCode})${stderr.trim() ? `: ${stderr.trim().slice(-300)}` : ""}`
+          )
+        );
+    };
+    tar.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    tar.on("error", reject);
+    out.on("error", reject);
+    tar.stdout.pipe(out);
+    tar.on("close", (code) => {
+      tarCode = code ?? 1;
+      tarClosed = true;
+      settle();
+    });
+    out.on("finish", () => {
+      outClosed = true;
+      settle();
+    });
+  });
+}
+async function extractRemoteArchive(exec, remoteArchive, remotePath, expectedBytes, onLog) {
+  const received = Number((await exec(`wc -c < ${sq(remoteArchive)}`)).trim());
+  if (received !== expectedBytes) {
+    await exec(`rm -f ${sq(remoteArchive)}`).catch(() => {
+    });
+    throw new Error(
+      `upload truncated: sent ${expectedBytes} bytes, server received ${received}`
+    );
+  }
+  await exec(
+    `mkdir -p ${sq(remotePath)} && tar xzf ${sq(remoteArchive)} -C ${sq(remotePath)}; rc=$?; rm -f ${sq(remoteArchive)}; exit $rc`
+  );
+  onLog?.(
+    logEntry(
+      `Transferred ${formatBytes(expectedBytes)} and extracted on the server.`
+    )
+  );
+}
+function formatPrivateKeyForOpenSsh(privateKey) {
+  const normalized = privateKey.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
+  return normalized.endsWith("\n") ? normalized : `${normalized}
+`;
+}
+async function canUseRemoteRsync(deps) {
+  if (deps.config.privateKey && deps.config.privateKeyPassphrase && !deps.config.sshAgent) {
+    return {
+      ok: false,
+      reason: "encrypted SSH keys without an agent are not supported by non-interactive rsync"
+    };
+  }
+  const [localRsync, localSsh, localSshpass, remoteRsync] = await Promise.all([
+    hasLocalCommand("rsync"),
+    hasLocalCommand("ssh"),
+    deps.config.password ? hasLocalCommand("sshpass") : Promise.resolve(true),
+    deps.hasRemoteCommand("rsync")
+  ]);
+  if (!localRsync) return { ok: false, reason: "local rsync is not installed" };
+  if (!localSsh) return { ok: false, reason: "local ssh is not installed" };
+  if (!localSshpass)
+    return {
+      ok: false,
+      reason: "local sshpass is not installed for password-based rsync"
+    };
+  if (!remoteRsync)
+    return { ok: false, reason: "remote rsync is not installed" };
+  return { ok: true };
+}
+function buildRsyncSshCommand(config, keyPath) {
+  const args = config.password ? [
+    "sshpass",
+    "-e",
+    "ssh",
+    "-p",
+    String(config.port ?? 22),
+    "-o",
+    "NumberOfPasswordPrompts=1",
+    "-o",
+    "PreferredAuthentications=password,keyboard-interactive",
+    "-o",
+    "PubkeyAuthentication=no",
+    "-o",
+    "StrictHostKeyChecking=accept-new"
+  ] : [
+    "ssh",
+    "-p",
+    String(config.port ?? 22),
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "StrictHostKeyChecking=accept-new"
+  ];
+  if (config.sshAgent) {
+    args.push("-A");
+  }
+  if (keyPath) {
+    args.push("-i", keyPath, "-o", "IdentitiesOnly=yes");
+  }
+  return args.map(sq).join(" ");
+}
+async function withTemporaryPrivateKey(config, fn) {
+  if (!config.privateKey || config.sshAgent) {
+    return fn();
+  }
+  const tempDir = await mkdtemp(join(tmpdir(), "kraft-rsync-key-"));
+  const keyPath = join(tempDir, "id_rsa");
+  try {
+    await fsWriteFile(keyPath, formatPrivateKeyForOpenSsh(config.privateKey), {
+      mode: 384
+    });
+    await chmod(keyPath, 384);
+    return await fn(keyPath);
+  } finally {
+    await fsRm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function runRsync(config, args, onLog, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("rsync", args, {
+      cwd,
+      env: {
+        ...getTarCreateEnv(),
+        ...config.password ? { SSHPASS: config.password } : {}
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutState = { partial: "" };
+    const stderrState = { partial: "" };
+    proc.stdout.on("data", (chunk) => {
+      emitBufferedLines(chunk, stdoutState, (line) => onLog?.(logEntry(line)));
+    });
+    proc.stderr.on("data", (chunk) => {
+      emitBufferedLines(chunk, stderrState, (line) => onLog?.(logEntry(line)));
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`rsync failed to start: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      flushBufferedLines(stdoutState, (line) => onLog?.(logEntry(line)));
+      flushBufferedLines(stderrState, (line) => onLog?.(logEntry(line)));
+      resolve({ code: code ?? 1 });
+    });
+  });
+}
+async function uploadFileWithRsync(localFile, remoteFile, deps, onLog, opts) {
+  await reconcileKnownHosts(deps.config);
+  const retries = Math.max(1, opts?.retries ?? 3);
+  const host = deps.config.host.includes(":") ? `[${deps.config.host}]` : deps.config.host;
+  const user = deps.config.username ?? "root";
+  const target = `${user}@${host}:${remoteFile}`;
+  await withTemporaryPrivateKey(deps.config, async (keyPath) => {
+    let lastCode = 1;
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      if (attempt > 1) {
+        onLog?.(
+          logEntry(
+            `Connection dropped \u2014 resuming upload (attempt ${attempt}/${retries})...`,
+            "warn"
+          )
+        );
+      }
+      const args = [
+        "-a",
+        // already gzipped, so no `-z`
+        "--partial",
+        // keep the partial on interruption; delta-resume on re-run
+        "--progress",
+        "--timeout=60",
+        // abort if no I/O for 60s → surfaces a stall as a retryable exit
+        "-e",
+        buildRsyncSshCommand(deps.config, keyPath),
+        localFile,
+        target
+      ];
+      const { code } = await runRsync(deps.config, args, onLog);
+      if (code === 0) return;
+      lastCode = code;
+    }
+    throw new Error(
+      `rsync upload failed after ${retries} attempt(s) (exit ${lastCode})`
+    );
+  });
+}
+
+// ../../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)));
+}
+var SshExecutor = class _SshExecutor {
+  client = null;
+  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/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). */
+  reverseHandlers = /* @__PURE__ */ new Map();
+  /** The client the single 'tcp connection' dispatcher is attached to (re-attached on reconnect). */
+  reverseListenerClient = null;
+  constructor(config) {
+    if (!config.privateKey && !config.sshAgent && !config.password) {
+      throw new Error("SSH requires one of privateKey, sshAgent, or password.");
+    }
+    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) {
+      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());
+      client.on("end", () => onTransportDown());
+      client.on("error", (err) => onTransportDown(err));
+      this.client = client;
+      return client;
+    })();
+    this.connecting = attempt;
+    const clearMemo = () => {
+      if (this.connecting === attempt) this.connecting = null;
+    };
+    attempt.then(clearMemo, clearMemo);
+    return this.awaitConnection(attempt);
+  }
+  /**
+   * Subscribe to transport-level disconnects. Returns an unsubscribe fn.
+   */
+  onDisconnect(cb) {
+    this.disconnectListeners.add(cb);
+    return () => {
+      this.disconnectListeners.delete(cb);
+    };
+  }
+  /**
+   * The transport died. Reject every in-flight exec/stream with a typed
+   * SshDisconnectedError — so they fail in <1s instead of hanging to their
+   * per-command timeout on a dead channel — then notify subscribers so the
+   * manager can reconnect / re-drive journaled ops.
+   */
+  handleDisconnect(cause) {
+    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) {
+      try {
+        abort(err);
+      } catch {
+      }
+    }
+  }
+  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 {
+        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
+   * file op. ssh2's SFTPWrapper pipelines many concurrent requests over a
+   * single channel, so file operations cost exactly ONE session against the
+   * server's MaxSessions — not one channel per op, which leaks and exhausts
+   * the quota, then takes down the whole connection (incl. a live build) on
+   * the next channel-open failure (#34). Self-clears on the channel's own
+   * close/error and on resetConnection/dispose so the next op reopens clean.
+   */
+  async sftp() {
+    const client = await this.connect();
+    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;
+          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 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();
+        } catch {
+        }
+      }).catch(() => {
+      });
+  }
+  /**
+   * Force-close the current connection so the next call reconnects.
+   */
+  resetConnection() {
+    this.dropSftp();
+    if (this.client) {
+      try {
+        this.client.end();
+      } catch {
+      }
+      try {
+        this.client.destroy();
+      } catch {
+      }
+      this.client = null;
+    }
+    this.connecting = null;
+  }
+  /**
+   * Recover from a channel-open failure without killing live work. If other
+   * ops are still streaming on this connection (a docker build, an exec), the
+   * failure is session pressure — NOT a dead socket — so ending the client
+   * would abort that in-flight command (#34). Free the SFTP channel and keep
+   * the connection. With nothing in flight the cached socket is stale (idle
+   * drop), so reset it fully.
+   */
+  recoverFromChannelError() {
+    if (this.inflight.size > 0) this.dropSftp();
+    else this.resetConnection();
+  }
+  /** 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), 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) && !this.operationSignal()?.aborted) {
+        this.recoverFromChannelError();
+        return fn();
+      }
+      throw err;
+    }
+  }
+  async exec(command, opts) {
+    return this.withChannelRetry(() => this._exec(command, opts));
+  }
+  /** Prefix applied to every SSH command - keeps dpkg non-interactive. */
+  static ENV_PREFIX = "export DEBIAN_FRONTEND=noninteractive DPKG_FORCE=confnew && ";
+  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;
+      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(
+        () => 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(tagExecRequestError(err)));
+        channel = stream;
+        if (terminating) {
+          try {
+            stream.close();
+          } catch {
+          }
+          return;
+        }
+        let stdout = "";
+        let stderr = "";
+        stream.on("data", (data) => {
+          stdout += data.toString();
+        });
+        stream.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+        stream.on("error", (error) => finish(() => reject(error)));
+        stream.on("close", (code) => {
+          finish(() => {
+            if (code !== 0) {
+              const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+              reject(new Error(detail || `Exit code ${code}`));
+            } else resolve(stdout.trim());
+          });
+        });
+      });
+    });
+  }
+  streamExec(command, onLog, opts) {
+    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, scopedOpts);
+      }
+      throw err;
+    });
+  }
+  async _streamExec(command, onLog, opts) {
+    const client = await this.connect();
+    const signal = opts?.signal;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let terminating = false;
+      const chunks = [];
+      let channel = null;
+      const cleanup = () => {
+        this.inflight.delete(abort);
+        signal?.removeEventListener("abort", onSignalAbort);
+      };
+      const finish = (act) => {
+        if (settled || terminating) return;
+        settled = true;
+        cleanup();
+        act();
+      };
+      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) {
+        onSignalAbort();
+        return;
+      }
+      client.exec(_SshExecutor.ENV_PREFIX + command, (err, stream) => {
+        if (err) return finish(() => reject(tagExecRequestError(err)));
+        channel = stream;
+        if (terminating || signal?.aborted) {
+          try {
+            stream.close();
+          } catch {
+          }
+          return;
+        }
+        const onChunk = (data, level) => {
+          const text = data.toString();
+          if (!text) return;
+          chunks.push(text);
+          onLog(logEntry(text, level, data.toString("base64")));
+        };
+        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;
+        });
+        stream.on("close", (code) => {
+          finish(() => {
+            const final = typeof code === "number" ? code : exitCode;
+            if (final == null) {
+              reject(
+                new Error(
+                  "remote channel closed without an exit status \u2014 the SSH connection or channel was terminated mid-command"
+                )
+              );
+            } else {
+              resolve({ code: final, output: chunks.join("") });
+            }
+          });
+        });
+      });
+    });
+  }
+  /** 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)}`);
+    } catch {
+    }
+    return this.withChannelRetry(async () => {
+      const sftp = await this.sftp();
+      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) {
+    await this.exec(`mv ${sq(from)} ${sq(to)}`);
+  }
+  async readFile(path) {
+    return this.withChannelRetry(async () => {
+      const sftp = await this.sftp();
+      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) => {
+            done(err, data?.toString());
+          });
+        }
+      );
+    });
+  }
+  async exists(path) {
+    return this.withChannelRetry(async () => {
+      const sftp = await this.sftp();
+      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) => {
+            done(null, !err);
+          });
+        }
+      );
+    });
+  }
+  async mkdir(path) {
+    await this.exec(`mkdir -p ${sq(path)}`);
+  }
+  async rm(path) {
+    try {
+      await this.exec(`rm -rf ${sq(path)}`);
+    } catch {
+    }
+  }
+  rawExec(command) {
+    return (async () => {
+      const client = await this.connect();
+      return new Promise((resolve, reject) => {
+        client.exec(command, (err, stream) => {
+          if (err) return reject(err);
+          const onClose = new Promise((res) => {
+            stream.on("close", (code) => res(code ?? 1));
+          });
+          resolve({
+            stdout: stream,
+            stderr: stream.stderr,
+            onClose,
+            kill: () => {
+              try {
+                stream.close();
+              } catch {
+              }
+            }
+          });
+        });
+      });
+    })();
+  }
+  /**
+   * Pipe `body` into a remote command's stdin over a raw ssh2 channel, half-
+   * closing stdin at EOF. The streaming inverse of rawExec: used to stream a
+   * `docker save` tar straight into `docker load` on another host without
+   * staging the (multi-GB) image to a temp file. Bounded stderr tail for
+   * diagnostics; registered for transport-drop abort like _exec/_streamExec.
+   */
+  execWithInput(command, body) {
+    return (async () => {
+      const client = await this.connect();
+      return new Promise(
+        (resolve, reject) => {
+          let settled = false;
+          const abort = (err) => finish(() => reject(err));
+          const finish = (act) => {
+            if (settled) return;
+            settled = true;
+            this.inflight.delete(abort);
+            act();
+          };
+          this.inflight.add(abort);
+          client.exec(command, (err, stream) => {
+            if (err) return finish(() => reject(err));
+            let stderr = "";
+            stream.stderr.on("data", (d) => {
+              stderr += d.toString();
+              if (stderr.length > 16 * 1024) stderr = stderr.slice(-16 * 1024);
+            });
+            let stdout = "";
+            stream.on("data", (d) => {
+              stdout += d.toString();
+              if (stdout.length > 16 * 1024) stdout = stdout.slice(-16 * 1024);
+            });
+            let exitCode = null;
+            stream.on("exit", (code) => {
+              exitCode = code;
+            });
+            stream.on("close", (code) => {
+              finish(() => {
+                const final = typeof code === "number" ? code : exitCode;
+                if (final == null) {
+                  reject(
+                    new Error(
+                      "remote channel closed without an exit status \u2014 the SSH connection was terminated mid-command"
+                    )
+                  );
+                } else {
+                  resolve({
+                    code: final,
+                    stderr: stderr.trim(),
+                    stdout: stdout.trim()
+                  });
+                }
+              });
+            });
+            body.on(
+              "error",
+              (e) => finish(() => {
+                try {
+                  stream.close();
+                } catch {
+                }
+                reject(e);
+              })
+            );
+            stream.on("error", (e) => finish(() => reject(e)));
+            body.pipe(stream);
+          });
+        }
+      );
+    })();
+  }
+  /**
+   * Open an interactive PTY shell on the remote host. The returned
+   * ShellSession wraps an ssh2 ClientChannel: writes go to stdin,
+   * stdout/stderr emit on the readable streams, setWindow forwards to
+   * channel.setWindow, close ends the channel. Lifetime is bound to the
+   * channel - the underlying ssh2.Client stays cached by sshManager, so
+   * callers must wrap with `sshManager.retain(serverId)` / `release()`
+   * to avoid the 5-minute idle drop on the parent connection.
+   */
+  async openShell(opts) {
+    const client = await this.connect();
+    const cols = clampWindow(opts?.cols, 80, 1, 1e3);
+    const rows = clampWindow(opts?.rows, 24, 1, 500);
+    const term = opts?.term || "xterm-256color";
+    const channel = await new Promise(
+      (resolve, reject) => {
+        client.shell(
+          { term, cols, rows, width: 0, height: 0, modes: {} },
+          (err, ch) => err ? reject(err) : resolve(ch)
+        );
+      }
+    );
+    const closeListeners = [];
+    let closed = false;
+    const fireClose = (code, signal) => {
+      if (closed) return;
+      closed = true;
+      for (const cb of closeListeners) {
+        try {
+          cb(code, signal);
+        } catch {
+        }
+      }
+    };
+    channel.on("exit", (code, signal) => {
+      fireClose(code, signal);
+    });
+    channel.on("close", () => fireClose(null));
+    channel.on("error", () => fireClose(null));
+    return {
+      stdin: channel,
+      stdout: channel,
+      stderr: channel.stderr,
+      setWindow: (c, r) => {
+        const sc = clampWindow(c, 80, 1, 1e3);
+        const sr = clampWindow(r, 24, 1, 500);
+        try {
+          channel.setWindow(sr, sc, 0, 0);
+        } catch {
+        }
+      },
+      close: (_signal) => {
+        try {
+          channel.end();
+        } catch {
+        }
+        try {
+          channel.close();
+        } catch {
+        }
+      },
+      onClose: (cb) => {
+        closeListeners.push(cb);
+      }
+    };
+  }
+  async forwardUnixSocket(socketPath) {
+    const client = await this.connect();
+    return openSshUnixSocket(client, socketPath);
+  }
+  /**
+   * Carry the Docker Engine API over a `docker system dial-stdio` exec channel
+   * on the pooled connection — the streamlocal-free transport used when the
+   * SSH server (or the Bun-compiled desktop runtime) can't do socket
+   * forwarding.
+   *
+   * Deliberately WITHOUT `ENV_PREFIX`: that prefix only exports apt's
+   * non-interactive variables (it sets no PATH, despite what the comment here
+   * used to claim), and the bridge's own ephemeral dial-stdio client opens the
+   * bare command. Two dial-stdio channels that differ by a shell prefix are two
+   * transports, and the bridge picks one by probing the other.
+   *
+   * Failure diagnostics (daemon down, socket permission, `docker: command not
+   * found`, an sshd ForceCommand banner) ride ON the returned channel — see
+   * `attachDialStdioDiagnostics`. They used to go to `console.warn` while the
+   * caller got a bare socket reset, which is how a host with no running dockerd
+   * reported itself as `socket hang up`.
+   */
+  async openDockerDialStdio() {
+    const client = await this.connect();
+    return openDockerDialStdioChannel(client);
+  }
+  async forwardPort(remoteHost, remotePort) {
+    const client = await this.connect();
+    return new Promise((resolve, reject) => {
+      client.forwardOut(
+        "127.0.0.1",
+        0,
+        remoteHost,
+        remotePort,
+        (err, stream) => {
+          if (err) return reject(err);
+          resolve(stream);
+        }
+      );
+    });
+  }
+  /**
+   * Open a reverse tunnel: the remote listens on an ephemeral 127.0.0.1 port
+   * and every connection to it is handed to `onConnection` as a duplex stream
+   * over this SSH connection. ssh2's 'tcp connection' event is client-wide, so
+   * a single dispatcher routes by the bound `destPort` to the right handler.
+   */
+  async reverseForward(onConnection) {
+    const client = await this.connect();
+    this.attachReverseListener(client);
+    const port = await new Promise((resolve, reject) => {
+      client.forwardIn("127.0.0.1", 0, (err, boundPort) => {
+        if (err) return reject(err);
+        resolve(boundPort);
+      });
+    });
+    this.reverseHandlers.set(port, onConnection);
+    return {
+      port,
+      close: async () => {
+        this.reverseHandlers.delete(port);
+        await new Promise((resolve) => {
+          try {
+            client.unforwardIn("127.0.0.1", port, () => resolve());
+          } catch {
+            resolve();
+          }
+        });
+      }
+    };
+  }
+  /** Attach the single client-wide 'tcp connection' dispatcher (idempotent per client). */
+  attachReverseListener(client) {
+    if (this.reverseListenerClient === client) return;
+    this.reverseListenerClient = client;
+    client.on("tcp connection", (details, accept, reject) => {
+      const handler = this.reverseHandlers.get(details.destPort);
+      if (!handler) {
+        try {
+          reject();
+        } catch {
+        }
+        return;
+      }
+      const channel = accept();
+      handler(channel);
+    });
+  }
+  async dispose() {
+    this.connecting = null;
+    this.sftpChannel = null;
+    this.sftpWrapper = null;
+    this.reverseHandlers.clear();
+    this.reverseListenerClient = null;
+    if (this.client) {
+      this.client.end();
+      this.client = null;
+    }
+  }
+  async transferIn(localPath, remotePath, onLog, options) {
+    const deps = {
+      config: this.config,
+      hasRemoteCommand: (c) => this.hasRemoteCommand(c)
+    };
+    const excludes = options?.excludes ?? [...TRANSFER_EXCLUDES];
+    const { args: tarArgs, cleanup: cleanupTarList } = await prepareSourceTarArgs(localPath, {
+      excludes,
+      includes: options?.includes,
+      alsoInclude: options?.alsoInclude
+    });
+    const tmpLocalDir = await mkdtemp2(join2(tmpdir2(), "kraft-xfer-"));
+    const localArchive = join2(tmpLocalDir, "context.tar.gz");
+    const remoteArchive = `${remotePath}.kraft-xfer.tar.gz`;
+    try {
+      onLog?.(logEntry("Packing source into a single archive..."));
+      await packLocalArchive(tarArgs, localArchive);
+      const totalBytes = (await stat(localArchive)).size;
+      await this.exec(`mkdir -p ${sq(remoteDirname(remoteArchive))}`);
+      const rsync = await canUseRemoteRsync(deps);
+      if (rsync.ok) {
+        onLog?.(
+          logEntry(
+            `Uploading ${formatBytes(totalBytes)} archive via rsync (resumable)...`
+          )
+        );
+        await uploadFileWithRsync(localArchive, remoteArchive, deps, onLog);
+      } else {
+        onLog?.(
+          logEntry(
+            `Uploading ${formatBytes(totalBytes)} archive via SFTP (resumable) \u2014 ${rsync.reason}.`
+          )
+        );
+        await this.sftpUploadResumable(
+          localArchive,
+          remoteArchive,
+          totalBytes,
+          onLog
+        );
+      }
+      await extractRemoteArchive(
+        (command) => this.exec(command),
+        remoteArchive,
+        remotePath,
+        totalBytes,
+        onLog
+      );
+    } finally {
+      await cleanupTarList().catch(() => {
+      });
+      await fsRm2(tmpLocalDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+  async hasRemoteCommand(command) {
+    try {
+      await this.exec(`command -v ${command} >/dev/null 2>&1 && echo ok`, {
+        timeout: 5e3
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Resumable SFTP upload (the fallback when rsync isn't available — password
+   * auth with no `sshpass`). Each attempt `stat`s the remote to learn how much
+   * already landed and streams the REST from that offset (append), so a dropped
+   * or stalled connection continues instead of restarting from 0. A watchdog
+   * aborts the attempt if no bytes flow for `STALL_MS`, and the loop retries
+   * (resuming) up to `MAX_ATTEMPTS`.
+   */
+  async sftpUploadResumable(localArchive, remoteArchive, totalBytes, onLog) {
+    const MAX_ATTEMPTS = 4;
+    const STALL_MS = 3e4;
+    let lastErr = null;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      const sftp = await this.sftp();
+      let offset = 0;
+      try {
+        const size = await new Promise(
+          (resolve, reject) => sftp.stat(
+            remoteArchive,
+            (err, stats) => err ? reject(err) : resolve(stats.size)
+          )
+        );
+        if (size === totalBytes) return;
+        if (size < totalBytes) offset = size;
+      } catch {
+        offset = 0;
+      }
+      if (attempt > 1 || offset > 0) {
+        onLog?.(
+          logEntry(
+            `Resuming SFTP upload from ${formatBytes(offset)} (attempt ${attempt}/${MAX_ATTEMPTS})...`,
+            "warn"
+          )
+        );
+      }
+      try {
+        await this.sftpStreamFrom(
+          sftp,
+          localArchive,
+          remoteArchive,
+          offset,
+          totalBytes,
+          STALL_MS,
+          onLog
+        );
+        return;
+      } catch (err) {
+        lastErr = err instanceof Error ? err : new Error(String(err));
+        onLog?.(
+          logEntry(`SFTP upload interrupted: ${lastErr.message}`, "warn")
+        );
+      }
+    }
+    throw lastErr ?? new Error("SFTP upload failed");
+  }
+  /** Stream `localArchive` (from `offset`) into `remoteArchive`, appending when
+   *  resuming. Rejects on error, on a stall (no bytes for `stallMs`), or if the
+   *  stream closes before `totalBytes` land. */
+  sftpStreamFrom(sftp, localArchive, remoteArchive, offset, totalBytes, stallMs, onLog) {
+    return new Promise((resolve, reject) => {
+      const read = createReadStream(localArchive, { start: offset });
+      const write = sftp.createWriteStream(remoteArchive, {
+        flags: offset > 0 ? "a" : "w"
+      });
+      let transferred = offset;
+      let lastProgressAt = Date.now();
+      const startedAt = Date.now();
+      let lastReportedAt = startedAt;
+      let settled = false;
+      const finish = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearInterval(watch);
+        fn();
+      };
+      const watch = setInterval(() => {
+        if (Date.now() - lastProgressAt > stallMs) {
+          read.destroy();
+          write.end();
+          finish(
+            () => reject(
+              new Error(`stalled \u2014 no data for ${Math.round(stallMs / 1e3)}s`)
+            )
+          );
+        }
+      }, 5e3);
+      watch.unref?.();
+      read.on("data", (chunk) => {
+        transferred += chunk.length;
+        lastProgressAt = Date.now();
+        const now = Date.now();
+        if (now - lastReportedAt >= 2500) {
+          lastReportedAt = now;
+          const elapsed = (now - startedAt) / 1e3;
+          const mbps = elapsed > 0 ? (transferred - offset) / 1024 / 1024 / elapsed : 0;
+          const pct = totalBytes > 0 ? Math.min(Math.floor(transferred / totalBytes * 100), 100) : 0;
+          onLog?.(
+            logEntry(
+              `  ~${pct}% \xB7 ${formatBytes(transferred)} \xB7 ${mbps.toFixed(1)} MB/s`
+            )
+          );
+        }
+      });
+      read.on("error", (e) => finish(() => reject(e)));
+      write.on("error", (e) => finish(() => reject(e)));
+      write.on(
+        "close",
+        () => finish(
+          () => transferred >= totalBytes ? resolve() : reject(
+            new Error(
+              `incomplete upload: ${transferred}/${totalBytes} bytes`
+            )
+          )
+        )
+      );
+      read.pipe(write);
+    });
+  }
+};
+
+// ../../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";
+import { connect as netConnect } from "net";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join3, posix as posix2 } from "path";
+import { Duplex } from "stream";
+import { promisify as promisify2 } from "util";
+import { randomBytes as randomBytes2 } from "crypto";
+
+// ../../packages/adapters/src/system/system-ssh.ts
+import { randomBytes } from "crypto";
+var CONNECT_TIMEOUT_SECONDS = 15;
+function makeControlPath() {
+  return `/tmp/kraft-ssh-${process.pid}-${randomBytes(6).toString("hex")}.sock`;
+}
+function buildBaseSshArgs(config, controlPath) {
+  const args = [
+    "-p",
+    String(config.port ?? 22),
+    // BatchMode keeps the OS ssh non-interactive: agent/keys only, never a
+    // password/passphrase prompt that would hang a headless API process.
+    "-o",
+    "BatchMode=yes",
+    "-o",
+    "StrictHostKeyChecking=accept-new",
+    "-o",
+    `ConnectTimeout=${CONNECT_TIMEOUT_SECONDS}`,
+    "-o",
+    "ServerAliveInterval=15",
+    "-o",
+    "ServerAliveCountMax=3",
+    // One authenticated master; subsequent ssh calls attach to it.
+    "-o",
+    "ControlMaster=auto",
+    "-o",
+    `ControlPath=${controlPath}`,
+    // Keep the master alive across brief idle gaps (the connection manager
+    // caches the executor for ~5 min); dispose() tears it down explicitly.
+    "-o",
+    "ControlPersist=300"
+  ];
+  if (config.sshJumpHost?.trim()) {
+    args.push("-J", config.sshJumpHost.trim());
+  }
+  if (config.sshArgs?.trim()) {
+    for (const token of config.sshArgs.trim().split(/\s+/)) {
+      if (token) args.push(token);
+    }
+  }
+  return args;
+}
+function sshTarget(config) {
+  return `${config.username ?? "root"}@${config.host}`;
+}
+function sshChildEnv(config) {
+  const env = { ...process.env };
+  if (config.sshAgent) {
+    env.SSH_AUTH_SOCK = config.sshAgent;
+  }
+  return env;
+}
+
+// ../../packages/adapters/src/system/reverse-tunnel.ts
+import { execFile } from "child_process";
+import { createServer } from "net";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function openSystemSshReverseTunnel(opts) {
+  const server = createServer((socket) => opts.onConnection(socket));
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  const localPort = server.address().port;
+  const closeServer = () => new Promise((resolve) => server.close(() => resolve()));
+  const sshBin = opts.sshBin ?? "ssh";
+  const forwardSpec = (remote) => `127.0.0.1:${remote}:127.0.0.1:${localPort}`;
+  let remotePort;
+  try {
+    const { stdout } = await execFileAsync(
+      sshBin,
+      [...opts.baseArgs, "-O", "forward", "-R", forwardSpec(0), opts.target],
+      { env: opts.env }
+    );
+    remotePort = Number.parseInt(stdout.trim(), 10);
+    if (!Number.isInteger(remotePort) || remotePort <= 0) {
+      throw new Error(
+        `ssh -O forward returned no port (stdout: ${JSON.stringify(stdout.trim())})`
+      );
+    }
+  } catch (err) {
+    await closeServer();
+    throw err;
+  }
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    await execFileAsync(
+      sshBin,
+      [
+        ...opts.baseArgs,
+        "-O",
+        "cancel",
+        "-R",
+        forwardSpec(remotePort),
+        opts.target
+      ],
+      { env: opts.env }
+    ).catch(() => {
+    });
+    await closeServer();
+  };
+  return { port: remotePort, close };
+}
+
+// ../../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)));
+}
+function describeSshFailure(stderr, fallback) {
+  const text = stderr.trim() || fallback;
+  if (/permission denied|authentication failed|too many authentication failures/i.test(
+    text
+  )) {
+    return new Error(`All configured authentication methods failed: ${text}`);
+  }
+  return new Error(text);
+}
+var SystemSshExecutor = class _SystemSshExecutor {
+  config;
+  abortScope = new AsyncLocalStorage2();
+  controlPath = makeControlPath();
+  /** Resolves once the ControlMaster connection is established. */
+  masterPromise = null;
+  /** Remote-socket → local-forward-socket, one StreamLocal forward per target. */
+  socketForwards = /* @__PURE__ */ new Map();
+  localSockets = /* @__PURE__ */ new Set();
+  disconnectListeners = /* @__PURE__ */ new Set();
+  disposed = false;
+  /** Prefix applied to every remote command - keeps dpkg non-interactive. */
+  static ENV_PREFIX = "export DEBIAN_FRONTEND=noninteractive DPKG_FORCE=confnew && ";
+  constructor(config) {
+    if (!config.host) {
+      throw new Error("System SSH executor requires a host.");
+    }
+    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);
+  }
+  onDisconnect(cb) {
+    this.disconnectListeners.add(cb);
+    return () => {
+      this.disconnectListeners.delete(cb);
+    };
+  }
+  /**
+   * On an SSH-level failure (exit 255 — which OpenSSH uses for ANY ssh-level
+   * error: a dropped transport AND an auth failure alike, with no granular
+   * code to tell them apart), authoritatively probe the ControlMaster with
+   * `ssh -O check` instead of guessing from locale/version-dependent stderr.
+   * Only a genuinely-dead master counts as a disconnect: we null it so the
+   * next op reopens, and notify subscribers so the manager can react.
+   */
+  async maybeSignalDisconnect(code) {
+    if (code !== 255 || this.disposed) return;
+    if (!this.masterPromise) return;
+    if (await this.isMasterAlive()) return;
+    this.masterPromise = null;
+    const err = new SshDisconnectedError("SSH master connection lost");
+    for (const cb of [...this.disconnectListeners]) {
+      try {
+        cb(err);
+      } catch {
+      }
+    }
+  }
+  /** Authoritative ControlMaster liveness check: `ssh -O check` exits 0
+   *  ("Master running") when the multiplex socket is alive, non-zero when it's
+   *  missing/dead. Immune to stderr locale/version drift. */
+  async isMasterAlive() {
+    try {
+      await execFileAsync2(
+        "ssh",
+        [...this.baseArgs(), "-O", "check", sshTarget(this.config)],
+        {
+          timeout: 5e3,
+          env: sshChildEnv(this.config)
+        }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Open (once) the multiplexed master connection. Authenticates here. */
+  async ensureMaster() {
+    if (this.masterPromise) return this.masterPromise;
+    this.masterPromise = (async () => {
+      try {
+        await execFileAsync2(
+          "ssh",
+          [...this.baseArgs(), "-fN", sshTarget(this.config)],
+          {
+            timeout: 3e4,
+            env: sshChildEnv(this.config)
+          }
+        );
+      } catch (err) {
+        this.masterPromise = null;
+        const e = err;
+        throw describeSshFailure(e.stderr ?? "", safeErrorMessage(err));
+      }
+    })();
+    return this.masterPromise;
+  }
+  /**
+   * Open a reverse tunnel over the ControlMaster: the remote binds an ephemeral
+   * 127.0.0.1 port whose connections arrive here as duplex streams. The
+   * system-ssh counterpart to `SshExecutor.reverseForward` (ssh2) — same shape,
+   * so `CommandExecutor.reverseForward` consumers (the git-credential relay,
+   * future callers) work over agent auth too. Delegates to the generic
+   * `openSystemSshReverseTunnel`.
+   */
+  async reverseForward(onConnection) {
+    await this.ensureMaster();
+    return openSystemSshReverseTunnel({
+      baseArgs: this.baseArgs(),
+      target: sshTarget(this.config),
+      env: sshChildEnv(this.config),
+      onConnection
+    });
+  }
+  /** 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),
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      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;
+          child.kill("SIGKILL");
+        }, opts.timeout);
+        timer.unref?.();
+      }
+      child.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+      child.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      child.on("error", (e) => {
+        finish(() => reject(new Error(`ssh failed to start: ${e.message}`)));
+      });
+      child.on("close", (code) => {
+        const c = code ?? 1;
+        void this.maybeSignalDisconnect(c).catch(() => {
+        });
+        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);
+      }
+      child.stdin.end();
+    });
+  }
+  async exec(command, opts) {
+    const timeout = opts?.timeout ?? 3e4;
+    const res = await this.runSsh(_SystemSshExecutor.ENV_PREFIX + command, {
+      timeout
+    });
+    if (res.timedOut) {
+      throw new Error(
+        `Command timed out after ${timeout}ms: ${commandForError(command)}`
+      );
+    }
+    if (res.code !== 0) {
+      if (res.code === 255)
+        throw describeSshFailure(res.stderr, `Exit code ${res.code}`);
+      throw new Error(res.stderr.trim() || `Exit code ${res.code}`);
+    }
+    return res.stdout.trim();
+  }
+  async streamExec(command, onLog, opts) {
+    await this.ensureMaster();
+    const signal = this.resolvedSignal(opts?.signal);
+    if (signal?.aborted) return { code: 0, output: "" };
+    return new Promise((resolve) => {
+      const child = spawn2(
+        "ssh",
+        [
+          ...this.baseArgs(),
+          sshTarget(this.config),
+          _SystemSshExecutor.ENV_PREFIX + command
+        ],
+        { env: sshChildEnv(this.config), stdio: ["ignore", "pipe", "pipe"] }
+      );
+      let aborted = false;
+      const onAbort = () => {
+        aborted = true;
+        child.kill("SIGKILL");
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const chunks = [];
+      const onChunk = (chunk, level) => {
+        const text = chunk.toString();
+        if (!text) return;
+        chunks.push(text);
+        onLog(logEntry(text, level, chunk.toString("base64")));
+      };
+      child.stdout.on("data", (chunk) => onChunk(chunk, "info"));
+      child.stderr.on("data", (chunk) => onChunk(chunk, "warn"));
+      child.on("error", (err) => {
+        signal?.removeEventListener("abort", onAbort);
+        onLog(logEntry(`Process error: ${err.message}`, "error"));
+        resolve({ code: 1, output: err.message });
+      });
+      child.on("close", (code) => {
+        signal?.removeEventListener("abort", onAbort);
+        const c = aborted ? 0 : code ?? 1;
+        void this.maybeSignalDisconnect(c).catch(() => {
+        });
+        resolve({ code: c, output: chunks.join("") });
+      });
+    });
+  }
+  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})`
+      );
+    }
+  }
+  async rename(from, to) {
+    await this.exec(`mv ${sq(from)} ${sq(to)}`);
+  }
+  async readFile(path) {
+    const res = await this.runSsh(`cat ${sq(path)}`);
+    if (res.code !== 0) {
+      throw new Error(
+        res.stderr.trim() || `Failed to read ${path} (exit ${res.code})`
+      );
+    }
+    return res.stdout;
+  }
+  async exists(path) {
+    const res = await this.runSsh(`test -e ${sq(path)}`);
+    return res.code === 0;
+  }
+  async mkdir(path) {
+    await this.exec(`mkdir -p ${sq(path)}`);
+  }
+  async rm(path) {
+    try {
+      await this.exec(`rm -rf ${sq(path)}`);
+    } catch {
+    }
+  }
+  /** Pipe a local command's stdout into a remote command's stdin over ssh. */
+  async pipeLocal(localCmd, remoteCmd, onLog, onBytes) {
+    await this.ensureMaster();
+    return new Promise((resolve, reject) => {
+      onLog?.(logEntry(`local: ${localCmd}`));
+      const remote = spawn2(
+        "ssh",
+        [...this.baseArgs(), sshTarget(this.config), remoteCmd],
+        {
+          env: sshChildEnv(this.config),
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      const local = spawn2("sh", ["-c", localCmd], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      if (onBytes) {
+        local.stdout.on("data", (chunk) => onBytes(chunk.length));
+      }
+      local.stdout.pipe(remote.stdin);
+      local.stderr.on("data", (d) => {
+        const text = d.toString().trim();
+        if (text) onLog?.(logEntry(`local stderr: ${text}`, "warn"));
+      });
+      remote.stderr.on("data", (d) => {
+        const text = d.toString().trim();
+        if (text) onLog?.(logEntry(`remote stderr: ${text}`, "warn"));
+      });
+      local.on(
+        "error",
+        (e) => reject(new Error(`Local process failed to start: ${e.message}`))
+      );
+      remote.on(
+        "error",
+        (e) => reject(new Error(`ssh failed to start: ${e.message}`))
+      );
+      remote.on("close", (code) => resolve({ code: code ?? 1 }));
+    });
+  }
+  async transferIn(localPath, remotePath, onLog, options) {
+    const deps = {
+      config: this.config,
+      hasRemoteCommand: (c) => this.hasRemoteCommand(c)
+    };
+    const excludes = options?.excludes ?? [...TRANSFER_EXCLUDES];
+    const { args: tarArgs, cleanup: cleanupTarList } = await prepareSourceTarArgs(localPath, {
+      excludes,
+      includes: options?.includes,
+      alsoInclude: options?.alsoInclude
+    });
+    const tmpLocalDir = await mkdtemp3(join3(tmpdir3(), "kraft-xfer-"));
+    const localArchive = join3(tmpLocalDir, "context.tar.gz");
+    const remoteArchive = `${remotePath}.kraft-xfer.tar.gz`;
+    try {
+      onLog?.(logEntry("Packing source into a single archive..."));
+      await packLocalArchive(tarArgs, localArchive);
+      const totalBytes = (await stat2(localArchive)).size;
+      await this.exec(`mkdir -p ${sq(remoteDirname2(remoteArchive))}`);
+      const rsync = await canUseRemoteRsync(deps);
+      if (rsync.ok) {
+        onLog?.(
+          logEntry(
+            `Uploading ${formatBytes(totalBytes)} archive via rsync (resumable)...`
+          )
+        );
+        await uploadFileWithRsync(localArchive, remoteArchive, deps, onLog);
+      } else {
+        onLog?.(
+          logEntry(
+            `Uploading ${formatBytes(totalBytes)} archive over the SSH connection \u2014 ${rsync.reason}.`
+          )
+        );
+        await this.streamArchiveWithRetry(localArchive, remoteArchive, onLog);
+      }
+      await extractRemoteArchive(
+        (command) => this.exec(command),
+        remoteArchive,
+        remotePath,
+        totalBytes,
+        onLog
+      );
+    } finally {
+      await cleanupTarList().catch(() => {
+      });
+      await fsRm3(tmpLocalDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+  /** Stream a single local file over the ControlMaster, retrying from 0 on
+   *  failure (the `cat >` truncates, so there is no partial to resume). */
+  async streamArchiveWithRetry(localArchive, remoteArchive, onLog) {
+    const MAX_ATTEMPTS = 3;
+    let lastErr = null;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      if (attempt > 1)
+        onLog?.(
+          logEntry(
+            `Retrying upload (attempt ${attempt}/${MAX_ATTEMPTS})...`,
+            "warn"
+          )
+        );
+      try {
+        const { code } = await this.pipeLocal(
+          `cat ${sq(localArchive)}`,
+          `cat > ${sq(remoteArchive)}`,
+          onLog
+        );
+        if (code === 0) return;
+        lastErr = new Error(`archive upload failed (exit ${code})`);
+      } catch (err) {
+        lastErr = err instanceof Error ? err : new Error(String(err));
+      }
+    }
+    throw lastErr ?? new Error("archive upload failed");
+  }
+  async hasRemoteCommand(command) {
+    try {
+      const out = await this.exec(
+        `command -v ${command} >/dev/null 2>&1 && echo ok`,
+        { timeout: 5e3 }
+      );
+      return out.trim() === "ok";
+    } catch {
+      return false;
+    }
+  }
+  async forwardPort(remoteHost, remotePort) {
+    await this.ensureMaster();
+    const child = spawn2(
+      "ssh",
+      [
+        ...this.baseArgs(),
+        "-W",
+        `${remoteHost}:${remotePort}`,
+        sshTarget(this.config)
+      ],
+      { env: sshChildEnv(this.config), stdio: ["pipe", "pipe", "ignore"] }
+    );
+    const duplex = Duplex.from({
+      writable: child.stdin,
+      readable: child.stdout
+    });
+    duplex.on("close", () => {
+      try {
+        child.kill();
+      } catch {
+      }
+    });
+    child.on("exit", () => {
+      duplex.destroy();
+    });
+    child.on("error", (e) => {
+      duplex.destroy(e);
+    });
+    return duplex;
+  }
+  /** Ensure a StreamLocal forward (local unix socket → remote socket) on the master. */
+  async ensureSocketForward(remoteSocket) {
+    let pending = this.socketForwards.get(remoteSocket);
+    if (!pending) {
+      pending = (async () => {
+        await this.ensureMaster();
+        const localSocket = `/tmp/kraft-fwd-${process.pid}-${randomBytes2(6).toString("hex")}.sock`;
+        await execFileAsync2(
+          "ssh",
+          [
+            ...this.baseArgs(),
+            "-O",
+            "forward",
+            "-L",
+            `${localSocket}:${remoteSocket}`,
+            sshTarget(this.config)
+          ],
+          { timeout: 15e3, env: sshChildEnv(this.config) }
+        );
+        this.localSockets.add(localSocket);
+        return localSocket;
+      })();
+      pending.catch(() => {
+        if (this.socketForwards.get(remoteSocket) === pending) {
+          this.socketForwards.delete(remoteSocket);
+        }
+      });
+      this.socketForwards.set(remoteSocket, pending);
+    }
+    return pending;
+  }
+  async forwardUnixSocket(socketPath) {
+    const attempt = async () => {
+      const localSocket = await this.ensureSocketForward(socketPath);
+      const sock = netConnect(localSocket);
+      await once(sock, "connect");
+      return sock;
+    };
+    try {
+      return await attempt();
+    } catch {
+      this.socketForwards.delete(socketPath);
+      return attempt();
+    }
+  }
+  /**
+   * Run a best-effort, fire-and-forget control command on the remote over the
+   * existing master (no output captured, errors swallowed). Used for PTY
+   * resize and marker cleanup.
+   */
+  fireAndForget(command) {
+    try {
+      spawn2("ssh", [...this.baseArgs(), sshTarget(this.config), command], {
+        env: sshChildEnv(this.config),
+        stdio: "ignore"
+      }).on("error", () => {
+      });
+    } catch {
+    }
+  }
+  async openShell(opts) {
+    await this.ensureMaster();
+    const cols = clampWindow2(opts?.cols, 80, 1, 1e3);
+    const rows = clampWindow2(opts?.rows, 24, 1, 500);
+    const term = opts?.term || "xterm-256color";
+    const ptyMarker = `/tmp/kraft-pty-${process.pid}-${randomBytes2(6).toString("hex")}`;
+    const remoteInit = `tty > ${ptyMarker} 2>/dev/null; stty sane 2>/dev/null; stty cols ${cols} rows ${rows} 2>/dev/null; exec "\${SHELL:-/bin/sh}" -l`;
+    const env = { ...sshChildEnv(this.config), TERM: term };
+    const child = spawn2(
+      "ssh",
+      [...this.baseArgs(), "-tt", sshTarget(this.config), remoteInit],
+      {
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    child.stdin.on("error", () => {
+    });
+    child.stdout.on("error", () => {
+    });
+    child.stderr.on("error", () => {
+    });
+    const closeListeners = [];
+    let closed = false;
+    let resizeTimer = null;
+    let pendingSize = null;
+    const fireClose = (code, signal) => {
+      if (closed) return;
+      closed = true;
+      if (resizeTimer) clearTimeout(resizeTimer);
+      this.fireAndForget(`rm -f ${ptyMarker}`);
+      for (const cb of closeListeners) {
+        try {
+          cb(code, signal);
+        } catch {
+        }
+      }
+    };
+    child.on("exit", (code, signal) => fireClose(code, signal ?? void 0));
+    child.on("error", () => fireClose(null));
+    return {
+      stdin: child.stdin,
+      stdout: child.stdout,
+      stderr: child.stderr,
+      setWindow: (c, r) => {
+        pendingSize = {
+          c: clampWindow2(c, 80, 1, 1e3),
+          r: clampWindow2(r, 24, 1, 500)
+        };
+        if (resizeTimer) clearTimeout(resizeTimer);
+        resizeTimer = setTimeout(() => {
+          const size = pendingSize;
+          pendingSize = null;
+          if (!size || closed) return;
+          this.fireAndForget(
+            `for i in 1 2 3 4 5 6; do P=$(cat ${ptyMarker} 2>/dev/null); if [ -n "$P" ]; then stty -F "$P" cols ${size.c} rows ${size.r} 2>/dev/null || stty -f "$P" cols ${size.c} rows ${size.r} 2>/dev/null; break; fi; sleep 0.2; done`
+          );
+        }, 60);
+        resizeTimer.unref?.();
+      },
+      close: (_signal) => {
+        if (resizeTimer) clearTimeout(resizeTimer);
+        try {
+          child.kill();
+        } catch {
+        }
+      },
+      onClose: (cb) => {
+        closeListeners.push(cb);
+      }
+    };
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (this.masterPromise) {
+      try {
+        await execFileAsync2(
+          "ssh",
+          [...this.baseArgs(), "-O", "exit", sshTarget(this.config)],
+          {
+            timeout: 5e3,
+            env: sshChildEnv(this.config)
+          }
+        );
+      } catch {
+      }
+    }
+    this.masterPromise = null;
+    this.socketForwards.clear();
+    for (const socket of this.localSockets) {
+      await unlink(socket).catch(() => {
+      });
+    }
+    this.localSockets.clear();
+  }
+};
+
+// ../../packages/adapters/src/system/executor.ts
+var localExecutor = new LocalExecutor();
+function createExecutor(ssh) {
+  if (ssh) {
+    if (ssh.useSystemSsh) return new SystemSshExecutor(ssh);
+    return new SshExecutor(ssh);
+  }
+  return localExecutor;
+}
+var hostControlOverride = null;
+function setHostControlOverride(disabled) {
+  hostControlOverride = disabled;
+}
+function hostControlDisabled() {
+  return hostControlOverride ?? process.env.KRAFT_HOST_CONTROL?.trim().toLowerCase() === "false";
+}
+function runningInContainer() {
+  if (process.env.KRAFT_IN_CONTAINER?.trim().toLowerCase() === "true")
+    return true;
+  try {
+    if (existsSync("/.dockerenv")) return true;
+  } catch {
+  }
+  try {
+    return /\b(docker|containerd|podman|kubepods)\b/.test(
+      readFileSync("/proc/1/cgroup", "utf8")
+    );
+  } catch {
+    return false;
+  }
+}
+function hostChannelPort() {
+  const raw = Number(process.env.KRAFT_HOST_SSH_PORT || "22");
+  return Number.isInteger(raw) && raw > 0 && raw < 65536 ? raw : 22;
+}
+function hostChannelUser() {
+  return hostChannelAccount(process.env);
+}
+function readHostChannelKey(keyPath) {
+  let contents;
+  try {
+    contents = readFileSync(keyPath, "utf8");
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      reason: `Cannot read the host SSH key at ${keyPath} (${detail}).`
+    };
+  }
+  if (!contents.trim())
+    return { reason: `The host SSH key at ${keyPath} is empty.` };
+  return { key: contents };
+}
+function containerBridgeCidr() {
+  for (const addrs of Object.values(networkInterfaces())) {
+    for (const addr of addrs ?? []) {
+      if (addr.family !== "IPv4" || addr.internal) continue;
+      const prefix = Number(addr.cidr?.split("/")[1]);
+      if (!Number.isInteger(prefix) || prefix < 8 || prefix > 32) continue;
+      const octets = addr.address.split(".").map(Number);
+      if (octets.length !== 4 || octets.some((o) => !Number.isInteger(o) || o < 0 || o > 255))
+        continue;
+      const asInt = (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
+      const mask = 4294967295 << 32 - prefix >>> 0;
+      const net = (asInt & mask) >>> 0;
+      return `${net >>> 24 & 255}.${net >>> 16 & 255}.${net >>> 8 & 255}.${net & 255}/${prefix}`;
+    }
+  }
+  return null;
+}
+function probeDetail(probe) {
+  const { code, message } = probe;
+  if (code && message && !message.includes(code)) return `${code}: ${message}`;
+  return code ?? message;
+}
+function explainDialFailure(probe, host, port, target) {
+  const { headline, body, firewallShaped } = explainHostChannelCause(
+    probe.reason,
+    {
+      target,
+      host,
+      detail: probeDetail(probe)
+    }
+  );
+  const hint = body ? `${headline}. ${body}` : `${headline}.`;
+  if (!firewallShaped) return { hint };
+  const cidr = containerBridgeCidr();
+  return { hint, rule: hostFirewallRule("unknown", cidr ? [cidr] : [], port) };
+}
+var AUTH_MEMO_OK_MS = 3e4;
+var AUTH_MEMO_FAIL_MS = 5e3;
+var authMemo = null;
+function invalidateHostChannelAuth() {
+  authMemo = null;
+}
+function probeForwarding(client, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (verdict) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(verdict);
+    };
+    const timer = setTimeout(() => finish("unknown"), timeoutMs);
+    timer.unref?.();
+    try {
+      client.forwardOut("127.0.0.1", 0, "127.0.0.1", 1, (err, stream) => {
+        if (stream) {
+          stream.destroy();
+          finish("ok");
+          return;
+        }
+        const reason = err?.reason;
+        const message = err?.message;
+        if (reason === 1 || reason === 3) return finish("blocked");
+        if (typeof message === "string" && /administratively prohibited/i.test(message)) {
+          return finish("blocked");
+        }
+        finish("ok");
+      });
+    } catch {
+      finish("unknown");
+    }
+  });
+}
+async function verifyHostChannelAuth(config) {
+  const memoKey = `${config.username}@${config.host}:${config.port}#${config.privateKey.length}`;
+  if (authMemo?.key === memoKey && authMemo.expires > Date.now()) {
+    return authMemo.hint ? { hint: authMemo.hint, forwarding: authMemo.forwarding } : { forwarding: authMemo.forwarding };
+  }
+  let hint = null;
+  let forwarding = "unknown";
+  try {
+    const { connectSshClient: connectSshClient2 } = await import("./ssh-client-NWQVRCV7.js");
+    const client = await connectSshClient2({
+      host: config.host,
+      port: config.port,
+      username: config.username,
+      privateKey: config.privateKey,
+      readyTimeoutMs: config.timeoutMs,
+      // Load-bearing: it selects describeSshAuthFailure's host-channel wording, so the
+      // hint an operator reads here is the same sentence the deploy log gives them.
+      hostChannel: true
+    });
+    forwarding = await probeForwarding(
+      client,
+      config.timeoutMs
+    );
+    client.end();
+  } catch (err) {
+    if (isSshAuthError(err)) {
+      hint = err instanceof Error ? err.message : HOST_CHANNEL_AUTH_REJECTED;
+    }
+  }
+  authMemo = {
+    key: memoKey,
+    hint,
+    forwarding,
+    expires: Date.now() + (hint ? AUTH_MEMO_FAIL_MS : AUTH_MEMO_OK_MS)
+  };
+  return hint ? { hint, forwarding } : { forwarding };
+}
+async function hostChannelHealth(timeoutMs = 2500) {
+  if (hostControlDisabled()) {
+    return {
+      ok: false,
+      code: "disabled",
+      hint: "Host control is off (KRAFT_HOST_CONTROL=false). Re-run `kraft up` without --no-host-control."
+    };
+  }
+  const host = process.env.KRAFT_HOST_SSH_HOST?.trim();
+  if (!host) {
+    if (runningInContainer()) {
+      return {
+        ok: false,
+        code: "not_configured",
+        hint: `${HOST_CHANNEL_UNPROVISIONED} ${HOST_CHANNEL_NOT_PROVISIONED}`
+      };
+    }
+    return { ok: true, code: "not_applicable" };
+  }
+  const port = hostChannelPort();
+  const target = `${hostChannelUser()}@${host}:${port}`;
+  const keyPath = process.env.KRAFT_HOST_SSH_KEY?.trim();
+  let privateKey;
+  if (keyPath) {
+    const read = readHostChannelKey(keyPath);
+    if (read.reason) {
+      return {
+        ok: false,
+        code: "key_unreadable",
+        host,
+        port,
+        target,
+        hint: `${read.reason} ${HOST_CHANNEL_NOT_PROVISIONED}`
+      };
+    }
+    privateKey = read.key;
+  }
+  const probe = await probeTcpDetailed(host, port, timeoutMs);
+  if (!probe.ok) {
+    return {
+      ok: false,
+      code: "unreachable",
+      host,
+      port,
+      target,
+      cause: probe.reason,
+      ...explainDialFailure(probe, host, port, target)
+    };
+  }
+  let forwarding = "unknown";
+  if (privateKey) {
+    const verdict = await verifyHostChannelAuth({
+      host,
+      port,
+      username: hostChannelUser(),
+      privateKey,
+      timeoutMs
+    });
+    if (verdict.hint) {
+      return {
+        ok: false,
+        code: "auth_rejected",
+        host,
+        port,
+        target,
+        hint: verdict.hint
+      };
+    }
+    forwarding = verdict.forwarding;
+  }
+  return { ok: true, code: "ok", host, port, target, forwarding };
+}
+function unavailableExecutor(reason, code = "not_configured") {
+  const refuse = async () => {
+    throw new HostChannelUnavailableError(code, reason);
+  };
+  return {
+    exec: refuse,
+    streamExec: refuse,
+    writeFile: refuse,
+    readFile: refuse,
+    exists: refuse,
+    mkdir: refuse,
+    rm: refuse,
+    transferIn: refuse,
+    // Nothing was ever opened, so releasing must not be the one call that throws.
+    dispose: async () => {
+    }
+  };
+}
+function createHostExecutor() {
+  if (hostControlDisabled()) {
+    throw new HostChannelUnavailableError(
+      "disabled",
+      "Host control is disabled on this instance (KRAFT_HOST_CONTROL=false). Re-run `kraft up` without --no-host-control to allow host operations."
+    );
+  }
+  const host = process.env.KRAFT_HOST_SSH_HOST?.trim();
+  if (!host) {
+    if (runningInContainer()) {
+      throw new HostChannelUnavailableError(
+        "not_configured",
+        `This operation targets the HOST machine, but no host channel is configured (KRAFT_HOST_SSH_HOST is unset) and Kraft is running in a container \u2014 so it would have run inside the container instead, against the wrong filesystem. ${HOST_CHANNEL_NOT_PROVISIONED}`
+      );
+    }
+    return localExecutor;
+  }
+  const keyPath = process.env.KRAFT_HOST_SSH_KEY?.trim();
+  if (!keyPath) {
+    throw new HostChannelUnavailableError(
+      "not_configured",
+      `A host channel is configured (KRAFT_HOST_SSH_HOST) but KRAFT_HOST_SSH_KEY is unset, so there is no credential to connect to the host with. ${HOST_CHANNEL_NOT_PROVISIONED}`
+    );
+  }
+  const read = readHostChannelKey(keyPath);
+  if (read.reason) {
+    throw new HostChannelUnavailableError(
+      "not_configured",
+      `${read.reason} ${HOST_CHANNEL_NOT_PROVISIONED}`
+    );
+  }
+  return new SshExecutor({
+    host,
+    port: hostChannelPort(),
+    username: hostChannelUser(),
+    privateKey: read.key,
+    // One hop over the docker bridge: it answers at once or it is being filtered.
+    // 20s of silence per host operation reads as a hang, not as a failure.
+    readyTimeoutMs: 8e3,
+    hostChannel: true
+  });
+}
+
+export {
+  SshExecutor,
+  SystemSshExecutor,
+  createExecutor,
+  setHostControlOverride,
+  hostControlDisabled,
+  containerBridgeCidr,
+  invalidateHostChannelAuth,
+  hostChannelHealth,
+  unavailableExecutor,
+  createHostExecutor
+};