@xec-sh/core/dist/adapters/ssh-adapter.d.ts

Universal shell execution engine

import { ExecutionResult } from '../core/result.js';
import { Command, SSHAdapterOptions } from '../core/command.js';
import { BaseAdapter, BaseAdapterConfig } from './base-adapter.js';
import { SecurePasswordHandler } from '../utils/secure-password.js';
import { Config as SSH2Config } from '../utils/ssh.js';
export interface SSHConnectionPoolOptions {
    enabled: boolean;
    maxConnections: number;
    idleTimeout: number;
    keepAlive: boolean;
    keepAliveInterval?: number;
    autoReconnect?: boolean;
    maxReconnectAttempts?: number;
    reconnectDelay?: number;
}
export interface SSHMultiplexingOptions {
    enabled: boolean;
    controlPath?: string;
    controlPersist?: string | number;
}
export interface SSHSudoOptions {
    enabled: boolean;
    password?: string;
    prompt?: string;
    method?: 'stdin' | 'askpass' | 'echo' | 'secure-askpass';
    secureHandler?: SecurePasswordHandler;
}
export interface SSHSFTPOptions {
    enabled: boolean;
    concurrency: number;
}
export interface SSHAdapterConfig extends BaseAdapterConfig {
    connectionPool?: SSHConnectionPoolOptions;
    defaultConnectOptions?: SSH2Config;
    multiplexing?: SSHMultiplexingOptions;
    sudo?: SSHSudoOptions;
    sftp?: SSHSFTPOptions;
}
export declare class SSHAdapter extends BaseAdapter {
    protected readonly adapterName = "ssh";
    private sshConfig;
    private connectionPool;
    private poolCleanupInterval?;
    private securePasswordHandler?;
    private metricsCollector;
    private activeTunnels;
    private lastUsedSSHOptions?;
    constructor(config?: SSHAdapterConfig);
    isAvailable(): Promise<boolean>;
    execute(command: Command): Promise<ExecutionResult>;
    private extractSSHOptions;
    private getConnection;
    private getConnectionKey;
    private executeSSHCommand;
    private convertStdin;
    private wrapWithSudo;
    private buildSudoCommandWithConfig;
    private buildSudoCommand;
    private startPoolCleanup;
    private removeFromPool;
    private reconnectConnection;
    private setupKeepAlive;
    private removeOldestIdleConnection;
    private getPoolMetrics;
    getConnectionPoolMetrics(): import("../utils/connection-pool-metrics.js").ConnectionPoolMetrics;
    dispose(): Promise<void>;
    uploadFile(localPath: string, remotePath: string, options: SSHAdapterOptions): Promise<void>;
    downloadFile(remotePath: string, localPath: string, options: SSHAdapterOptions): Promise<void>;
    uploadDirectory(localPath: string, remotePath: string, options: SSHAdapterOptions): Promise<void>;
    portForward(localPort: number, remoteHost: string, remotePort: number, options: SSHAdapterOptions): Promise<void>;
    tunnel(options: {
        localPort?: number;
        localHost?: string;
        remoteHost: string;
        remotePort: number;
    }): Promise<{
        localPort: number;
        localHost: string;
        remoteHost: string;
        remotePort: number;
        isOpen: boolean;
        open: () => Promise<void>;
        close: () => Promise<void>;
    }>;
}