mirror of https://github.com/certd/certd
chore:
xiaojunnuo
parent
2c87b3d906
commit
83c2d743bc
|
|
@ -1,35 +0,0 @@
|
|||
export enum errorCode {
|
||||
generic = "ERR_GENERIC_CLIENT",
|
||||
connect = "ERR_NOT_CONNECTED",
|
||||
badPath = "ERR_BAD_PATH",
|
||||
permission = "EACCES",
|
||||
notexist = "ENOENT",
|
||||
notdir = "ENOTDIR",
|
||||
}
|
||||
|
||||
export enum targetType {
|
||||
writeFile = 1,
|
||||
readFile = 2,
|
||||
writeDir = 3,
|
||||
readDir = 4,
|
||||
readObj = 5,
|
||||
writeObj = 6,
|
||||
}
|
||||
|
||||
export const CLIENT_EVENTS = new Set([
|
||||
"banner",
|
||||
"ready",
|
||||
"tcp connection",
|
||||
"x11",
|
||||
"keyboard-interactive",
|
||||
"change password",
|
||||
"error",
|
||||
"end",
|
||||
"close",
|
||||
"timeout",
|
||||
"connect",
|
||||
"greeting",
|
||||
"handshake",
|
||||
"hostkeys",
|
||||
"unix connection",
|
||||
]);
|
||||
|
|
@ -1,568 +0,0 @@
|
|||
import { EventEmitter } from "events";
|
||||
import { mkdirSync, readdirSync, existsSync } from "fs";
|
||||
import { join, win32, posix } from "path";
|
||||
import { Client as SSHClient, ConnectConfig, InputAttributes, SFTPWrapper, Stats, TransferOptions, WriteFileOptions, ParsedKey, UNIXConnectionDetails, AcceptConnection, RejectConnection } from "ssh2";
|
||||
import { targetType } from "./constant.js";
|
||||
import * as utils from "./utils.js";
|
||||
import { ClientEvents } from "./types.js";
|
||||
|
||||
export type TScpOptions = ConnectConfig & {
|
||||
remoteOsType?: "posix" | "win32";
|
||||
events?: ClientEvents;
|
||||
};
|
||||
|
||||
export class ScpClient extends EventEmitter {
|
||||
sftpWrapper: SFTPWrapper | null = null;
|
||||
sshClient: SSHClient | null = null;
|
||||
remotePathSep = posix.sep;
|
||||
endCalled = false;
|
||||
errorHandled = false;
|
||||
|
||||
constructor(options: TScpOptions) {
|
||||
super();
|
||||
|
||||
const ssh = new SSHClient();
|
||||
ssh
|
||||
.on("connect", () => this.emit("connect"))
|
||||
.on("ready", () => {
|
||||
ssh.sftp((err, sftp) => {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
// save for reuse
|
||||
this.sftpWrapper = sftp;
|
||||
this.emit("ready");
|
||||
});
|
||||
})
|
||||
.on("error", err => this.emit("error", err))
|
||||
.on("end", () => this.emit("end"))
|
||||
.on("close", () => {
|
||||
if (!this.endCalled) {
|
||||
this.sftpWrapper = null;
|
||||
}
|
||||
this.emit("close");
|
||||
})
|
||||
.on("keyboard-interactive", (name, instructions, instructionsLang, prompts, finish) => this.emit("keyboard-interactive", name, instructions, instructionsLang, prompts, finish))
|
||||
.on("change password", (message, done) => this.emit("change password", message, done))
|
||||
.on("tcp connection", (details, accept, reject) => this.emit("tcp connection", details, accept, reject))
|
||||
.on("banner", message => this.emit("banner", message))
|
||||
.on("greeting", greeting => this.emit("banner", greeting))
|
||||
.on("handshake", negotiated => this.emit("handshake", negotiated))
|
||||
.on("hostkeys", (keys: ParsedKey[]) => this.emit("hostkeys", keys))
|
||||
.on("timeout", () => this.emit("timeout"))
|
||||
.on("unix connection", (info: UNIXConnectionDetails, accept: AcceptConnection, reject: RejectConnection) => this.emit("unix connection", info, accept, reject))
|
||||
.on("x11", message => this.emit("x11", message));
|
||||
ssh.connect(options);
|
||||
this.sshClient = ssh;
|
||||
|
||||
if (options.remoteOsType === "win32") {
|
||||
this.remotePathSep = win32.sep;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Uploads a file from `localPath` to `remotePath` using parallel reads for faster throughput.
|
||||
*/
|
||||
public async uploadFile(localPath: string, remotePath: string, options: TransferOptions = {}): Promise<void> {
|
||||
utils.haveConnection(this, "uploadFile");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.fastPut(localPath, remotePath, options, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Downloads a file at `remotePath` to `localPath` using parallel reads for faster throughput.
|
||||
*/
|
||||
public async downloadFile(remotePath: string, localPath: string, options: TransferOptions = {}): Promise<void> {
|
||||
utils.haveConnection(this, "downloadFile");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.fastGet(remotePath, localPath, options, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Clean a directory in remote server
|
||||
*/
|
||||
public async emptyDir(dir: string): Promise<void> {
|
||||
utils.haveConnection(this, "uploadDir");
|
||||
try {
|
||||
const isExist = await this.exists(dir);
|
||||
|
||||
if (!isExist) {
|
||||
await this.mkdir(dir);
|
||||
} else if (isExist === "d") {
|
||||
await this.rmdir(dir);
|
||||
await this.mkdir(dir);
|
||||
}
|
||||
} catch (error) {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
public async uploadDir(src: string, dest: string): Promise<void> {
|
||||
utils.haveConnection(this, "uploadDir");
|
||||
try {
|
||||
const isExist = await this.exists(dest);
|
||||
|
||||
if (!isExist) {
|
||||
await this.mkdir(dest);
|
||||
}
|
||||
|
||||
const dirEntries = readdirSync(src, {
|
||||
encoding: "utf8",
|
||||
withFileTypes: true,
|
||||
});
|
||||
|
||||
for (const e of dirEntries) {
|
||||
if (e.isDirectory()) {
|
||||
const newSrc = join(src, e.name);
|
||||
const newDst = utils.joinRemote(this, dest, e.name);
|
||||
await this.uploadDir(newSrc, newDst);
|
||||
} else if (e.isFile()) {
|
||||
const newSrc = join(src, e.name);
|
||||
const newDst = utils.joinRemote(this, dest, e.name);
|
||||
await this.uploadFile(newSrc, newDst);
|
||||
|
||||
// this.client.emit('upload', {source: src, destination: dst})
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
public async downloadDir(remotePath: string, localPath: string) {
|
||||
utils.haveConnection(this, "downloadDir");
|
||||
const remoteInfo: any = await utils.checkRemotePath(this, remotePath, targetType.readDir);
|
||||
if (!remoteInfo.valid) {
|
||||
throw new Error(remoteInfo.msg);
|
||||
}
|
||||
|
||||
if (!existsSync(localPath)) {
|
||||
mkdirSync(localPath);
|
||||
}
|
||||
|
||||
const localInfo = await utils.checkLocalPath(localPath, targetType.writeDir);
|
||||
|
||||
if (localInfo.valid && !localInfo.type) {
|
||||
mkdirSync(localInfo.path, { recursive: true });
|
||||
}
|
||||
|
||||
if (!localInfo.valid) {
|
||||
throw new Error(localInfo.msg);
|
||||
}
|
||||
const fileList = await this.list(remoteInfo.path);
|
||||
for (const f of fileList) {
|
||||
if (f.type === "d") {
|
||||
const newSrc = remoteInfo.path + this.remotePathSep + f.name;
|
||||
const newDst = join(localInfo.path, f.name);
|
||||
await this.downloadDir(newSrc, newDst);
|
||||
} else if (f.type === "-") {
|
||||
const src = remoteInfo.path + this.remotePathSep + f.name;
|
||||
const dst = join(localInfo.path, f.name);
|
||||
await this.downloadFile(src, dst);
|
||||
this.sshClient!.emit("download", { source: src, destination: dst });
|
||||
} else {
|
||||
console.log(`downloadDir: File ignored: ${f.name} not regular file`);
|
||||
}
|
||||
}
|
||||
return `${remoteInfo.path} downloaded to ${localInfo.path}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves attributes for `path`.
|
||||
*/
|
||||
public async stat(remotePath: string): Promise<Stats> {
|
||||
utils.haveConnection(this, "stat");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.stat(remotePath, (err, stats) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve(stats);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the attributes defined in `attributes` for `path`.
|
||||
*/
|
||||
public async setstat(path: string, attributes: InputAttributes = {}): Promise<void> {
|
||||
utils.haveConnection(this, "setstat");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.setstat(path, attributes, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the file/symlink at `path`.
|
||||
*/
|
||||
public async unlink(remotePath: string): Promise<void> {
|
||||
utils.haveConnection(this, "unlink");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.unlink(remotePath, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// _rmdir - only works with an empty directory
|
||||
async _rmdir(remotePath: string): Promise<void> {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
this.sftpWrapper!.rmdir(remotePath, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
public async rmdir(remotePath: string): Promise<void> {
|
||||
const files = await this.list(remotePath);
|
||||
for (const file of files) {
|
||||
const fullFilename = utils.joinRemote(this, remotePath, file.name);
|
||||
if (file.type === "d") {
|
||||
await this.rmdir(fullFilename);
|
||||
} else {
|
||||
await this.unlink(fullFilename);
|
||||
}
|
||||
}
|
||||
await this._rmdir(remotePath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new directory `path`.
|
||||
*/
|
||||
public async mkdir(remotePath: string, attributes: InputAttributes = {}): Promise<void> {
|
||||
utils.haveConnection(this, "mkdir");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.mkdir(remotePath, attributes, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
public async exists(remotePath: string): Promise<string | boolean> {
|
||||
utils.haveConnection(this, "exists");
|
||||
try {
|
||||
const stats = await this.stat(remotePath);
|
||||
|
||||
if (stats.isDirectory()) {
|
||||
return "d";
|
||||
}
|
||||
if (stats.isSymbolicLink()) {
|
||||
return "l";
|
||||
}
|
||||
if (stats.isFile()) {
|
||||
return "-";
|
||||
}
|
||||
return false;
|
||||
} catch (error) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes data to a file
|
||||
*/
|
||||
public async writeFile(remotePath: string, data: string | Buffer, options: WriteFileOptions = {}): Promise<void> {
|
||||
utils.haveConnection(this, "writeFile");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.writeFile(remotePath, data, options, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the access time and modified time for `path`.
|
||||
*/
|
||||
public async utimes(path: string, atime: number | Date, mtime: number | Date): Promise<void> {
|
||||
utils.haveConnection(this, "utimes");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.utimes(path, atime, mtime, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a symlink at `linkPath` to `targetPath`.
|
||||
*/
|
||||
public async symlink(targetPath: string, linkPath: string): Promise<void> {
|
||||
utils.haveConnection(this, "symlink");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.symlink(targetPath, linkPath, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Renames/moves `srcPath` to `destPath`.
|
||||
*/
|
||||
public async rename(srcPath: string, destPath: string): Promise<void> {
|
||||
utils.haveConnection(this, "rename");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.rename(srcPath, destPath, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the target for a symlink at `path`.
|
||||
*/
|
||||
public async readlink(path: string): Promise<string> {
|
||||
utils.haveConnection(this, "readlink");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.readlink(path, (err, target) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve(target);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads a file in memory and returns its contents
|
||||
*/
|
||||
public async readFile(remotePath: string): Promise<Buffer> {
|
||||
utils.haveConnection(this, "readFile");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.readFile(remotePath, (err, handle) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve(handle);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves attributes for `path`. If `path` is a symlink, the link itself is stat'ed
|
||||
* instead of the resource it refers to.
|
||||
*/
|
||||
public async lstat(path: string): Promise<Stats> {
|
||||
utils.haveConnection(this, "lstat");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.lstat(path, (err, stats) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve(stats);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Appends data to a file
|
||||
*/
|
||||
public async appendFile(remotePath: string, data: string | Buffer, options: WriteFileOptions): Promise<void> {
|
||||
utils.haveConnection(this, "appendFile");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.appendFile(remotePath, data, options, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the mode for `path`.
|
||||
*/
|
||||
public async chmod(path: string, mode: number | string): Promise<void> {
|
||||
utils.haveConnection(this, "chmod");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.chmod(path, mode, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the owner for `path`.
|
||||
*/
|
||||
public async chown(path: string, uid: number, gid: number): Promise<void> {
|
||||
utils.haveConnection(this, "chown");
|
||||
return new Promise((resolve, reject) => {
|
||||
this.sftpWrapper!.chown(path, uid, gid, err => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Close SSH connection
|
||||
*/
|
||||
public close() {
|
||||
if (this.sshClient && this.sftpWrapper) {
|
||||
this.sshClient.end();
|
||||
this.sshClient = null;
|
||||
this.sftpWrapper = null;
|
||||
}
|
||||
|
||||
this.endCalled = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* List all files and directories at remotePath
|
||||
*/
|
||||
public async list(remotePath: string, pattern = /.*/): Promise<any> {
|
||||
const _list = (aPath: string, filter: RegExp | string) => {
|
||||
return new Promise((resolve, reject) => {
|
||||
const reg = /-/gi;
|
||||
this.sftpWrapper!.readdir(aPath, (err, fileList) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
let newList: any = [];
|
||||
// reset file info
|
||||
if (fileList) {
|
||||
newList = fileList.map(item => {
|
||||
return {
|
||||
type: item.longname.substr(0, 1),
|
||||
name: item.filename,
|
||||
size: item.attrs.size,
|
||||
modifyTime: item.attrs.mtime * 1000,
|
||||
accessTime: item.attrs.atime * 1000,
|
||||
rights: {
|
||||
user: item.longname.substr(1, 3).replace(reg, ""),
|
||||
group: item.longname.substr(4, 3).replace(reg, ""),
|
||||
other: item.longname.substr(7, 3).replace(reg, ""),
|
||||
},
|
||||
owner: item.attrs.uid,
|
||||
group: item.attrs.gid,
|
||||
};
|
||||
});
|
||||
}
|
||||
// provide some compatibility for auxList
|
||||
let regex: RegExp;
|
||||
if (filter instanceof RegExp) {
|
||||
regex = filter;
|
||||
} else {
|
||||
const newPattern = filter.replace(/\*([^*])*?/gi, ".*");
|
||||
regex = new RegExp(newPattern);
|
||||
}
|
||||
resolve(newList.filter((item: any) => regex.test(item.name)));
|
||||
}
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
utils.haveConnection(this, "list");
|
||||
const pathInfo = await utils.checkRemotePath(this, remotePath, targetType.readDir);
|
||||
if (!pathInfo.valid) {
|
||||
throw new Error("Remote path is invalid");
|
||||
}
|
||||
return _list(pathInfo.path, pattern);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves `path` to an absolute path.
|
||||
*/
|
||||
public realPath(remotePath: string): Promise<string> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const closeListener = utils.makeCloseListener(this, reject, "realPath");
|
||||
this.sshClient!.prependListener("close", closeListener);
|
||||
const errorListener = utils.makeErrorListener(reject, this, "realPath");
|
||||
this.sshClient!.prependListener("error", errorListener);
|
||||
if (utils.haveConnection(this, "realPath", reject)) {
|
||||
this.sftpWrapper!.realpath(remotePath, (err, absPath) => {
|
||||
if (err) {
|
||||
reject(utils.formatError(`${err.message} ${remotePath}`, "realPath"));
|
||||
}
|
||||
resolve(absPath);
|
||||
this.removeListener("error", errorListener);
|
||||
this.removeListener("close", closeListener);
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export async function Client(options: TScpOptions): Promise<ScpClient> {
|
||||
const client = new ScpClient(options);
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
client.on("ready", () => {
|
||||
resolve(client);
|
||||
});
|
||||
|
||||
client.on("error", err => {
|
||||
reject(err);
|
||||
});
|
||||
|
||||
client.on("close", () => {
|
||||
client.removeAllListeners();
|
||||
});
|
||||
|
||||
for (const event in options.events) {
|
||||
client.on(event, (...args) => {
|
||||
(options.events![event as keyof ClientEvents] as (...args: any[]) => void)(...args);
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
export default Client;
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
import type {
|
||||
AcceptConnection,
|
||||
ChangePasswordCallback,
|
||||
ClientChannel,
|
||||
ClientErrorExtensions,
|
||||
KeyboardInteractiveCallback,
|
||||
NegotiatedAlgorithms,
|
||||
ParsedKey,
|
||||
Prompt,
|
||||
RejectConnection,
|
||||
TcpConnectionDetails,
|
||||
UNIXConnectionDetails,
|
||||
X11Details,
|
||||
} from "ssh2";
|
||||
|
||||
export class ErrorCustom extends Error {
|
||||
custom?: boolean;
|
||||
code?: string;
|
||||
level?: string;
|
||||
hostname?: string;
|
||||
address?: string;
|
||||
}
|
||||
export interface CheckResult {
|
||||
path: string;
|
||||
type?: string;
|
||||
valid?: boolean;
|
||||
msg?: string;
|
||||
code?: string;
|
||||
}
|
||||
|
||||
export interface ClientEvents {
|
||||
/**
|
||||
* Emitted when a notice was sent by the server upon connection.
|
||||
*/
|
||||
banner?: (message: string) => void;
|
||||
|
||||
/**
|
||||
* Emitted when authentication was successful.
|
||||
*/
|
||||
ready?: () => void;
|
||||
|
||||
/**
|
||||
* Emitted when an incoming forwarded TCP connection is being requested.
|
||||
*
|
||||
* Calling `accept()` accepts the connection and returns a `Channel` object.
|
||||
* Calling `reject()` rejects the connection and no further action is needed.
|
||||
*/
|
||||
"tcp connection"?: (details: TcpConnectionDetails, accept: AcceptConnection<ClientChannel>, reject: RejectConnection) => void;
|
||||
|
||||
/**
|
||||
* Emitted when an incoming X11 connection is being requested.
|
||||
*
|
||||
* Calling `accept()` accepts the connection and returns a `Channel` object.
|
||||
* Calling `reject()` rejects the connection and no further action is needed.
|
||||
*/
|
||||
x11?: (details: X11Details, accept: AcceptConnection<ClientChannel>, reject: RejectConnection) => void;
|
||||
|
||||
/**
|
||||
* Emitted when the server is asking for replies to the given `prompts` for keyboard-
|
||||
* interactive user authentication.
|
||||
*
|
||||
* * `name` is generally what you'd use as a window title (for GUI apps).
|
||||
* * `prompts` is an array of `Prompt` objects.
|
||||
*
|
||||
* The answers for all prompts must be provided as an array of strings and passed to
|
||||
* `finish` when you are ready to continue.
|
||||
*
|
||||
* NOTE: It's possible for the server to come back and ask more questions.
|
||||
*/
|
||||
"keyboard-interactive"?: (name: string, instructions: string, lang: string, prompts: Prompt[], finish: KeyboardInteractiveCallback) => void;
|
||||
|
||||
/**
|
||||
* Emitted when the server has requested that the user's password be changed, if using
|
||||
* password-based user authentication.
|
||||
*
|
||||
* Call `done` with the new password.
|
||||
*/
|
||||
"change password"?: (message: string, done: ChangePasswordCallback) => void;
|
||||
|
||||
/**
|
||||
* Emitted when an error occurred.
|
||||
*/
|
||||
error?: (err: Error & ClientErrorExtensions) => void;
|
||||
|
||||
/**
|
||||
* Emitted when the socket was disconnected.
|
||||
*/
|
||||
end?: () => void;
|
||||
|
||||
/**
|
||||
* Emitted when the socket was closed.
|
||||
*/
|
||||
close?: () => void;
|
||||
|
||||
/**
|
||||
* Emitted when the socket has timed out.
|
||||
*/
|
||||
timeout?: () => void;
|
||||
|
||||
/**
|
||||
* Emitted when the socket has connected.
|
||||
*/
|
||||
connect?: () => void;
|
||||
|
||||
/**
|
||||
* Emitted when the server responds with a greeting message.
|
||||
*/
|
||||
greeting?: (greeting: string) => void;
|
||||
|
||||
/**
|
||||
* Emitted when a handshake has completed (either initial or rekey).
|
||||
*/
|
||||
handshake?: (negotiated: NegotiatedAlgorithms) => void;
|
||||
|
||||
/**
|
||||
* Emitted when the server announces its available host keys.
|
||||
*/
|
||||
hostkeys?: (keys: ParsedKey[]) => void;
|
||||
|
||||
/**
|
||||
* An incoming forwarded UNIX socket connection is being requested.
|
||||
*/
|
||||
"unix connection"?: (info: UNIXConnectionDetails, accept: AcceptConnection, reject: RejectConnection) => void;
|
||||
}
|
||||
|
|
@ -1,639 +0,0 @@
|
|||
import fs from "fs";
|
||||
import path from "path";
|
||||
import { errorCode, targetType } from "./constant.js";
|
||||
import { EventEmitter } from "events";
|
||||
import { ScpClient } from ".";
|
||||
import { CheckResult, ErrorCustom } from "./types.js";
|
||||
|
||||
/**
|
||||
* Generate a new Error object with a reformatted error message which
|
||||
* is a little more informative and useful to users.
|
||||
*
|
||||
* @param {Error|string} err - The Error object the new error will be based on
|
||||
* @param {number} retryCount - For those functions which use retry. Number of
|
||||
* attempts to complete before giving up
|
||||
* @returns {Error} New error with custom error message
|
||||
*/
|
||||
export function formatError(err: ErrorCustom | string, name = "sftp", eCode = errorCode.generic, retryCount?: number) {
|
||||
let msg = "";
|
||||
let code = "";
|
||||
const retry = retryCount ? ` after ${retryCount} ${retryCount > 1 ? "attempts" : "attempt"}` : "";
|
||||
|
||||
if (err === undefined) {
|
||||
msg = `${name}: Undefined error - probably a bug!`;
|
||||
code = errorCode.generic;
|
||||
} else if (typeof err === "string") {
|
||||
msg = `${name}: ${err}${retry}`;
|
||||
code = eCode;
|
||||
} else if (err.custom) {
|
||||
msg = `${name}->${err.message}${retry}`;
|
||||
code = err.code!;
|
||||
} else {
|
||||
switch (err.code) {
|
||||
case "ENOTFOUND":
|
||||
msg = `${name}: ${err.level} error. ` + `Address lookup failed for host ${err.hostname}${retry}`;
|
||||
break;
|
||||
case "ECONNREFUSED":
|
||||
msg = `${name}: ${err.level} error. Remote host at ` + `${err.address} refused connection${retry}`;
|
||||
break;
|
||||
case "ECONNRESET":
|
||||
msg = `${name}: Remote host has reset the connection: ` + `${err.message}${retry}`;
|
||||
break;
|
||||
case "ENOENT":
|
||||
msg = `${name}: ${err.message}${retry}`;
|
||||
break;
|
||||
default:
|
||||
msg = `${name}: ${err.message}${retry}`;
|
||||
}
|
||||
code = err.code ? err.code : eCode;
|
||||
}
|
||||
const newError = new ErrorCustom(msg);
|
||||
newError.code = code;
|
||||
newError.custom = true;
|
||||
return newError;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests an error to see if it is one which has already been customised
|
||||
* by this module or not. If not, applies appropriate customisation.
|
||||
*
|
||||
* @param {Error} err - an Error object
|
||||
* @param {String} name - name to be used in customised error message
|
||||
* @param {Function} reject - If defined, call this function instead of
|
||||
* throwing the error
|
||||
* @throws {Error}
|
||||
*/
|
||||
export function handleError(err: ErrorCustom, name: string, reject: (e: any) => void) {
|
||||
if (reject) {
|
||||
if (err.custom) {
|
||||
reject(err);
|
||||
} else {
|
||||
reject(formatError(err, name, undefined, undefined));
|
||||
}
|
||||
} else {
|
||||
if (err.custom) {
|
||||
throw err;
|
||||
} else {
|
||||
throw formatError(err, name, undefined, undefined);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove all ready, error and end listeners.
|
||||
*
|
||||
* @param {Emitter} emitter - The emitter object to remove listeners from
|
||||
*/
|
||||
// function removeListeners(emitter) {
|
||||
// const listeners = emitter.eventNames()
|
||||
// listeners.forEach((name) => {
|
||||
// emitter.removeAllListeners(name)
|
||||
// })
|
||||
// }
|
||||
|
||||
/**
|
||||
* Simple default error listener. Will reformat the error message and
|
||||
* throw a new error.
|
||||
*
|
||||
* @param {Error} err - source for defining new error
|
||||
* @throws {Error} Throws new error
|
||||
*/
|
||||
export function makeErrorListener(reject: (e: any) => void, client: ScpClient, name: string) {
|
||||
return (err: Error) => {
|
||||
client.errorHandled = true;
|
||||
reject(formatError(err, name));
|
||||
};
|
||||
}
|
||||
|
||||
export function makeEndListener(client: ScpClient) {
|
||||
return () => {
|
||||
if (!client.endCalled) {
|
||||
console.error("End Listener: Connection ended unexpectedly");
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
export function makeCloseListener(client: ScpClient, reject?: (e: any) => void, name?: string) {
|
||||
return () => {
|
||||
if (!client.endCalled) {
|
||||
if (reject) {
|
||||
reject(formatError("Connection closed unexpectedly", name));
|
||||
} else {
|
||||
console.error("Connection closed unexpectedly");
|
||||
}
|
||||
}
|
||||
client.sftpWrapper = null;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* @async
|
||||
*
|
||||
* Tests to see if a path identifies an existing item. Returns either
|
||||
* 'd' = directory, 'l' = sym link or '-' regular file if item exists. Returns
|
||||
* false if it does not
|
||||
*
|
||||
* @param {String} localPath
|
||||
* @returns {Boolean | String}
|
||||
*/
|
||||
export function localExists(localPath: string): Promise<string> {
|
||||
return new Promise((resolve, reject) => {
|
||||
fs.stat(localPath, (err, stats) => {
|
||||
if (err) {
|
||||
if (err.code === "ENOENT") {
|
||||
resolve("ENOENT");
|
||||
} else {
|
||||
reject(err);
|
||||
}
|
||||
} else {
|
||||
if (stats.isDirectory()) {
|
||||
resolve("d");
|
||||
} else if (stats.isSymbolicLink()) {
|
||||
resolve("l");
|
||||
} else if (stats.isFile()) {
|
||||
resolve("-");
|
||||
} else {
|
||||
resolve("");
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Used by checkRemotePath and checkLocalPath to help ensure consistent
|
||||
* error messages.
|
||||
*
|
||||
* @param {Error} err - original error
|
||||
* @param {String} testPath - path associated with the error
|
||||
* @returns {Object} with properties of 'msg' and 'code'.
|
||||
*/
|
||||
export function classifyError(err: ErrorCustom, testPath: string) {
|
||||
switch (err.code) {
|
||||
case "EACCES":
|
||||
return {
|
||||
msg: `Permission denied: ${testPath}`,
|
||||
code: errorCode.permission,
|
||||
};
|
||||
case "ENOENT":
|
||||
return {
|
||||
msg: `No such file: ${testPath}`,
|
||||
code: errorCode.notexist,
|
||||
};
|
||||
case "ENOTDIR":
|
||||
return {
|
||||
msg: `Not a directory: ${testPath}`,
|
||||
code: errorCode.notdir,
|
||||
};
|
||||
default:
|
||||
return {
|
||||
msg: err.message,
|
||||
code: err.code ? err.code : errorCode.generic,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export function localAccess(localPath: string, mode: number): Promise<CheckResult> {
|
||||
return new Promise(resolve => {
|
||||
fs.access(localPath, mode, err => {
|
||||
if (err) {
|
||||
const { msg, code } = classifyError(err, localPath);
|
||||
resolve({
|
||||
path: localPath,
|
||||
valid: false,
|
||||
msg,
|
||||
code,
|
||||
});
|
||||
} else {
|
||||
resolve({
|
||||
path: localPath,
|
||||
valid: true,
|
||||
});
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export async function checkLocalReadFile(localPath: string, localType: string) {
|
||||
try {
|
||||
const rslt: CheckResult = {
|
||||
path: localPath,
|
||||
type: localType,
|
||||
};
|
||||
if (localType === "d") {
|
||||
rslt.valid = false;
|
||||
rslt.msg = `Bad path: ${localPath} must be a file`;
|
||||
rslt.code = errorCode.badPath;
|
||||
return rslt;
|
||||
} else {
|
||||
const access = await localAccess(localPath, fs.constants.R_OK);
|
||||
if (access.valid) {
|
||||
rslt.valid = true;
|
||||
return rslt;
|
||||
} else {
|
||||
rslt.valid = false;
|
||||
rslt.msg = access.msg;
|
||||
rslt.code = access.code;
|
||||
return rslt;
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
throw formatError(err as ErrorCustom, "checkLocalReadFile");
|
||||
}
|
||||
}
|
||||
|
||||
export async function checkLocalReadDir(localPath: string, localType: string) {
|
||||
try {
|
||||
const rslt: CheckResult = {
|
||||
path: localPath,
|
||||
type: localType,
|
||||
};
|
||||
if (!localType) {
|
||||
rslt.valid = false;
|
||||
rslt.msg = `No such directory: ${localPath}`;
|
||||
rslt.code = errorCode.notdir;
|
||||
return rslt;
|
||||
} else if (localType !== "d") {
|
||||
rslt.valid = false;
|
||||
rslt.msg = `Bad path: ${localPath} must be a directory`;
|
||||
rslt.code = errorCode.badPath;
|
||||
return rslt;
|
||||
} else {
|
||||
const access = await localAccess(localPath, fs.constants.R_OK | fs.constants.X_OK);
|
||||
if (!access.valid) {
|
||||
rslt.valid = false;
|
||||
rslt.msg = access.msg;
|
||||
rslt.code = access.code;
|
||||
return rslt;
|
||||
}
|
||||
rslt.valid = true;
|
||||
return rslt;
|
||||
}
|
||||
} catch (err) {
|
||||
throw formatError(err as ErrorCustom, "checkLocalReadDir");
|
||||
}
|
||||
}
|
||||
|
||||
export async function checkLocalWriteFile(localPath: string, localType: string) {
|
||||
try {
|
||||
const rslt: CheckResult = {
|
||||
path: localPath,
|
||||
type: localType,
|
||||
};
|
||||
if (localType === "d") {
|
||||
rslt.valid = false;
|
||||
rslt.msg = `Bad path: ${localPath} must be a file`;
|
||||
rslt.code = errorCode.badPath;
|
||||
return rslt;
|
||||
} else if (!localType) {
|
||||
const dir = path.parse(localPath).dir;
|
||||
const parent = await localAccess(dir, fs.constants.W_OK);
|
||||
if (parent.valid) {
|
||||
rslt.valid = true;
|
||||
return rslt;
|
||||
} else {
|
||||
rslt.valid = false;
|
||||
rslt.msg = parent.msg;
|
||||
rslt.code = parent.code;
|
||||
return rslt;
|
||||
}
|
||||
} else {
|
||||
const access = await localAccess(localPath, fs.constants.W_OK);
|
||||
if (access.valid) {
|
||||
rslt.valid = true;
|
||||
return rslt;
|
||||
} else {
|
||||
rslt.valid = false;
|
||||
rslt.msg = access.msg;
|
||||
rslt.code = access.code;
|
||||
return rslt;
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
throw formatError(err as ErrorCustom, "checkLocalWriteFile");
|
||||
}
|
||||
}
|
||||
|
||||
export async function checkLocalWriteDir(localPath: string, localType: string) {
|
||||
try {
|
||||
const rslt: CheckResult = {
|
||||
path: localPath,
|
||||
type: localType,
|
||||
};
|
||||
if (!localType) {
|
||||
const parent = path.parse(localPath).dir;
|
||||
const access = await localAccess(parent, fs.constants.W_OK);
|
||||
if (access.valid) {
|
||||
rslt.valid = true;
|
||||
return rslt;
|
||||
} else {
|
||||
rslt.valid = false;
|
||||
rslt.msg = access.msg;
|
||||
rslt.code = access.code;
|
||||
return rslt;
|
||||
}
|
||||
} else if (localType !== "d") {
|
||||
rslt.valid = false;
|
||||
rslt.msg = `Bad path: ${localPath} must be a directory`;
|
||||
rslt.code = errorCode.badPath;
|
||||
return rslt;
|
||||
} else {
|
||||
const access = await localAccess(localPath, fs.constants.W_OK);
|
||||
if (access.valid) {
|
||||
rslt.valid = true;
|
||||
return rslt;
|
||||
} else {
|
||||
rslt.valid = false;
|
||||
rslt.msg = access.msg;
|
||||
rslt.code = access.code;
|
||||
return rslt;
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
throw formatError(err as ErrorCustom, "checkLocalWriteDir");
|
||||
}
|
||||
}
|
||||
|
||||
export async function checkLocalPath(lPath: string, target = targetType.readFile) {
|
||||
const localPath = path.resolve(lPath);
|
||||
const type = await localExists(localPath);
|
||||
switch (target) {
|
||||
case targetType.readFile:
|
||||
return checkLocalReadFile(localPath, type);
|
||||
case targetType.readDir:
|
||||
return checkLocalReadDir(localPath, type);
|
||||
case targetType.writeFile:
|
||||
return checkLocalWriteFile(localPath, type);
|
||||
case targetType.writeDir:
|
||||
return checkLocalWriteDir(localPath, type);
|
||||
default:
|
||||
return {
|
||||
path: localPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
export async function normalizeRemotePath(client: ScpClient, aPath: string) {
|
||||
try {
|
||||
if (aPath.startsWith("..")) {
|
||||
const root = await client.realPath("..");
|
||||
return root + client.remotePathSep + aPath.substring(3);
|
||||
} else if (aPath.startsWith(".")) {
|
||||
const root = await client.realPath(".");
|
||||
return root + client.remotePathSep + aPath.substring(2);
|
||||
}
|
||||
return aPath;
|
||||
} catch (err) {
|
||||
throw formatError(err as ErrorCustom, "normalizeRemotePath");
|
||||
}
|
||||
}
|
||||
|
||||
export function checkReadObject(aPath: string, type: string) {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: type ? true : false,
|
||||
msg: type ? undefined : `No such file ${aPath}`,
|
||||
code: type ? undefined : errorCode.notexist,
|
||||
};
|
||||
}
|
||||
|
||||
export function checkReadFile(aPath: string, type: string) {
|
||||
if (!type) {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `No such file: ${aPath}`,
|
||||
code: errorCode.notexist,
|
||||
};
|
||||
} else if (type === "d") {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `Bad path: ${aPath} must be a file`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
}
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
|
||||
export function checkReadDir(aPath: string, type: string) {
|
||||
if (!type) {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `No such directory: ${aPath}`,
|
||||
code: errorCode.notdir,
|
||||
};
|
||||
} else if (type !== "d") {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `Bad path: ${aPath} must be a directory`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
}
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
|
||||
export async function checkWriteFile(client: ScpClient, aPath: string, type: string) {
|
||||
if (type && type === "d") {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `Bad path: ${aPath} must be a regular file`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
} else if (!type) {
|
||||
const { root, dir } = path.parse(aPath);
|
||||
// let parentDir = path.parse(aPath).dir;
|
||||
if (!dir) {
|
||||
return {
|
||||
path: aPath,
|
||||
type: false,
|
||||
valid: false,
|
||||
msg: `Bad path: ${aPath} cannot determine parent directory`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
}
|
||||
if (root === dir) {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
const parentType = await client.exists(dir);
|
||||
if (!parentType) {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `Bad path: ${dir} parent not exist`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
} else if (parentType !== "d") {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `Bad path: ${dir} must be a directory`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
}
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
|
||||
export async function checkWriteDir(client: ScpClient, aPath: string, type: string) {
|
||||
if (type && type !== "d") {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: `Bad path: ${aPath} must be a directory`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
} else if (!type) {
|
||||
const { root, dir } = path.parse(aPath);
|
||||
if (root === dir) {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
if (!dir) {
|
||||
return {
|
||||
path: aPath,
|
||||
type: false,
|
||||
valid: false,
|
||||
msg: `Bad path: ${aPath} cannot determine directory parent`,
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
}
|
||||
const parentType = await client.exists(dir);
|
||||
if (parentType && parentType !== "d") {
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: false,
|
||||
msg: "Bad path: Parent Directory must be a directory",
|
||||
code: errorCode.badPath,
|
||||
};
|
||||
}
|
||||
}
|
||||
// don't care if parent does not exist as it might be created
|
||||
// via recursive call to mkdir.
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
|
||||
export function checkWriteObject(aPath: string, type: string) {
|
||||
// for writeObj, not much error checking we can do
|
||||
// Just return path, type and valid indicator
|
||||
return {
|
||||
path: aPath,
|
||||
type,
|
||||
valid: true,
|
||||
};
|
||||
}
|
||||
|
||||
export async function checkRemotePath(client: ScpClient, rPath: string, target = targetType.readFile) {
|
||||
const aPath = await normalizeRemotePath(client, rPath);
|
||||
const type = await client.exists(aPath);
|
||||
switch (target) {
|
||||
case targetType.readObj:
|
||||
return checkReadObject(aPath, type as string);
|
||||
case targetType.readFile:
|
||||
return checkReadFile(aPath, type as string);
|
||||
case targetType.readDir:
|
||||
return checkReadDir(aPath, type as string);
|
||||
case targetType.writeFile:
|
||||
return checkWriteFile(client, aPath, type as string);
|
||||
case targetType.writeDir:
|
||||
return checkWriteDir(client, aPath, type as string);
|
||||
case targetType.writeObj:
|
||||
return checkWriteObject(aPath, type as string);
|
||||
default:
|
||||
throw formatError(`Unknown target type: ${target}`, "checkRemotePath", errorCode.generic);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check to see if there is an active sftp connection
|
||||
*
|
||||
* @param {Object} client - current sftp object
|
||||
* @param {String} name - name given to this connection
|
||||
* @param {Function} reject - if defined, call this rather than throw
|
||||
* an error
|
||||
* @returns {Boolean} True if connection OK
|
||||
* @throws {Error}
|
||||
*/
|
||||
export function haveConnection(client: ScpClient, name: string, reject?: (e: any) => void) {
|
||||
if (!client.sftpWrapper) {
|
||||
const newError = formatError("No SFTP connection available", name, errorCode.connect);
|
||||
if (reject) {
|
||||
reject(newError);
|
||||
return false;
|
||||
} else {
|
||||
throw newError;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
export function dumpListeners(emitter: EventEmitter) {
|
||||
const eventNames = emitter.eventNames();
|
||||
if (eventNames.length) {
|
||||
console.log("Listener Data");
|
||||
eventNames.map((n: any) => {
|
||||
const listeners = emitter.listeners(n);
|
||||
console.log(`${n}: ${emitter.listenerCount(n)}`);
|
||||
console.dir(listeners);
|
||||
listeners.map(l => {
|
||||
console.log(`listener name = ${l.name}`);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export function hasListener(emitter: EventEmitter, eventName: string, listenerName: string) {
|
||||
const listeners = emitter.listeners(eventName);
|
||||
const matches = listeners.filter(l => l.name === listenerName);
|
||||
return matches.length === 0 ? false : true;
|
||||
}
|
||||
|
||||
export function joinRemote(client: ScpClient, ...args: string[]) {
|
||||
if (client.remotePathSep === path.win32.sep) {
|
||||
return path.win32.join(...args);
|
||||
}
|
||||
return path.posix.join(...args);
|
||||
}
|
||||
|
|
@ -7,8 +7,8 @@ import { SshAccess } from "./ssh-access.js";
|
|||
import stripAnsi from "strip-ansi";
|
||||
import { SocksClient } from "socks";
|
||||
import { SocksProxy, SocksProxyType } from "socks/typings/common/constants.js";
|
||||
import { ScpClient } from "../scp/index.js";
|
||||
import fs from "fs";
|
||||
|
||||
export type TransportItem = { localPath: string; remotePath: string };
|
||||
|
||||
export class AsyncSsh2Client {
|
||||
|
|
@ -313,7 +313,7 @@ export class SshClient {
|
|||
}
|
||||
|
||||
async scpUpload(options: { conn: any; localPath: string; remotePath: string; opts?: { mode?: string } }) {
|
||||
const { conn, localPath, remotePath, opts } = options;
|
||||
const { conn, localPath, remotePath } = options;
|
||||
return new Promise((resolve, reject) => {
|
||||
// 关键步骤：构造 SCP 命令
|
||||
try {
|
||||
|
|
|
|||
Loading…
Reference in New Issue