Method attemptConnection

src/node/runtime/SSH2ConnectionPool.ts:460–639

(
        identityFiles: string[],
        agentOverride: string | undefined
      )

      };

      const attemptConnection = async (
        identityFiles: string[],
        agentOverride: string | undefined
      ): Promise<SSH2ConnectionEntry> => {
        const resolvedConfigWithIdentities: ResolvedSSHConfig = {
          ...resolvedConfig,
          identityFiles,
        };

        const readableKeys = await resolvePrivateKeys(resolvedConfigWithIdentities.identityFiles);
        if (abortSignal?.aborted) {
          throw new Error(SSH2_OPERATION_ABORTED_ERROR);
        }
        const keysToTry: Array<Buffer | undefined> =
          readableKeys.length > 0 ? readableKeys : [undefined];
        // Keep the sshPromptService wiring in place so known_hosts-backed
        // verification can be restored without changing the public module API.
        void sshPromptService;

        const connectWithKey = async (
          privateKey: Buffer | undefined,
          reportAuthFailure: boolean
        ): Promise<SSH2ConnectionEntry> => {
          const proxy = resolvedConfigWithIdentities.proxyCommand
            ? spawnProxyCommand(resolvedConfigWithIdentities.proxyCommand, proxyTokens)
            : undefined;

          // Lazy-load ssh2 to avoid loading the native sshcrypto.node module at
          // startup. Bun doesn't support the libuv functions the NAPI module calls,
          // so eagerly importing ssh2 crashes the headless CLI in sandboxes.
          const { Client: SSH2Client } = await import("ssh2");
          const client = new SSH2Client();
          const entry: SSH2ConnectionEntry = {
            client,
            resolvedConfig: resolvedConfigWithIdentities,
            proxyProcess: proxy?.process,
            lastActivityAt: Date.now(),
          };

          const cleanupProxy = () => {
            if (proxy?.process?.exitCode === null) {
              proxy.process.kill();
            }
          };

          const cleanupProxySocket = () => {
            if (proxy?.sock && !proxy.sock.destroyed) {
              proxy.sock.destroy();
            }
            cleanupProxy();
          };

          if (proxy) {
            // ProxyCommand streams can emit EPIPE/ECONNRESET; handle to avoid crashes.
            const attach = (emitter: NodeJS.EventEmitter, label: string) => {
              attachStreamErrorHandler(emitter, label, {
                logger: log,
                onIgnorable: cleanupProxySocket,