hivessh
Version:
HiveSsh is an innovative library designed to streamline SSH2 connections and simplify task execution on Linux servers.
218 lines • 28.3 kB
JavaScript
import { ExecSession } from "./ExecSession.js";
import { handleHops } from "./HostHop.js";
import { execSshChannel } from "./SshExec.js";
import { loadSettings } from "./SshHostOptions.js";
import { tunnelOut } from "./SshTunnel.js";
import { getApm } from "./apm/apm.js";
import { fetchOsRelease } from "./essentials/OsRelease.js";
import { createSFTPPromiseWrapper } from "./essentials/SftpPromiseWrapper.js";
import { trimAll } from "./utils/base.js";
export class SshHost {
settings;
closeErr;
connected = false;
ssh = undefined;
sftp = undefined;
release = undefined;
/**
*
* @description The only public function to create a SshHost object.
* @param options Connection options for the ssh host
* @returns A promise that resolves when the connection is established and the promise provides you an SshHost object
*/
static async connect(options) {
const host = new SshHost(await loadSettings(options));
await host.connect();
return host;
}
constructor(settings) {
this.settings = settings;
}
async connect() {
this.ssh = await handleHops(this.settings);
this.connected = true;
this.ssh.on("close", () => {
this.emergencyClose(new Error("Ssh2 client closed!"));
});
this.ssh.on("end", () => {
this.emergencyClose(new Error("Ssh2 client end!"));
});
this.ssh.on("timeout", () => {
this.emergencyClose(new Error("Ssh2 client connection timeout!"));
});
this.ssh.on("error", (err) => {
this.emergencyClose(err);
});
const sftpWrapper = await new Promise((res, rej) => this.ssh.sftp((err, sftpClient) => err ? rej(err) : res(sftpClient)));
this.sftp = createSFTPPromiseWrapper(sftpWrapper);
}
emergencyClose(err) {
if (typeof err == "string") {
err = new Error(err);
}
this.connected = false;
if (!this.closeErr) {
this.closeErr = err;
}
this.ssh.destroy();
}
/**
* @description If the SshHost socket is closed because of an error this method throws that error.
* @throws Ssh socket close reason
*/
throwCloseError() {
if (!this.connected) {
if (this.closeErr) {
throw this.closeErr;
}
throw new Error("SshHost is not connected!");
}
}
/**
* @deprecated Use disconnect()
* @description Closes the ssh socket if still connected
*/
close() {
if (this.connected) {
this.ssh.end();
}
this.connected = false;
}
/**
* @description Closes the ssh socket if still connected
*/
disconnect() {
if (this.connected) {
this.ssh.end();
}
this.connected = false;
}
/**
*
* @param cmd Command string to execute
* @param options Command channel execution options
* @description Opens a ssh channel to handle a command execution by yourself
* @returns A promise that resolves when the command begins execution and the promise provides you with the SshChannel to process the command output
*/
execChannel(cmd, options) {
this.throwCloseError();
return execSshChannel(this.ssh, cmd, options);
}
/**
*
* @param cmd Command string to execute
* @param options Command execution options
* @description Opens an SSH channel to execute the command and resolves the promise as soon as the exit code is available for the executed command
* @returns A promise that resolves when the command begins execution and the promise provides you the process some runtime, stdout, stderr and some exit data
*/
async exec(cmd, options) {
this.throwCloseError();
try {
const channel = await execSshChannel(this.ssh, cmd, options);
return await channel.toPromise(options);
}
catch (err) {
if (err instanceof Error &&
err.message == "Ssh channel closed, check why the socket was closed or lost connection") {
this.throwCloseError();
}
throw err;
}
}
/**
*
* @description Opens a ssh shell channel to handle the shell by yourself
* @returns A promise that resolves when the shell is started and the promise provides you with a session channel
*/
shellChannel() {
return new Promise((res, rej) => this.ssh.shell((err, channel) => err ?
rej(err) :
res(channel)));
}
/**
*
* @param pwd Inital path of the session
* @param sudo Defines if commands should be prefied as sudo
* @param timeoutMillis Default command timeout milliseconds
* @returns The new created ExecSession object
*/
session(pwd, sudo, timeoutMillis) {
const session = new ExecSession(this, {
PWD: pwd,
});
session.sudo = sudo;
session.timeoutMillis = timeoutMillis;
return session;
}
async homeDir() {
const result = await this.exec("pwd");
return trimAll(result.out);
}
/**
*
* @param cmd Command to check if it cmdExists
* @description Function that checks if a spisific command exists on the remote ssh host
* @returns True if command exists and false if not
*/
async cmdExists(cmd) {
this.throwCloseError();
if (cmd.includes(" ")) {
throw new Error("Command cant contain a space: '" + cmd + "'");
}
const exit = await this.exec("command -v " + cmd, {
expectedExitCode: [0, 1]
});
return exit.code == 0;
}
cachedOsRelease;
/**
*
* @description Resolves all releases files from '/etc/*-release' on the remove ssh host and maps them. Also tries to detect the distro name and version.
* @param useCache The return value of this function get cached for the next function call. Set this to false to disable the caching.
* @returns Returns an object that maps all values of all '/etc/*-release' files.
*/
fetchOsRelease(useCache = true) {
this.throwCloseError();
if (useCache &&
this.cachedOsRelease) {
return this.cachedOsRelease;
}
return fetchOsRelease(this).then((release) => {
return this.cachedOsRelease = release;
});
}
cachedApm;
/**
* @deprecated Check your self
* @description Checks one of the predefined package mangers is installed (apt, dnf, yum or a custom one) and returns a abstract interface for that package manager.
* @param useCache The return value of this function get cached for the next function call. Set this to false to disable the caching.
* @throws Throws an error if the package manager cant be detected.
* @returns The abstract interface of the hosts package manager (if found).
*/
getApm(useCache = true) {
this.throwCloseError();
if (useCache &&
this.cachedApm) {
return this.cachedApm;
}
return getApm(this).then((apm) => {
return this.cachedApm = apm;
});
}
/**
* @experimental This function is experimental and may not be stable.
* Creates a local server that tunnels incoming connections to a remote linux socket or host and port bind.
*
* You need to close the server to stop tunneling!
*
* This function creates a server that listens for incoming connections and forwards them to the remote SSH host.
*
* @param tunnelOptions - Options specifying remote linux socket or host and port details.
*
* @returns A promise that resolves to the created server that need to be closed.
*/
tunnelOut(tunnelOptions) {
return tunnelOut(this.ssh, tunnelOptions);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SshHost.js","sourceRoot":"","sources":["../src/SshHost.ts"],"names":[],"mappings":"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","sourcesContent":["import net from \"net\"\nimport { ClientChannel, ClientErrorExtensions, SFTPWrapper, Client as SshClient } from \"ssh2\"\nimport { ExecSession } from \"./ExecSession.js\"\nimport { handleHops } from \"./HostHop.js\"\nimport { CmdChannelOptions, CmdExecOptions, SshChannel, SshChannelExit, execSshChannel } from \"./SshExec.js\"\nimport { SshHostOptions, SshHostSettings, loadSettings } from \"./SshHostOptions.js\"\nimport { SshTunnelOutOptions, tunnelOut } from \"./SshTunnel.js\"\nimport { AbstractPackageManager, getApm } from \"./apm/apm.js\"\nimport { OsRelease, fetchOsRelease } from \"./essentials/OsRelease.js\"\nimport { SFTPPromiseWrapper, createSFTPPromiseWrapper } from \"./essentials/SftpPromiseWrapper.js\"\nimport { Awaitable, trimAll } from \"./utils/base.js\"\n\nexport class SshHost {\n    closeErr?: Error | string\n    connected: boolean = false\n    ssh: SshClient = undefined as any\n    sftp: SFTPPromiseWrapper = undefined as any\n    release: OsRelease = undefined as any\n\n    /**\n     * \n     * @description The only public function to create a SshHost object.\n     * @param options Connection options for the ssh host\n     * @returns A promise that resolves when the connection is established and the promise provides you an SshHost object\n     */\n    static async connect(\n        options: SshHostOptions,\n    ): Promise<SshHost> {\n        const host = new SshHost(\n            await loadSettings(options)\n        )\n        await host.connect()\n        return host\n    }\n\n    private constructor(\n        public settings: SshHostSettings\n    ) { }\n\n    private async connect(): Promise<void> {\n        this.ssh = await handleHops(this.settings)\n        this.connected = true\n\n        this.ssh.on(\"close\", () => {\n            this.emergencyClose(\n                new Error(\n                    \"Ssh2 client closed!\"\n                )\n            )\n        })\n\n        this.ssh.on(\"end\", () => {\n            this.emergencyClose(\n                new Error(\n                    \"Ssh2 client end!\"\n                )\n            )\n        })\n\n        this.ssh.on(\"timeout\", () => {\n            this.emergencyClose(\n                new Error(\n                    \"Ssh2 client connection timeout!\"\n                )\n            )\n        })\n\n        this.ssh.on(\"error\", (err: Error & ClientErrorExtensions) => {\n            this.emergencyClose(\n                err\n            )\n        })\n\n        const sftpWrapper = await new Promise<SFTPWrapper>(\n            (res, rej) => this.ssh.sftp(\n                (err, sftpClient) => err ? rej(err) : res(sftpClient)\n            )\n        )\n\n        this.sftp = createSFTPPromiseWrapper(sftpWrapper)\n\n\n    }\n\n    private emergencyClose(err: Error | string) {\n        if (typeof err == \"string\") {\n            err = new Error(err)\n        }\n\n        this.connected = false\n        if (!this.closeErr) {\n            this.closeErr = err\n        }\n        this.ssh.destroy()\n    }\n\n    /**\n     * @description If the SshHost socket is closed because of an error this method throws that error. \n     * @throws Ssh socket close reason\n     */\n    throwCloseError(): void | never {\n        if (!this.connected) {\n            if (this.closeErr) {\n                throw this.closeErr\n            }\n\n            throw new Error(\n                \"SshHost is not connected!\"\n            )\n        }\n    }\n\n    /**\n     * @deprecated Use disconnect()\n     * @description Closes the ssh socket if still connected\n     */\n    close(): void {\n        if (this.connected) {\n            this.ssh.end()\n        }\n        this.connected = false\n    }\n\n    /**\n     * @description Closes the ssh socket if still connected\n     */\n    disconnect(): void {\n        if (this.connected) {\n            this.ssh.end()\n        }\n        this.connected = false\n    }\n\n    /**\n     * \n     * @param cmd Command string to execute\n     * @param options Command channel execution options\n     * @description Opens a ssh channel to handle a command execution by yourself\n     * @returns A promise that resolves when the command begins execution and the promise provides you with the SshChannel to process the command output\n     */\n    execChannel(\n        cmd: string,\n        options?: CmdChannelOptions\n    ): Promise<SshChannel> {\n        this.throwCloseError()\n\n        return execSshChannel(\n            this.ssh,\n            cmd,\n            options\n        )\n    }\n\n    /**\n     * \n     * @param cmd Command string to execute\n     * @param options Command execution options\n     * @description Opens an SSH channel to execute the command and resolves the promise as soon as the exit code is available for the executed command\n     * @returns A promise that resolves when the command begins execution and the promise provides you the process some runtime, stdout, stderr and some exit data\n     */\n    async exec(\n        cmd: string,\n        options?: CmdExecOptions\n    ): Promise<SshChannelExit> {\n        this.throwCloseError()\n\n        try {\n            const channel = await execSshChannel(\n                this.ssh,\n                cmd,\n                options\n            )\n\n            return await channel.toPromise(\n                options\n            )\n        } catch (err) {\n            if (\n                err instanceof Error &&\n                err.message == \"Ssh channel closed, check why the socket was closed or lost connection\"\n            ) {\n                this.throwCloseError()\n            }\n\n            throw err\n        }\n    }\n\n    /**\n     * \n     * @description Opens a ssh shell channel to handle the shell by yourself\n     * @returns A promise that resolves when the shell is started and the promise provides you with a session channel\n     */\n    shellChannel(): Promise<ClientChannel> {\n        return new Promise<ClientChannel>(\n            (res, rej) => this.ssh.shell(\n                (err, channel) =>\n                    err ?\n                        rej(err) :\n                        res(channel)\n            )\n        )\n    }\n\n    /**\n     * \n     * @param pwd Inital path of the session\n     * @param sudo Defines if commands should be prefied as sudo\n     * @param timeoutMillis Default command timeout milliseconds\n     * @returns The new created ExecSession object\n     */\n    session(\n        pwd: string,\n        sudo?: boolean,\n        timeoutMillis?: number,\n    ): ExecSession {\n        const session = new ExecSession(\n            this,\n            {\n                PWD: pwd,\n            }\n        )\n\n        session.sudo = sudo\n        session.timeoutMillis = timeoutMillis\n\n        return session\n    }\n\n    async homeDir(): Promise<string> {\n        const result = await this.exec(\"pwd\")\n        return trimAll(result.out)\n    }\n\n    /**\n     * \n     * @param cmd Command to check if it cmdExists\n     * @description Function that checks if a spisific command exists on the remote ssh host\n     * @returns True if command exists and false if not\n     */\n    async cmdExists(\n        cmd: string\n    ): Promise<boolean> {\n        this.throwCloseError()\n\n        if (cmd.includes(\" \")) {\n            throw new Error(\"Command cant contain a space: '\" + cmd + \"'\")\n        }\n\n        const exit = await this.exec(\"command -v \" + cmd, {\n            expectedExitCode: [0, 1]\n        })\n\n        return exit.code == 0\n    }\n\n    cachedOsRelease: OsRelease | undefined\n\n    /**\n     * \n     * @description Resolves all releases files from '/etc/*-release' on the remove ssh host and maps them. Also tries to detect the distro name and version.\n     * @param useCache The return value of this function get cached for the next function call. Set this to false to disable the caching.\n     * @returns Returns an object that maps all values of all '/etc/*-release' files.\n     */\n    fetchOsRelease(\n        useCache: boolean = true,\n    ): Awaitable<OsRelease> {\n        this.throwCloseError()\n\n        if (\n            useCache &&\n            this.cachedOsRelease\n        ) {\n            return this.cachedOsRelease\n        }\n\n        return fetchOsRelease(\n            this\n        ).then((release) => {\n            return this.cachedOsRelease = release\n        })\n    }\n\n\n\n    cachedApm: AbstractPackageManager | undefined\n\n    /**\n     * @deprecated Check your self\n     * @description Checks one of the predefined package mangers is installed (apt, dnf, yum or a custom one) and returns a abstract interface for that package manager.\n     * @param useCache The return value of this function get cached for the next function call. Set this to false to disable the caching.\n     * @throws Throws an error if the package manager cant be detected.\n     * @returns The abstract interface of the hosts package manager (if found).\n     */\n    getApm(\n        useCache: boolean = true,\n    ): Awaitable<AbstractPackageManager> {\n        this.throwCloseError()\n\n        if (\n            useCache &&\n            this.cachedApm\n        ) {\n            return this.cachedApm\n        }\n\n        return getApm(\n            this\n        ).then((apm) => {\n            return this.cachedApm = apm\n        })\n    }\n\n    /**\n     * @experimental This function is experimental and may not be stable.\n     * Creates a local server that tunnels incoming connections to a remote linux socket or host and port bind.\n     *\n     * You need to close the server to stop tunneling!\n     * \n     * This function creates a server that listens for incoming connections and forwards them to the remote SSH host. \n     * \n     * @param tunnelOptions - Options specifying remote linux socket or host and port details.\n     * \n     * @returns A promise that resolves to the created server that need to be closed.\n     */\n    tunnelOut(\n        tunnelOptions: SshTunnelOutOptions,\n    ): Promise<net.Server> {\n        return tunnelOut(\n            this.ssh,\n            tunnelOptions\n        )\n    }\n}"]}