rustssh2 9.0.0

package/lib/index.d.ts

@@ -0,0 +1,102 @@
+import { Observable } from 'rxjs';
+import { Destructible } from './helpers';
+import { SFTP } from './sftp';
+import { Channel, NewChannel } from './channel';
+import { ClientEventInterface } from './events';
+import { SshKeyPair, KeyboardInteractiveAuthenticationPrompt, SshClient, SshPublicKey, SshTransport } from './native';
+import { AgentConnectionSpec } from './agent';
+export declare class KeyPair {
+    protected inner: SshKeyPair;
+    private constructor();
+    get algorithm(): string;
+    static parse(data: string, passphrase?: string): Promise<KeyPair>;
+}
+export interface X11ChannelOpenEvent {
+    readonly channel: NewChannel;
+    readonly clientAddress: string;
+    readonly clientPort: number;
+}
+export interface TCPChannelOpenEvent {
+    readonly channel: NewChannel;
+    readonly targetAddress: string;
+    readonly targetPort: number;
+    readonly clientAddress: string;
+    readonly clientPort: number;
+}
+export type KeyboardInteractiveAuthenticationState = {
+    state: 'failure';
+    remainingMethods: string[];
+} | {
+    state: 'infoRequest';
+    name: string;
+    instructions: string;
+    prompts: () => KeyboardInteractiveAuthenticationPrompt[];
+};
+export interface AuthFailure {
+    remainingMethods: string[];
+}
+export interface Config {
+    preferred?: {
+        ciphers?: string[];
+        kex?: string[];
+        key?: string[];
+        mac?: string[];
+        compression?: string[];
+    };
+    connectionTimeoutSeconds?: number;
+    keepaliveIntervalSeconds?: number;
+    keepaliveCountMax?: number;
+}
+export declare class SSHClient extends Destructible {
+    private client;
+    private events;
+    readonly disconnect$: Observable<void>;
+    readonly banner$: Observable<string>;
+    private constructor();
+    static connect(transport: SshTransport, serverKeyCallback: (key: SshPublicKey) => Promise<boolean>, config?: Config): Promise<SSHClient>;
+    protected destruct(): void;
+    authenticateNone(username: string): Promise<AuthenticatedSSHClient | AuthFailure>;
+    authenticateWithPassword(username: string, password: string): Promise<AuthenticatedSSHClient | AuthFailure>;
+    private _hashAlg;
+    authenticateWithKeyPair(username: string, keyPair: KeyPair, hashAlgorithm: 'sha1' | 'sha256' | 'sha512' | null): Promise<AuthenticatedSSHClient | AuthFailure>;
+    startKeyboardInteractiveAuthentication(username: string): Promise<KeyboardInteractiveAuthenticationState>;
+    continueKeyboardInteractiveAuthentication(responses: string[]): Promise<AuthenticatedSSHClient | KeyboardInteractiveAuthenticationState>;
+    authenticateWithAgent(username: string, connection: AgentConnectionSpec): Promise<AuthenticatedSSHClient | AuthFailure>;
+    /**
+     * Authenticate using SSH agent with a specific public key identity.
+     * This is useful when you have multiple keys in the agent and want to use a specific one,
+     * avoiding the server's authentication attempt limit.
+     * @param username SSH username
+     * @param connection Agent connection specification
+     * @param publicKey The specific public key to use for authentication
+     */
+    authenticateWithAgentIdentity(username: string, connection: AgentConnectionSpec, publicKey: SshPublicKey): Promise<AuthenticatedSSHClient | AuthFailure>;
+    disconnect(): Promise<void>;
+    private intoAuthenticated;
+}
+export declare class AuthenticatedSSHClient extends Destructible {
+    private client;
+    private events;
+    readonly disconnect$: Observable<void>;
+    readonly x11ChannelOpen$: Observable<X11ChannelOpenEvent>;
+    readonly tcpChannelOpen$: Observable<TCPChannelOpenEvent>;
+    readonly agentChannelOpen$: Observable<NewChannel>;
+    constructor(client: SshClient, events: ClientEventInterface);
+    openSessionChannel(): Promise<NewChannel>;
+    openTCPForwardChannel(options: {
+        addressToConnectTo: string;
+        portToConnectTo: number;
+        originatorAddress: string;
+        originatorPort: number;
+    }): Promise<NewChannel>;
+    forwardTCPPort(addressToBind: string, portToBind: number): Promise<number>;
+    stopForwardingTCPPort(addressToBind: string, portToBind: number): Promise<void>;
+    disconnect(): Promise<void>;
+    activateChannel(ch: NewChannel): Promise<Channel>;
+    activateSFTP(ch: NewChannel): Promise<SFTP>;
+    private wrapChannel;
+}
+export { KeyboardInteractiveAuthenticationPrompt, SshPublicKey, SshTransport, SshChannel, NewSshChannel, SftpFileType as SFTPFileType, supportedCiphers as getSupportedCiphers, supportedKexAlgorithms as getSupportedKexAlgorithms, supportedMacs as getSupportedMACs, supportedCompressionAlgorithms as getSupportedCompressionAlgorithms, supportedKeyTypes as getSupportedKeyTypes, OPEN_APPEND, OPEN_CREATE, OPEN_READ, OPEN_TRUNCATE, OPEN_WRITE, SftpFile as SFTPFile, isPageantRunning, HashAlgorithm, parsePublicKey, } from './native';
+export { SFTP, SFTPDirectoryEntry, SFTPMetadata, } from './sftp';
+export { AgentConnectionSpec, SSHAgentStream } from './agent';
+export { Channel, NewChannel };

