hivessh
Version:
HiveSsh is an innovative library designed to streamline SSH2 connections and simplify task execution on Linux servers.
149 lines • 21.1 kB
JavaScript
import net from "net";
/**
* Returns true if the given options are for a local socket (i.e. path is present).
*
* @param options - The options to check.
* @returns True if the options are for a local socket, otherwise false.
*/
export function isSshTunnelOutLocalSocketOption(options) {
return typeof options == "object" &&
options != null &&
typeof options.localPath == "string";
}
/**
* Returns true if the given options are for a remote socket (i.e. remotePath is present).
*
* @param options - The options to check.
* @returns True if the options are for a remote socket, otherwise false.
*/
export function isSshTunnelOutRemoteSocketOption(options) {
return typeof options == "object" &&
options != null &&
typeof options.remotePath == "string";
}
/**
* @experimental This function is experimental and may not be stable.
* Tunnels incoming server socket conntions to a remote host and port bind (not linux socket).
*
* This function establishes an SSH tunnel by forwarding
* a local server's address and port to a specified remote
* host and port. It manages the connection and lifecycle of
* the tunnel, ensuring that resources are cleaned up upon
* closure of the server or socket.
*
* @param sshClient - The SSH client instance used to establish the tunnel.
* @param server - The local server for which the tunnel is being created.
* @param socket - The socket associated with the server.
* @param tunnelOptions - Options specifying remote host and port details
* and optional forwarding source host and port.
*
* @throws {Error} If the server's socket address is invalid.
*/
export function handleRemoteHostPortOutTunnel(sshClient, server, socket, tunnelOptions) {
const address = server.address();
if (typeof address.address != "string" ||
typeof address.family != "string" ||
typeof address.port != "number") {
throw new Error("Invalid server socket address: " +
JSON.stringify(address, null, 2));
}
sshClient.forwardOut(tunnelOptions.forwardSourceHost ??
address.address, tunnelOptions.forwardSourcePort ??
address.port, tunnelOptions.remoteHost, tunnelOptions.remotePort, (err, clientChannel) => {
if (err) {
server.emit("error", err);
return;
}
server.on('close', () => {
if (!clientChannel.closed) {
clientChannel.end();
}
if (!socket.closed) {
socket.end();
}
});
socket.pipe(clientChannel).pipe(socket);
});
}
/**
* @experimental This function is experimental and may not be stable.
* Tunnels incoming server socket conntions to a remote socket (not address and port bind) using openssh.
*
* This function establishes an SSH tunnel by forwarding
* a local server's address and port to a specified remote
* socket path. It manages the connection and lifecycle of
* the tunnel, ensuring that resources are cleaned up upon
* closure of the server or socket.
*
* @param sshClient - The SSH client instance used to establish the tunnel.
* @param server - The local server for which the tunnel is being created.
* @param socket - The socket associated with the server.
* @param tunnelOptions - Options specifying remote socket path details
* and optional forwarding source host and port.
*
* @throws {Error} If the server's socket address is invalid.
*/
export function handleRemoteSocketOutTunnel(sshClient, server, socket, tunnelOptions) {
const address = server.address();
if (typeof address.address != "string" ||
typeof address.family != "string" ||
typeof address.port != "number") {
throw new Error("Invalid server socket address: " +
JSON.stringify(address, null, 2));
}
sshClient.openssh_forwardOutStreamLocal(tunnelOptions.remotePath, (err, clientChannel) => {
if (err) {
server.emit("error", err);
return;
}
server.on('close', () => {
if (!clientChannel.closed) {
clientChannel.end();
}
if (!socket.closed) {
socket.end();
}
});
socket.pipe(clientChannel).pipe(socket);
});
}
/**
* @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 sshClient - The SSH client instance used to establish the tunnel.
* @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.
*/
export function tunnelOut(sshClient, tunnelOptions) {
return new Promise((res, rej) => {
let server;
server = net.createServer();
server.on('error', (err) => {
server.close();
rej(err);
});
server.on('connection', isSshTunnelOutRemoteSocketOption(tunnelOptions) ?
(socket) => handleRemoteSocketOutTunnel(sshClient, server, socket, tunnelOptions) :
(socket) => handleRemoteHostPortOutTunnel(sshClient, server, socket, tunnelOptions));
const baseTunnelServerOptions = isSshTunnelOutLocalSocketOption(tunnelOptions) ?
{
path: tunnelOptions.localPath,
} :
{
host: tunnelOptions.localHost,
port: tunnelOptions.localPort,
};
server.listen({
...tunnelOptions,
...baseTunnelServerOptions,
});
res(server);
});
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SshTunnel.js","sourceRoot":"","sources":["../src/SshTunnel.ts"],"names":[],"mappings":"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","sourcesContent":["import net, { type ListenOptions as ServerOptions } from \"net\";\nimport { Client } from \"ssh2\";\n\nexport type LocalHostPortExtraOptions =\n    Omit<\n        Partial<ServerOptions>,\n        \"host\" | \"port\" | \"path\"\n    >\n\nexport type SshTunnelOutLocalHostPort = {\n    localHost: string,\n    localPort: number,\n} & LocalHostPortExtraOptions\n\nexport type SshTunnelOutLocalSocket = {\n    localPath: string,\n} & LocalHostPortExtraOptions\n\nexport interface SshTunnelOutRemoteHostPort {\n    remoteHost: string,\n    remotePort: number,\n    forwardSourceHost?: string\n    forwardSourcePort?: number\n}\n\nexport interface SshTunnelOutRemoteSocket {\n    remotePath: string,\n}\n\nexport type SshTunnelLocalOutOptions =\n    SshTunnelOutLocalHostPort |\n    SshTunnelOutLocalSocket\n\nexport type SshTunnelRemoteOutOptions =\n    SshTunnelOutRemoteHostPort |\n    SshTunnelOutRemoteSocket\n\nexport type SshTunnelOutOptions =\n    SshTunnelLocalOutOptions &\n    SshTunnelRemoteOutOptions\n\n/**\n * Returns true if the given options are for a local socket (i.e. path is present).\n *\n * @param options - The options to check.\n * @returns True if the options are for a local socket, otherwise false.\n */\nexport function isSshTunnelOutLocalSocketOption(\n    options: SshTunnelOutOptions,\n): options is SshTunnelOutLocalSocket & SshTunnelRemoteOutOptions {\n    return typeof options == \"object\" &&\n        options != null &&\n        typeof (options as any).localPath == \"string\"\n}\n\n/**\n * Returns true if the given options are for a remote socket (i.e. remotePath is present).\n *\n * @param options - The options to check.\n * @returns True if the options are for a remote socket, otherwise false.\n */\nexport function isSshTunnelOutRemoteSocketOption(\n    options: SshTunnelOutOptions,\n): options is SshTunnelLocalOutOptions & SshTunnelOutRemoteSocket {\n    return typeof options == \"object\" &&\n        options != null &&\n        typeof (options as any).remotePath == \"string\"\n}\n\n/**\n * @experimental This function is experimental and may not be stable.\n * Tunnels incoming server socket conntions to a remote host and port bind (not linux socket).\n *\n * This function establishes an SSH tunnel by forwarding\n * a local server's address and port to a specified remote\n * host and port. It manages the connection and lifecycle of \n * the tunnel, ensuring that resources are cleaned up upon \n * closure of the server or socket.\n *\n * @param sshClient - The SSH client instance used to establish the tunnel.\n * @param server - The local server for which the tunnel is being created.\n * @param socket - The socket associated with the server.\n * @param tunnelOptions - Options specifying remote host and port details \n *                        and optional forwarding source host and port.\n *\n * @throws {Error} If the server's socket address is invalid.\n */\nexport function handleRemoteHostPortOutTunnel(\n    sshClient: Client,\n    server: net.Server,\n    socket: net.Socket,\n    tunnelOptions: SshTunnelOutRemoteHostPort\n) {\n    const address = server.address() as net.AddressInfo\n    if (\n        typeof address.address != \"string\" ||\n        typeof address.family != \"string\" ||\n        typeof address.port != \"number\"\n    ) {\n        throw new Error(\n            \"Invalid server socket address: \" +\n            JSON.stringify(address, null, 2)\n        )\n    }\n\n    sshClient.forwardOut(\n        tunnelOptions.forwardSourceHost ??\n        address.address,\n        tunnelOptions.forwardSourcePort ??\n        address.port,\n        tunnelOptions.remoteHost,\n        tunnelOptions.remotePort, (err, clientChannel) => {\n            if (err) {\n                server.emit(\"error\", err)\n                return\n            }\n\n            server.on('close', () => {\n                if (!clientChannel.closed) {\n                    clientChannel.end()\n                }\n                if (!socket.closed) {\n                    socket.end()\n                }\n            })\n            socket.pipe(clientChannel).pipe(socket)\n        })\n}\n\n/**\n * @experimental This function is experimental and may not be stable.\n * Tunnels incoming server socket conntions to a remote socket (not address and port bind) using openssh.\n *\n * This function establishes an SSH tunnel by forwarding\n * a local server's address and port to a specified remote\n * socket path. It manages the connection and lifecycle of \n * the tunnel, ensuring that resources are cleaned up upon \n * closure of the server or socket.\n *\n * @param sshClient - The SSH client instance used to establish the tunnel.\n * @param server - The local server for which the tunnel is being created.\n * @param socket - The socket associated with the server.\n * @param tunnelOptions - Options specifying remote socket path details \n *                        and optional forwarding source host and port.\n *\n * @throws {Error} If the server's socket address is invalid.\n */\nexport function handleRemoteSocketOutTunnel(\n    sshClient: Client,\n    server: net.Server,\n    socket: net.Socket,\n    tunnelOptions: SshTunnelOutRemoteSocket\n) {\n    const address = server.address() as net.AddressInfo\n    if (\n        typeof address.address != \"string\" ||\n        typeof address.family != \"string\" ||\n        typeof address.port != \"number\"\n    ) {\n        throw new Error(\n            \"Invalid server socket address: \" +\n            JSON.stringify(address, null, 2)\n        )\n    }\n\n    sshClient.openssh_forwardOutStreamLocal(\n        tunnelOptions.remotePath,\n        (err, clientChannel) => {\n            if (err) {\n                server.emit(\"error\", err)\n                return\n            }\n\n            server.on('close', () => {\n                if (!clientChannel.closed) {\n                    clientChannel.end()\n                }\n                if (!socket.closed) {\n                    socket.end()\n                }\n            })\n            socket.pipe(clientChannel).pipe(socket)\n        }\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 sshClient - The SSH client instance used to establish the tunnel.\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 */\nexport function tunnelOut(\n    sshClient: Client,\n    tunnelOptions: SshTunnelOutOptions,\n): Promise<net.Server> {\n    return new Promise<net.Server>((res, rej) => {\n        let server: net.Server\n\n        server = net.createServer()\n        server.on('error', (err) => {\n            server.close()\n            rej(err)\n        })\n\n        server.on('connection',\n            isSshTunnelOutRemoteSocketOption(tunnelOptions) ?\n                (socket) => handleRemoteSocketOutTunnel(\n                    sshClient,\n                    server,\n                    socket,\n                    tunnelOptions,\n                ) :\n                (socket) => handleRemoteHostPortOutTunnel(\n                    sshClient,\n                    server,\n                    socket,\n                    tunnelOptions,\n                )\n        )\n\n        const baseTunnelServerOptions =\n            isSshTunnelOutLocalSocketOption(tunnelOptions) ?\n                {\n                    path: tunnelOptions.localPath,\n                } :\n                {\n                    host: tunnelOptions.localHost,\n                    port: tunnelOptions.localPort,\n                }\n\n        server.listen({\n            ...tunnelOptions,\n            ...baseTunnelServerOptions,\n        })\n\n        res(server)\n    })\n}\n"]}