filefive 1.0.0

package/dist/fs/SFtp.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTRIBUTES = void 0;
+const node_path_1 = require("node:path");
+const ssh2_1 = require("ssh2");
+const FileSystem_1 = require("../FileSystem");
+// https://github.com/mscdex/ssh2/blob/master/SFTP.md
+// https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-13#section-4.3
+// see also https://github.com/theophilusx/ssh2-sftp-client
+exports.ATTRIBUTES = [
+    {
+        name: "name",
+        type: FileSystem_1.FileAttributeType.String,
+        title: "Name"
+    },
+    {
+        name: "size",
+        type: FileSystem_1.FileAttributeType.Number,
+        title: "Size"
+    },
+    {
+        name: "modified",
+        type: FileSystem_1.FileAttributeType.Date,
+        title: "Last Modified"
+    },
+    {
+        name: "rights",
+        type: FileSystem_1.FileAttributeType.String,
+        title: "Rights"
+    }
+];
+class SFtp extends FileSystem_1.FileSystem {
+    constructor(host, user, password, port = 22, onError, onClose = () => { }) {
+        super();
+        this.host = host;
+        this.user = user;
+        this.password = password;
+        this.port = port;
+        this.onError = onError;
+        this.onClose = onClose;
+        this.connection = new ssh2_1.Client();
+    }
+    async open() {
+        if (this.connected === undefined) {
+            let connecting = true;
+            this.connected = new Promise((resolve, reject) => {
+                this.connection
+                    .on('close', () => {
+                    if (this.connected) {
+                        if (connecting) {
+                            reject(new Error('Remote side unexpectedly closed network connection'));
+                        }
+                        else {
+                            this.onClose();
+                        }
+                    }
+                    this.connected = undefined;
+                    connecting = false;
+                })
+                    .on('ready', () => {
+                    connecting = false;
+                    this.connection.sftp((e, sftp) => {
+                        if (e) {
+                            reject(new Error(this.decodeError(e)));
+                            return;
+                        }
+                        this.connection.on('error', this.onError);
+                        this.extensions = sftp._extensions;
+                        resolve(sftp);
+                    });
+                })
+                    .on('error', err => reject(err));
+            });
+            this.connection.connect({
+                host: this.host,
+                username: this.user,
+                password: this.password,
+                port: this.port,
+                // debug: s => console.log('DEBUG', s)
+            });
+        }
+        return this.connected;
+    }
+    close() {
+        this.connection.end();
+    }
+    opened() {
+        return this.connected != undefined;
+    }
+    async pwd() {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => sftp.realpath('.', (e, current) => e ?
+            reject(new Error(this.decodeError(e))) :
+            resolve(current)));
+    }
+    async ls(dir) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            sftp.readdir(dir, async (e, list) => {
+                if (e) {
+                    reject(new Error(`LS: Can't get contents of ${dir} ` + this.decodeError(e)));
+                    return;
+                }
+                const files = [];
+                for (let f of list) {
+                    if (f.attrs.isSymbolicLink()) {
+                        let target = await this.readlink((0, node_path_1.join)(dir, f.filename));
+                        if (!(0, node_path_1.isAbsolute)(target)) {
+                            target = (0, node_path_1.normalize)((0, node_path_1.join)(dir, target));
+                        }
+                        const targetStat = await this.stat(target);
+                        files.push({
+                            path: (0, node_path_1.join)(dir, f.filename),
+                            name: f.filename,
+                            dir: f.attrs.isDirectory(),
+                            size: targetStat.size,
+                            modified: new Date(targetStat.mtime * 1000),
+                            owner: targetStat.uid,
+                            group: targetStat.gid,
+                            rights: targetStat.mode,
+                            target
+                        });
+                    }
+                    else {
+                        files.push({
+                            path: (0, node_path_1.join)(dir, f.filename),
+                            name: f.filename,
+                            dir: f.attrs.isDirectory(),
+                            size: f.attrs.size,
+                            modified: new Date(f.attrs.mtime * 1000),
+                            owner: f.attrs.uid,
+                            group: f.attrs.gid,
+                            rights: f.attrs.mode
+                        });
+                    }
+                }
+                resolve(files);
+            });
+        });
+    }
+    async readlink(path) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            sftp.readlink(path, (e, target) => e ? reject(new Error(this.decodeError(e))) : resolve(target));
+        });
+    }
+    async stat(path) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            sftp.stat(path, (e, stats) => e ? reject(new Error(this.decodeError(e))) : resolve(stats));
+        });
+    }
+    async get(fromRemote, toLocal) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            sftp.fastGet(fromRemote, toLocal, (e) => e ? reject(new Error(this.decodeError(e))) : resolve());
+        });
+    }
+    async put(fromLocal, toRemote) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            sftp.fastPut(fromLocal, toRemote, e => e ? reject(new Error(this.decodeError(e) + ` ${toRemote}`)) : resolve());
+        });
+    }
+    async rm(path, recursive) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            if (recursive) {
+                sftp.rmdir(path, e => e ? reject(new Error(this.decodeError(e))) : resolve());
+            }
+            else {
+                sftp.unlink(path, e => e ? reject(new Error(this.decodeError(e))) : resolve());
+            }
+        });
+    }
+    async mkdir(path) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => sftp.mkdir(path, e => e ?
+            reject(new Error(`MKDIR: Can't create directory ${path} ` + this.decodeError(e))) :
+            resolve()));
+    }
+    async rename(from, to) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            sftp.rename(from, to, e => {
+                if (e) {
+                    reject(new Error(this.decodeError(e)));
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async mv(from, to) {
+        await this.exec(`rm -Rf '${to}'`);
+        await this.exec(`mkdir -p '${(0, node_path_1.dirname)(to)}'`);
+        return this.exec(`mv -f '${from}' '${to}'`);
+    }
+    async cp(from, to, recursive) {
+        await this.exec(`rm -Rf '${to}'`);
+        if (recursive) {
+            return this.exec(`cp -fR '${from}' '${to}'`);
+        }
+        await this.exec(`mkdir -p '${(0, node_path_1.dirname)(to)}'`);
+        return this.exec(`cp -f '${from}' '${to}'`);
+    }
+    async write(path, s) {
+        const sftp = await this.open();
+        return new Promise((resolve, reject) => {
+            sftp.open(path, 'w', (e, h) => {
+                if (e) {
+                    reject(e);
+                    return;
+                }
+                const data = Buffer.from(s);
+                sftp.write(h, data, 0, data.length, 0, (e) => e ? reject(new Error(this.decodeError(e))) : resolve());
+            });
+        });
+    }
+    async exec(cmd) {
+        await this.open();
+        return new Promise((resolve, reject) => this.connection.exec(cmd, (e, stream) => {
+            if (e) {
+                reject(new Error(cmd + ': ' + this.decodeError(e)));
+                return;
+            }
+            stream.on('exit', (code) => {
+                if (code) {
+                    reject(new Error(`${cmd}: the process's return code is ${code}`));
+                }
+                resolve();
+            }).on('data', (data) => {
+                console.log(`${cmd}: ${data}`);
+            }).stderr.on('data', data => {
+                reject(new Error(`${cmd}: ${data}`));
+            });
+        }));
+    }
+    decodeError(e) {
+        const STATUS_CODE = {
+            OK: 0,
+            EOF: 1,
+            NO_SUCH_FILE: 2,
+            PERMISSION_DENIED: 3,
+            FAILURE: 4,
+            BAD_MESSAGE: 5,
+            NO_CONNECTION: 6,
+            CONNECTION_LOST: 7,
+            OP_UNSUPPORTED: 8
+        };
+        const STATUS_CODE_STR = {
+            [STATUS_CODE.OK]: 'No error',
+            [STATUS_CODE.EOF]: 'End of file',
+            [STATUS_CODE.NO_SUCH_FILE]: 'No such file or directory',
+            [STATUS_CODE.PERMISSION_DENIED]: 'Permission denied',
+            [STATUS_CODE.FAILURE]: 'Failure',
+            [STATUS_CODE.BAD_MESSAGE]: 'Bad message',
+            [STATUS_CODE.NO_CONNECTION]: 'No connection',
+            [STATUS_CODE.CONNECTION_LOST]: 'Connection lost',
+            [STATUS_CODE.OP_UNSUPPORTED]: 'Operation unsupported',
+        };
+        let msg = e.message || (('code' in e) ?
+            (e['code'] in STATUS_CODE_STR ? STATUS_CODE_STR[e['code']] : `Code: ${e['code']}`) :
+            'Unknown error');
+        return msg;
+    }
+}
+exports.default = SFtp;

package/dist/index.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const multer_1 = __importDefault(require("multer"));
+const path_1 = require("path");
+const node_os_1 = require("node:os");
+const promises_1 = require("node:fs/promises");
+const App_1 = __importDefault(require("./App"));
+const ws_1 = require("ws");
+const open = import("open");
+const URI_1 = require("./utils/URI");
+const types_1 = require("./types");
+const commands_1 = require("./commands");
+const commander_1 = require("commander");
+const package_json_1 = __importDefault(require("../package.json"));
+const options_1 = __importDefault(require("./options"));
+commander_1.program
+    .name('F5')
+    .description('SFTP/FTP client, dual-panel file manager in the browser')
+    .version(package_json_1.default.version)
+    .option('-p, --port <number>', 'port number', '3113')
+    .option('--log', 'prints the log information');
+commander_1.program.parse();
+const inputOptions = commander_1.program.opts();
+const port = inputOptions.port ?? 3113;
+options_1.default.log = inputOptions.log ?? process.env.NODE_ENV == 'development';
+const app = (0, express_1.default)();
+app.use(express_1.default.json());
+app.use(express_1.default.static((0, path_1.resolve)(__dirname, 'public')));
+app.use(express_1.default.static((0, path_1.resolve)(__dirname, '../dist/public')));
+const server = app.listen(port, async () => {
+    console.log(`Listening on http://localhost:${port}`);
+    if (process.env.NODE_ENV !== 'development') {
+        (await open).default(`http://localhost:${port}`);
+    }
+});
+const handle = async (name, handler) => {
+    app.post(`/api/${name}`, async (req, res) => {
+        try {
+            const result = await handler(req.body);
+            res.json(result ?? null);
+        }
+        catch (e) {
+            res.status(400);
+            process.env.NODE_ENV == 'development' && console.error(e);
+            res.json({ message: (typeof e == 'object' && 'message' in e) ? e.message : String(e) });
+        }
+    });
+};
+const upload = (0, multer_1.default)({ dest: (0, node_os_1.tmpdir)() });
+app.post('/api/upload', upload.array('files'), async function (req, res) {
+    if (Array.isArray(req.files)) {
+        const src = [];
+        for (const { path, originalname } of req.files) {
+            const fnm = (0, path_1.join)((0, path_1.dirname)(path), originalname);
+            await (0, promises_1.rename)(path, fnm);
+            src.push(fnm);
+        }
+        commands_1.commands.copy(src.map(path => (0, URI_1.createURI)(types_1.LocalFileSystemID, path)), req.body['to'], true, null, null, () => src.forEach(path => (0, promises_1.rm)(path, { force: true })));
+    }
+    res.json(true);
+});
+const wss = new ws_1.WebSocketServer({ server, path: `/events` });
+const emitter = channel => event => wss.clients.forEach(ws => ws.send(JSON.stringify({ channel, ...event })));
+App_1.default.bootstrap(handle, emitter, async (file) => { (await open).default(file); });

package/dist/keybindings.json

@@ -0,0 +1,58 @@
+[
+    {
+        "key": "meta+comma",
+        "command": "settings"
+    },
+    {
+        "key": "meta+o",
+        "command": "connections"
+    },
+    {
+        "key": "meta+s",
+        "command": "connections"
+    },
+    {
+        "key": "delete",
+        "command": "delete"
+    },
+    {
+        "key": "meta+a",
+        "command": "select-all"
+    },
+    {
+        "key": "ctrl+r",
+        "command": "refresh"
+    },
+    {
+        "key": "alt+meta+c",
+        "command": "copy-path"
+    },
+    {
+        "key": "alt+meta+shift+c",
+        "command": "copy-relative-path"
+    },
+    {
+        "key": "ctrl+meta+c",
+        "command": "copy-name"
+    },
+    {
+        "key": "f5",
+        "command": "transfer"
+    },
+    {
+        "key": "ctrl+f",
+        "command": "show-filter"
+    },
+    {
+        "key": "ctrl+bracketleft",
+        "command": "go-back"
+    },
+    {
+        "key": "ctrl+bracketright",
+        "command": "go-forward"
+    },
+    {
+        "key": "meta+y",
+        "command": "sync-browsing"
+    }
+]

package/dist/log.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogFS = exports.err = exports.id = void 0;
+const FileSystem_1 = require("./FileSystem");
+const chalk = import('chalk');
+// const logger = new Console({
+//     stdout: createWriteStream(join(homedir(), '.f5', 'app.log')),
+//     stderr: createWriteStream(join(homedir(), '.f5', 'error.log')),
+// })
+const logger = console;
+exports.default = logger;
+const cmd = async (cmd) => (await chalk).default.bold.bgGreen(cmd);
+const id = async (id) => (await chalk).default.yellow(id);
+exports.id = id;
+const err = async (error) => (await chalk).default.red('⚠ ' + error);
+exports.err = err;
+class LogFS extends FileSystem_1.FileSystem {
+    constructor(id, fs) {
+        super();
+        this.id = id;
+        this.fs = fs;
+    }
+    async open() {
+        logger.log(await cmd('CONNECT'), await (0, exports.id)(this.id), '...');
+        try {
+            const res = await this.fs.open();
+            logger.log(await cmd('CONNECTED'), await (0, exports.id)(this.id));
+            return res;
+        }
+        catch (e) {
+            let msg = `Could not connect to ${this.id}`;
+            if ('message' in e) {
+                msg += ': ' + e.message;
+            }
+            logger.error(await (0, exports.err)(msg));
+            throw new Error(msg);
+        }
+    }
+    async close() {
+        logger.log(await cmd('CLOSE'), await (0, exports.id)(this.id));
+        this.fs.close();
+    }
+    opened() {
+        return this.fs.opened();
+    }
+    async pwd() {
+        logger.log(await cmd('PWD'), await (0, exports.id)(this.id));
+        try {
+            return await this.fs.pwd();
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+    async ls(dir) {
+        logger.log(await cmd('LS'), await (0, exports.id)(this.id) + dir);
+        try {
+            return await this.fs.ls(dir);
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+    async get(remote, local) {
+        logger.log(await cmd('GET'), `${local} ← ` + await (0, exports.id)(this.id) + remote);
+        try {
+            return await this.fs.get(remote, local);
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+    async put(local, remote) {
+        logger.log(await cmd('PUT'), `${local} → ` + await (0, exports.id)(this.id) + remote);
+        try {
+            return await this.fs.put(local, remote);
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+    async rm(path, recursive) {
+        logger.log(await cmd(recursive ? 'RMDIR' : 'RM'), await (0, exports.id)(this.id) + path);
+        try {
+            return await this.fs.rm(path, recursive);
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+    async mkdir(path) {
+        logger.log(await cmd('MKDIR'), await (0, exports.id)(this.id) + path);
+        try {
+            return await this.fs.mkdir(path);
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+    async rename(from, to) {
+        logger.log(await cmd('RENAME'), await (0, exports.id)(this.id) + from, ' → ', await (0, exports.id)(this.id) + to);
+        try {
+            return await this.fs.rename(from, to);
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+    async mv(from, to) {
+        logger.log(await cmd('MV'), await (0, exports.id)(this.id) + from, ' → ', await (0, exports.id)(this.id) + to);
+        try {
+            return await this.fs.mv(from, to);
+        }
+        catch (e) {
+            logger.error(await (0, exports.err)(e.message));
+            throw e;
+        }
+    }
+    async cp(from, to, recursive) {
+        logger.log(await cmd(recursive ? 'CP -R' : 'CP'), await (0, exports.id)(this.id) + from, ' → ', await (0, exports.id)(this.id) + to);
+        try {
+            return await this.fs.cp(from, to, recursive);
+        }
+        catch (e) {
+            logger.error(await (0, exports.err)(e.message));
+            throw e;
+        }
+    }
+    async write(path, data) {
+        logger.log(await cmd('WRITE'), await (0, exports.id)(this.id) + path);
+        try {
+            return await this.fs.write(path, data);
+        }
+        catch (e) {
+            logger.error(e);
+            throw e;
+        }
+    }
+}
+exports.LogFS = LogFS;

package/dist/options.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    log: false
+};