package/lib/index.js

@@ -0,0 +1,242 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewChannel = exports.Channel = exports.SSHAgentStream = exports.SFTP = exports.parsePublicKey = exports.isPageantRunning = exports.SFTPFile = exports.OPEN_WRITE = exports.OPEN_TRUNCATE = exports.OPEN_READ = exports.OPEN_CREATE = exports.OPEN_APPEND = exports.getSupportedKeyTypes = exports.getSupportedCompressionAlgorithms = exports.getSupportedMACs = exports.getSupportedKexAlgorithms = exports.getSupportedCiphers = exports.NewSshChannel = exports.SshChannel = exports.SshTransport = exports.SshPublicKey = exports.KeyboardInteractiveAuthenticationPrompt = exports.AuthenticatedSSHClient = exports.SSHClient = exports.KeyPair = void 0;
+const rxjs_1 = require("rxjs");
+const helpers_1 = require("./helpers");
+const sftp_1 = require("./sftp");
+const channel_1 = require("./channel");
+Object.defineProperty(exports, "Channel", { enumerable: true, get: function () { return channel_1.Channel; } });
+Object.defineProperty(exports, "NewChannel", { enumerable: true, get: function () { return channel_1.NewChannel; } });
+const events_1 = require("./events");
+const native_1 = __importDefault(require("./native"));
+const agent_1 = require("./agent");
+class KeyPair {
+    constructor(inner) {
+        this.inner = inner;
+    }
+    get algorithm() {
+        return this.inner.publicKey().algorithm();
+    }
+    static parse(data, passphrase) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new KeyPair(yield native_1.default.parseKey(data, passphrase));
+        });
+    }
+}
+exports.KeyPair = KeyPair;
+class SSHClient extends helpers_1.Destructible {
+    constructor(client, events) {
+        super();
+        this.client = client;
+        this.events = events;
+        this.disconnect$ = this.events.disconnect$.asObservable();
+        this.banner$ = this.events.banner$.asObservable();
+    }
+    static connect(transport, serverKeyCallback, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const eventInterface = new events_1.ClientEventInterface();
+            const russhClient = yield native_1.default.connect(transport, (_a = config === null || config === void 0 ? void 0 : config.preferred) === null || _a === void 0 ? void 0 : _a.ciphers, (_b = config === null || config === void 0 ? void 0 : config.preferred) === null || _b === void 0 ? void 0 : _b.kex, (_c = config === null || config === void 0 ? void 0 : config.preferred) === null || _c === void 0 ? void 0 : _c.key, (_d = config === null || config === void 0 ? void 0 : config.preferred) === null || _d === void 0 ? void 0 : _d.mac, (_e = config === null || config === void 0 ? void 0 : config.preferred) === null || _e === void 0 ? void 0 : _e.compression, config === null || config === void 0 ? void 0 : config.connectionTimeoutSeconds, config === null || config === void 0 ? void 0 : config.keepaliveIntervalSeconds, (_f = config === null || config === void 0 ? void 0 : config.keepaliveCountMax) !== null && _f !== void 0 ? _f : 3, (_, k) => serverKeyCallback(k), eventInterface.dataCallback, eventInterface.extendedDataCallback, eventInterface.eofCallback, eventInterface.closeCallback, eventInterface.disconnectCallback, eventInterface.x11ChannelOpenCallback, eventInterface.tcpChannelOpenCallback, eventInterface.agentChannelOpenCallback, eventInterface.bannerCallback);
+            eventInterface.disconnect$.subscribe(() => {
+                setTimeout(() => eventInterface.complete());
+            });
+            return new SSHClient(russhClient, eventInterface);
+        });
+    }
+    destruct() {
+        super.destruct();
+    }
+    authenticateNone(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            const result = yield this.client.authenticateNone(username);
+            if (result.success) {
+                return this.intoAuthenticated();
+            }
+            return result;
+        });
+    }
+    authenticateWithPassword(username, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            const result = yield this.client.authenticatePassword(username, password);
+            if (result.success) {
+                return this.intoAuthenticated();
+            }
+            return result;
+        });
+    }
+    _hashAlg(hashAlgorithm) {
+        return hashAlgorithm ? {
+            sha1: 0 /* HashAlgorithm.Sha1 */,
+            sha256: 1 /* HashAlgorithm.Sha256 */,
+            sha512: 2 /* HashAlgorithm.Sha512 */,
+        }[hashAlgorithm] : null;
+    }
+    authenticateWithKeyPair(username, keyPair, hashAlgorithm) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            const result = yield this.client.authenticatePublickey(username, keyPair['inner'], this._hashAlg(hashAlgorithm));
+            if (result.success) {
+                return this.intoAuthenticated();
+            }
+            return result;
+        });
+    }
+    startKeyboardInteractiveAuthentication(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            return yield this.client.startKeyboardInteractiveAuthentication(username);
+        });
+    }
+    continueKeyboardInteractiveAuthentication(responses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            const result = yield this.client.respondToKeyboardInteractiveAuthentication(responses);
+            if (result.state === 'success') {
+                return this.intoAuthenticated();
+            }
+            return result;
+        });
+    }
+    authenticateWithAgent(username, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            const result = yield this.client.authenticateAgent(username, (0, agent_1.makeRusshAgentConnection)(connection), null);
+            if (result.success) {
+                return this.intoAuthenticated();
+            }
+            return result;
+        });
+    }
+    /**
+     * Authenticate using SSH agent with a specific public key identity.
+     * This is useful when you have multiple keys in the agent and want to use a specific one,
+     * avoiding the server's authentication attempt limit.
+     * @param username SSH username
+     * @param connection Agent connection specification
+     * @param publicKey The specific public key to use for authentication
+     */
+    authenticateWithAgentIdentity(username, connection, publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            const result = yield this.client.authenticateAgent(username, (0, agent_1.makeRusshAgentConnection)(connection), publicKey);
+            if (result.success) {
+                return this.intoAuthenticated();
+            }
+            return result;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.destruct();
+            yield this.client.disconnect();
+        });
+    }
+    intoAuthenticated() {
+        this.destruct();
+        return new AuthenticatedSSHClient(this.client, this.events);
+    }
+}
+exports.SSHClient = SSHClient;
+class AuthenticatedSSHClient extends helpers_1.Destructible {
+    constructor(client, events) {
+        super();
+        this.client = client;
+        this.events = events;
+        this.disconnect$ = this.events.disconnect$;
+        this.x11ChannelOpen$ = this.events.x11ChannelOpen$.pipe((0, rxjs_1.map)(([ch, address, port]) => ({
+            channel: new channel_1.NewChannel(ch),
+            clientAddress: address,
+            clientPort: port,
+        })));
+        this.tcpChannelOpen$ = this.events.tcpChannelOpen$.pipe((0, rxjs_1.map)(([ch, targetAddress, targetPort, clientAddress, clientPort,]) => ({
+            channel: new channel_1.NewChannel(ch),
+            targetAddress,
+            targetPort,
+            clientAddress,
+            clientPort,
+        })));
+        this.agentChannelOpen$ = this.events.agentChannelOpen$.pipe((0, rxjs_1.map)(([ch]) => new channel_1.NewChannel(ch)));
+    }
+    openSessionChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield new channel_1.NewChannel(yield this.client.channelOpenSession());
+        });
+    }
+    openTCPForwardChannel(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new channel_1.NewChannel(yield this.client.channelOpenDirectTcpip(options.addressToConnectTo, options.portToConnectTo, options.originatorAddress, options.originatorPort));
+        });
+    }
+    forwardTCPPort(addressToBind, portToBind) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.tcpipForward(addressToBind, portToBind);
+        });
+    }
+    stopForwardingTCPPort(addressToBind, portToBind) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.cancelTcpipForward(addressToBind, portToBind);
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.destruct();
+            yield this.client.disconnect();
+        });
+    }
+    activateChannel(ch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let channel = yield ch.take().activate();
+            return this.wrapChannel(channel);
+        });
+    }
+    activateSFTP(ch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let channel = yield ch.take().activateSftp();
+            return new sftp_1.SFTP(channel, this.events);
+        });
+    }
+    wrapChannel(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let id = yield channel.id();
+            return new channel_1.Channel(id, channel, this.events);
+        });
+    }
+}
+exports.AuthenticatedSSHClient = AuthenticatedSSHClient;
+var native_2 = require("./native");
+Object.defineProperty(exports, "KeyboardInteractiveAuthenticationPrompt", { enumerable: true, get: function () { return native_2.KeyboardInteractiveAuthenticationPrompt; } });
+Object.defineProperty(exports, "SshPublicKey", { enumerable: true, get: function () { return native_2.SshPublicKey; } });
+Object.defineProperty(exports, "SshTransport", { enumerable: true, get: function () { return native_2.SshTransport; } });
+Object.defineProperty(exports, "SshChannel", { enumerable: true, get: function () { return native_2.SshChannel; } });
+Object.defineProperty(exports, "NewSshChannel", { enumerable: true, get: function () { return native_2.NewSshChannel; } });
+Object.defineProperty(exports, "getSupportedCiphers", { enumerable: true, get: function () { return native_2.supportedCiphers; } });
+Object.defineProperty(exports, "getSupportedKexAlgorithms", { enumerable: true, get: function () { return native_2.supportedKexAlgorithms; } });
+Object.defineProperty(exports, "getSupportedMACs", { enumerable: true, get: function () { return native_2.supportedMacs; } });
+Object.defineProperty(exports, "getSupportedCompressionAlgorithms", { enumerable: true, get: function () { return native_2.supportedCompressionAlgorithms; } });
+Object.defineProperty(exports, "getSupportedKeyTypes", { enumerable: true, get: function () { return native_2.supportedKeyTypes; } });
+Object.defineProperty(exports, "OPEN_APPEND", { enumerable: true, get: function () { return native_2.OPEN_APPEND; } });
+Object.defineProperty(exports, "OPEN_CREATE", { enumerable: true, get: function () { return native_2.OPEN_CREATE; } });
+Object.defineProperty(exports, "OPEN_READ", { enumerable: true, get: function () { return native_2.OPEN_READ; } });
+Object.defineProperty(exports, "OPEN_TRUNCATE", { enumerable: true, get: function () { return native_2.OPEN_TRUNCATE; } });
+Object.defineProperty(exports, "OPEN_WRITE", { enumerable: true, get: function () { return native_2.OPEN_WRITE; } });
+Object.defineProperty(exports, "SFTPFile", { enumerable: true, get: function () { return native_2.SftpFile; } });
+Object.defineProperty(exports, "isPageantRunning", { enumerable: true, get: function () { return native_2.isPageantRunning; } });
+Object.defineProperty(exports, "parsePublicKey", { enumerable: true, get: function () { return native_2.parsePublicKey; } });
+var sftp_2 = require("./sftp");
+Object.defineProperty(exports, "SFTP", { enumerable: true, get: function () { return sftp_2.SFTP; } });
+var agent_2 = require("./agent");
+Object.defineProperty(exports, "SSHAgentStream", { enumerable: true, get: function () { return agent_2.SSHAgentStream; } });

