@maiyunnet/kebab 2.0.0

package/lib/ssh/sftp.js

@@ -0,0 +1,373 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+const core = __importStar(require("~/lib/core"));
+const text = __importStar(require("~/lib/text"));
+class Connection {
+    constructor(sftp, path) {
+        this._client = sftp;
+        this._path = path;
+    }
+    getContent(path, options) {
+        path = text.urlResolve(this._path, path);
+        if (typeof options === 'string') {
+            options = {
+                'encoding': options
+            };
+        }
+        else if (!options) {
+            options = {};
+        }
+        const encoding = options.encoding;
+        const start = options.start;
+        const end = options.end;
+        return new Promise((resolve) => {
+            if (start ?? end) {
+                const rs = this.createReadStream(path, {
+                    'encoding': encoding,
+                    'start': start,
+                    'end': end
+                });
+                const data = [];
+                rs.on('data', function (chunk) {
+                    data.push(chunk);
+                }).on('end', function () {
+                    const buf = Buffer.concat(data);
+                    if (encoding) {
+                        resolve(buf.toString());
+                    }
+                    else {
+                        resolve(buf);
+                    }
+                }).on('error', function () {
+                    resolve(null);
+                });
+            }
+            else {
+                if (encoding) {
+                    this._client.readFile(path, {
+                        'encoding': encoding
+                    }, function (err, data) {
+                        if (err) {
+                            resolve(null);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                }
+                else {
+                    this._client.readFile(path, function (err, data) {
+                        if (err) {
+                            resolve(null);
+                        }
+                        else {
+                            resolve(data);
+                        }
+                    });
+                }
+            }
+        });
+    }
+    putContent(path, data, options = {}) {
+        path = text.urlResolve(this._path, path);
+        return new Promise((resolve) => {
+            this._client.writeFile(path, data, options, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    readLink(path) {
+        path = text.urlResolve(this._path, path);
+        return new Promise((resolve) => {
+            this._client.readlink(path, function (err, target) {
+                if (err) {
+                    resolve(null);
+                }
+                else {
+                    resolve(target);
+                }
+            });
+        });
+    }
+    symlink(filePath, linkPath) {
+        filePath = text.urlResolve(this._path, filePath);
+        linkPath = text.urlResolve(this._path, linkPath);
+        return new Promise((resolve) => {
+            this._client.symlink(filePath, linkPath, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    async unlink(path) {
+        path = text.urlResolve(this._path, path);
+        for (let i = 0; i < 2; ++i) {
+            const bol = await this._unlink(path);
+            if (bol) {
+                return true;
+            }
+            await core.sleep(250);
+        }
+        return this._unlink(path);
+    }
+    _unlink(path) {
+        return new Promise((resolve) => {
+            this._client.unlink(path, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    stats(path) {
+        path = text.urlResolve(this._path, path);
+        return new Promise((resolve) => {
+            this._client.lstat(path, function (err, stat) {
+                if (err) {
+                    resolve(null);
+                }
+                else {
+                    resolve(stat);
+                }
+            });
+        });
+    }
+    async isDir(path) {
+        const pstats = await this.stats(path);
+        if (!pstats?.isDirectory()) {
+            return false;
+        }
+        return pstats;
+    }
+    async isFile(path) {
+        const pstats = await this.stats(path);
+        if (!pstats?.isFile()) {
+            return false;
+        }
+        return pstats;
+    }
+    async mkdir(path, mode = 0o755) {
+        path = text.urlResolve(this._path, path);
+        if (await this.isDir(path)) {
+            return true;
+        }
+        if (path.endsWith('/')) {
+            path.slice(0, -1);
+        }
+        const lio = path.lastIndexOf('/');
+        if (!(await this.mkdir(path.slice(0, lio), mode))) {
+            return false;
+        }
+        if (!(await new Promise((resolve) => {
+            this._client.mkdir(path.slice(0, lio), {
+                'mode': mode
+            }, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        }))) {
+            return false;
+        }
+        return true;
+    }
+    async rmdir(path) {
+        path = text.urlResolve(this._path, path);
+        if (!(await this.isDir(path))) {
+            return true;
+        }
+        return new Promise((resolve) => {
+            this._client.rmdir(path, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    async rmdirDeep(path) {
+        path = text.urlResolve(this._path, path);
+        if (!path.endsWith('/')) {
+            path += '/';
+        }
+        const list = await this.readDir(path);
+        for (const item of list) {
+            if (item.filename === '.' || item.filename === '..') {
+                continue;
+            }
+            const stat = await this.stats(item.filename);
+            if (!stat) {
+                return false;
+            }
+            if (stat.isDirectory()) {
+                const rtn = await this.rmdirDeep(path + item.filename);
+                if (!rtn) {
+                    return false;
+                }
+            }
+            else {
+                const rtn = await this.unlink(path + item.filename);
+                if (!rtn) {
+                    return false;
+                }
+            }
+        }
+        return this.rmdir(path);
+    }
+    chmod(path, mode) {
+        path = text.urlResolve(this._path, path);
+        return new Promise((resolve) => {
+            this._client.chmod(path, mode, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    rename(oldPath, newPath) {
+        oldPath = text.urlResolve(this._path, oldPath);
+        newPath = text.urlResolve(this._path, newPath);
+        return new Promise((resolve) => {
+            this._client.rename(oldPath, newPath, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    readDir(path) {
+        path = text.urlResolve(this._path, path);
+        return new Promise((resolve) => {
+            this._client.readdir(path, function (err, files) {
+                if (err) {
+                    resolve([]);
+                }
+                else {
+                    resolve(files);
+                }
+            });
+        });
+    }
+    createReadStream(path, options) {
+        path = text.urlResolve(this._path, path);
+        return this._client.createReadStream(path, options);
+    }
+    pipe(path, destination, options = {}) {
+        path = text.urlResolve(this._path, path);
+        return new Promise((resolve) => {
+            this._client.createReadStream(path).on('error', function () {
+                resolve(false);
+            }).on('end', function () {
+                resolve(true);
+            }).pipe(destination, options);
+        });
+    }
+    createWriteStream(path, options) {
+        if (typeof options === 'string') {
+            options = {
+                'encoding': options
+            };
+        }
+        else if (!options) {
+            options = {};
+        }
+        return this._client.createWriteStream(path, options);
+    }
+    pwd() {
+        return this._path.slice(0, -1);
+    }
+    downloadFile(remoteFile, localFile, options = {}) {
+        remoteFile = text.urlResolve(this._path, remoteFile);
+        return new Promise((resolve) => {
+            this._client.fastGet(remoteFile, localFile, options, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    uploadFile(localFile, remoteFile, options = {}) {
+        remoteFile = text.urlResolve(this._path, remoteFile);
+        return new Promise((resolve) => {
+            this._client.fastPut(localFile, remoteFile, options, function (err) {
+                if (err) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+    cd(dir) {
+        this._path = text.urlResolve(this._path, dir);
+        if (!this._path.endsWith('/')) {
+            this._path += '/';
+        }
+        return this._path;
+    }
+    close() {
+        this._client.end();
+    }
+}
+exports.Connection = Connection;