package/lib/native.d.ts

@@ -0,0 +1,143 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export const enum AgentConnectionKind {
+  Pageant = 0,
+  Pipe = 1,
+  Unix = 2
+}
+function connectAgent(connection: AgentConnection, callback: ((err: Error | null, arg: Uint8Array) => any)): Promise<SshAgentStream>
+export const enum HashAlgorithm {
+  Sha1 = 0,
+  Sha256 = 1,
+  Sha512 = 2
+}
+function parseKey(data: string, password?: string | undefined | null): SshKeyPair
+function isPageantRunning(): boolean
+/** Parse a public key from OpenSSH format string (e.g., "ssh-ed25519 AAAA... comment") */
+function parsePublicKey(data: string): SshPublicKey
+export const OPEN_READ: number
+export const OPEN_WRITE: number
+export const OPEN_APPEND: number
+export const OPEN_CREATE: number
+export const OPEN_TRUNCATE: number
+export const enum SftpFileType {
+  Directory = 0,
+  File = 1,
+  Symlink = 2,
+  Other = 3
+}
+function supportedCiphers(): Array<string>
+function supportedKexAlgorithms(): Array<string>
+function supportedMacs(): Array<string>
+function supportedCompressionAlgorithms(): Array<string>
+function supportedKeyTypes(): Array<string>
+function connect(transport: SshTransport, cipherAlgos: Array<string> | undefined | null, kexAlgos: Array<string> | undefined | null, keyAlgos: Array<string> | undefined | null, macAlgos: Array<string> | undefined | null, compressionAlgos: Array<string> | undefined | null, connectionTimeoutSeconds: number | undefined | null, keepaliveIntervalSeconds: number | undefined | null, keepaliveMax: number, serverKeyCallback: ((err: Error | null, arg: SshPublicKey) => Promise<boolean>), dataCallback: ((err: Error | null, arg0: number, arg1: Uint8Array) => any), extendedDataCallback: ((err: Error | null, arg0: number, arg1: number, arg2: Uint8Array) => any), eofCallback: ((err: Error | null, arg: number) => any), closeCallback: ((err: Error | null, arg: number) => any), disconnectCallback: ((err: Error | null, arg: Error | undefined | null) => any), x11ChannelOpenCallback: ((err: Error | null, arg0: NewSshChannel, arg1: string, arg2: number) => any), tcpipChannelOpenCallback: ((err: Error | null, arg0: NewSshChannel, arg1: string, arg2: number, arg3: string, arg4: number) => any), agentChannelOpenCallback: ((err: Error | null, arg: NewSshChannel) => any), bannerCallback: ((err: Error | null, arg: string) => any)): Promise<SshClient>
+export class AgentConnection {
+  kind: AgentConnectionKind
+  path?: string
+  static new(kind: AgentConnectionKind, path?: string | undefined | null): AgentConnection
+}
+export class SshAgentStream {
+  write(data: Uint8Array): Promise<void>
+  close(): Promise<void>
+}
+export class NewSshChannel {
+  activate(): Promise<SshChannel>
+  activateSftp(): Promise<SftpChannel>
+}
+export class SshChannel {
+  id(): Promise<number>
+  requestPty(term: string, colWidth: number, rowHeight: number, pixWidth: number, pixHeight: number): Promise<void>
+  requestShell(): Promise<void>
+  requestExec(command: string): Promise<void>
+  requestX11Forwarding(singleConnection: boolean, x11Protocol: string, x11Cookie: string, screen: number): Promise<void>
+  requestAgentForwarding(): Promise<void>
+  windowChange(colWidth: number, rowHeight: number, pixWidth: number, pixHeight: number): Promise<void>
+  data(data: Uint8Array): Promise<void>
+  eof(): Promise<void>
+  close(): Promise<void>
+}
+export class SshPublicKey {
+  algorithm(): string
+  fingerprint(): string
+  base64(): string
+  bytes(): Uint8Array
+}
+export class SshKeyPair {
+  publicKey(): SshPublicKey
+}
+export class SftpFileMetadata {
+  size: string
+  uid?: number
+  user?: string
+  gid?: number
+  group?: string
+  permissions?: number
+  atime?: number
+  mtime?: number
+  type(): SftpFileType
+}
+export class SftpDirEntry {
+  name: string
+  type: SftpFileType
+  metadata(): SftpFileMetadata
+}
+export class SftpFile {
+  read(n: number): Promise<Uint8Array>
+  writeAll(data: Uint8Array): Promise<void>
+  flush(): Promise<void>
+  shutdown(): Promise<void>
+}
+export class SftpChannel {
+  channelId: number
+  readDir(path: string): Promise<Array<SftpDirEntry>>
+  stat(path: string): Promise<SftpFileMetadata>
+  createDir(path: string): Promise<void>
+  readlink(path: string): Promise<string>
+  rename(src: string, dst: string): Promise<void>
+  chmod(path: string, mode: number): Promise<void>
+  removeDir(path: string): Promise<void>
+  removeFile(path: string): Promise<void>
+  close(): Promise<void>
+  open(path: string, mode: number): Promise<SftpFile>
+}
+export class SshTransport {
+  static newSocket(address: string): Promise<SshTransport>
+  static newCommand(command: string, args: Array<string>): Promise<SshTransport>
+  static newSshChannel(channel: NewSshChannel): Promise<SshTransport>
+  static newSocksProxy(proxyHost: string, proxyPort: number, targetHost: string, targetPort: number): Promise<SshTransport>
+  static newHttpProxy(proxyHost: string, proxyPort: number, targetHost: string, targetPort: number): Promise<SshTransport>
+}
+export class KeyboardInteractiveAuthenticationPrompt {
+  prompt: string
+  echo: boolean
+}
+export class KeyboardInteractiveAuthenticationState {
+  state: string
+  partialSuccess: boolean
+  name?: string
+  instructions?: string
+  remainingMethods: Array<string>
+  prompts(): Array<KeyboardInteractiveAuthenticationPrompt> | null
+}
+export class SshAuthResult {
+  success: boolean
+  partialSuccess: boolean
+  remainingMethods: Array<string>
+}
+export class SshClient {
+  authenticateNone(username: string): Promise<SshAuthResult>
+  authenticatePassword(username: string, password: string): Promise<SshAuthResult>
+  authenticatePublickey(username: string, key: SshKeyPair, hashAlgorithm?: HashAlgorithm | undefined | null): Promise<SshAuthResult>
+  startKeyboardInteractiveAuthentication(username: string): Promise<KeyboardInteractiveAuthenticationState>
+  respondToKeyboardInteractiveAuthentication(responses: Array<string>): Promise<KeyboardInteractiveAuthenticationState>
+  authenticateAgent(username: string, connection: AgentConnection, specificKey?: SshPublicKey | undefined | null): Promise<SshAuthResult>
+  channelOpenSession(): Promise<NewSshChannel>
+  tcpipForward(address: string, port: number): Promise<number>
+  cancelTcpipForward(address: string, port: number): Promise<void>
+  channelOpenDirectTcpip(address: string, port: number, originatorAddress: string, originatorPort: number): Promise<NewSshChannel>
+  disconnect(): Promise<void>
+}

package/lib/native.js

@@ -0,0 +1,25 @@
+let _russh
+
+const nativeModule = process.env.RUST_TARGET_TRIPLE || {
+    win32: {
+        x64: 'win32-x64-msvc',
+        arm64: 'win32-arm64-msvc'
+    },
+    darwin: {
+        x64: 'darwin-x64',
+        arm64: 'darwin-arm64'
+    },
+    linux: {
+        x64: 'linux-x64-gnu',
+        arm: 'linux-arm-gnueabihf',
+        arm64: 'linux-arm64-gnu'
+    }
+}[process.platform][process.arch]
+
+// try {
+_russh = require(`../russh.${nativeModule}.node`)
+// } catch {
+//     _russh = require('../russh.node')
+// }
+
+module.exports = _russh

package/lib/sftp.d.ts

@@ -0,0 +1,34 @@
+import * as russh from './native';
+import { ClientEventInterface } from './events';
+import { Destructible } from "./helpers";
+export interface SFTPMetadata {
+    size: number;
+    type: russh.SftpFileType;
+    uid?: number;
+    user?: string;
+    gid?: number;
+    group?: string;
+    permissions?: number;
+    atime?: number;
+    mtime?: number;
+}
+export interface SFTPDirectoryEntry {
+    name: string;
+    metadata: SFTPMetadata;
+}
+export declare class SFTP extends Destructible {
+    private inner;
+    private events;
+    readonly closed$: import("rxjs").Observable<void>;
+    constructor(inner: russh.SftpChannel, events: ClientEventInterface);
+    createDirectory(path: string): Promise<void>;
+    removeDirectory(path: string): Promise<void>;
+    removeFile(path: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+    rename(src: string, dst: string): Promise<void>;
+    stat(path: string): Promise<SFTPMetadata>;
+    readDirectory(path: string): Promise<SFTPDirectoryEntry[]>;
+    chmod(path: string, mode: string | number): Promise<void>;
+    close(): Promise<void>;
+    open(path: string, mode: number): Promise<russh.SftpFile>;
+}

package/lib/sftp.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SFTP = void 0;
+const helpers_1 = require("./helpers");
+class SFTP extends helpers_1.Destructible {
+    constructor(inner, events) {
+        super();
+        this.inner = inner;
+        this.events = events;
+        this.closed$ = this.events.close$.subscribe(this.inner.channelId);
+        // Trigger subscriptions to stop buffering data
+        this.events.data$.subscribe(this.inner.channelId).subscribe().unsubscribe();
+        this.events.extendedData$.subscribe(this.inner.channelId).subscribe().unsubscribe();
+    }
+    createDirectory(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            yield this.inner.createDir(path);
+        });
+    }
+    removeDirectory(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            yield this.inner.removeDir(path);
+        });
+    }
+    removeFile(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            yield this.inner.removeFile(path);
+        });
+    }
+    readlink(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            return this.inner.readlink(path);
+        });
+    }
+    rename(src, dst) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            yield this.inner.rename(src, dst);
+        });
+    }
+    stat(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            const md = yield this.inner.stat(path);
+            return Object.assign(Object.assign({}, md), { type: md.type(), size: parseInt(md.size) });
+        });
+    }
+    readDirectory(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            let entries = yield this.inner.readDir(path);
+            return entries.map(e => {
+                const md = e.metadata();
+                return {
+                    name: e.name,
+                    metadata: {
+                        // Can't just spread a napi object
+                        type: e.type,
+                        size: parseInt(md.size),
+                        atime: md.atime,
+                        mtime: md.mtime,
+                        gid: md.gid,
+                        group: md.group,
+                        permissions: md.permissions,
+                        uid: md.uid,
+                        user: md.user,
+                    },
+                };
+            });
+        });
+    }
+    chmod(path, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertNotDestructed();
+            let parsed = typeof mode === 'string' ? parseInt(mode, 8) : mode;
+            yield this.inner.chmod(path, parsed);
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.inner.close();
+        });
+    }
+    open(path, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const f = yield this.inner.open(path, mode);
+            return f;
+        });
+    }
+}
+exports.SFTP = SFTP;