filefive 1.0.0

package/README.md

@@ -0,0 +1,53 @@
+<p align="center">
+    <img src="https://github.com/miroshnikov/filefive/blob/main/frontend/src/assets/logo.svg" width="64" alt="FileFive" />
+</p>
+
+
+# FileFive: SFTP/FTP client and dual-panel file manager for macOS and Linux
+FileFive is a free open-source SFTP/FTP client and file manager with intuitive and modern dual-panel interface.
+
+It is installed a Node.js package and works in the browser. 
+
+<p align="center">
+    <img src="https://github.com/miroshnikov/filefive/blob/main/screenshot.png" alt="FileFive" />
+</p>
+
+## Installation
+```shell
+npm install -g filefive
+```
+
+## Usage
+Run `f5` and FileFive will be opened in the default browser. Press <kbd>ctrl</kbd> + <kbd>c</kbd> to quit the program.
+```
+> f5 --help
+Usage: F5 [options]
+
+SFTP/FTP client, dual-panel file manager in the browser
+
+Options:
+  -V, --version        output the version number
+  -p, --port <number>  port number (default: "3113")
+  --log                prints the log information
+  -h, --help           display help for command
+```
+
+## Features
+- Supports SSH File Transfer Protocol (SFTP) and FTP
+- Cross-platform, runs on Mac OS and Linux
+- Minimal and intuitive UI, mimicing the VSCode Explorer view
+- Search/filter files using JavaScript Regular Expressions
+- Synchronized browsing
+- Connections/servers are plain files stored in a folder on your filesystem
+- You can use Git or any VCS to store connections and settings
+- Drag & drop support
+- Open files and folders in Visual Studio Code
+- Uses browser tabs to browse more than one server or transfer files simultaneously
+
+## Feedbacks
+To support its development, [star FileFive on GitHub](https://github.com/miroshnikov/filefive/stargazers)!
+
+[Feedback, suggestion, improvements](https://github.com/miroshnikov/filefive/discussions) or [bugs](https://github.com/miroshnikov/filefive/issues) are welcome.
+
+## License
+[GPL-3.0 License](LICENSE)

package/dist/App.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const types_1 = require("./types");
+const Connection_1 = __importDefault(require("./Connection"));
+const LocalWatcher_1 = __importDefault(require("./LocalWatcher"));
+const FileWatcher_1 = __importDefault(require("./FileWatcher"));
+const RemoteWatcher_1 = __importDefault(require("./RemoteWatcher"));
+const Queue_1 = require("./queues/Queue");
+const Password_1 = __importDefault(require("./Password"));
+const commands_1 = require("./commands");
+const transform_1 = __importDefault(require("./transform"));
+const Local_1 = require("./Local");
+const URI_1 = require("./utils/URI");
+class App {
+    static async bootstrap(handle, emitter, opener) {
+        const dataPath = (0, node_path_1.join)((0, node_os_1.homedir)(), '.f5');
+        const connPath = (0, node_path_1.join)(dataPath, 'connections');
+        (0, promises_1.mkdir)(connPath, { recursive: true });
+        (0, Local_1.touch)((0, node_path_1.join)(dataPath, 'credentials.json'), JSON.stringify([]));
+        const settingsPath = (0, node_path_1.join)(dataPath, 'settings.json');
+        if (!(0, Local_1.stat)(settingsPath)) {
+            await (0, Local_1.touch)(settingsPath);
+            commands_1.commands.saveSettings(settingsPath, await commands_1.commands.getSettings(settingsPath));
+        }
+        Password_1.default.load(dataPath, id => App.onError({ type: types_1.FailureType.Unauthorized, id }));
+        Connection_1.default.initialize();
+        Object.entries({
+            getapp: () => commands_1.commands.getSettings(settingsPath),
+            saveapp: ({ settings }) => commands_1.commands.saveSettings(settingsPath, settings),
+            connect: ({ file }) => commands_1.commands.connect(file, (id, { message }) => this.onError({ type: types_1.FailureType.RemoteError, id, message })),
+            login: ({ id, password, remember }) => Password_1.default.set(id, password, remember),
+            disconnect: ({ id, sid }) => commands_1.commands.disconnect(id, sid),
+            watch: ({ dir }) => commands_1.commands.watch(dir, this.localWatcher, this.remoteWatcher, this.fileWatcher),
+            unwatch: ({ dir }) => commands_1.commands.unwatch(dir, this.localWatcher, this.remoteWatcher, this.fileWatcher),
+            refresh: ({ dir }) => this.remoteWatcher.refresh(dir),
+            copy: ({ src, dest, move, filter, sid }) => commands_1.commands.copy(src, dest, move, filter, sid),
+            duplicate: ({ src, filter }) => commands_1.commands.duplicate(src, filter),
+            remove: ({ files, force }) => commands_1.commands.remove(files, force, connPath),
+            clear: ({ file, force }) => commands_1.commands.clear(file, force),
+            open: ({ file }) => opener(file),
+            mkdir: ({ name, parent }) => commands_1.commands.mkdir(name, parent),
+            read: ({ file }) => commands_1.commands.read(file),
+            write: ({ path, content }) => commands_1.commands.write(path, content),
+            rename: ({ path, name }) => commands_1.commands.rename(path, name),
+            get: ({ path }) => commands_1.commands.getConnection(path),
+            save: ({ path, settings }) => commands_1.commands.saveConnection(path, settings),
+            resolve: ({ id, action, forAll, sid }) => commands_1.commands.resolve(id, action, forAll, sid),
+            stop: ({ id }) => Queue_1.queues.get(id)?.stop()
+        }).forEach(([name, handler]) => handle(name, handler));
+        const emitError = emitter('error');
+        this.onError = (error) => emitError(error);
+        const emitDir = emitter('dir');
+        const sendDirContent = (uri, files) => emitDir({ uri, files });
+        this.localWatcher = new LocalWatcher_1.default((path, files) => sendDirContent((0, URI_1.createURI)(types_1.LocalFileSystemID, path), files.map(f => ({ ...f, URI: (0, URI_1.createURI)(types_1.LocalFileSystemID, f.path) }))), path => this.onError({ type: types_1.FailureType.MissingDir, uri: (0, URI_1.createURI)(types_1.LocalFileSystemID, path) }));
+        this.remoteWatcher = new RemoteWatcher_1.default(sendDirContent, uri => this.onError({ type: types_1.FailureType.MissingDir, uri }), transform_1.default);
+        const emitFile = emitter('file');
+        const sendFileStat = (path, stat) => emitFile({ path, stat });
+        this.fileWatcher = new FileWatcher_1.default(sendFileStat);
+        const emitQueue = emitter('queue');
+        this.onQueueUpdate = (id, event) => emitQueue({ id, event });
+    }
+}
+exports.default = App;

package/dist/Connection.js

@@ -0,0 +1,193 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ReferenceCountMap_1 = __importDefault(require("./utils/ReferenceCountMap"));
+const types_1 = require("./types");
+const URI_1 = require("./utils/URI");
+const Password_1 = __importDefault(require("./Password"));
+const uniqid_1 = __importDefault(require("./utils/uniqid"));
+const log_1 = __importStar(require("./log"));
+const Local_1 = __importDefault(require("./fs/Local"));
+const SFtp_1 = __importStar(require("./fs/SFtp"));
+const Ftp_1 = __importStar(require("./fs/Ftp"));
+const options_1 = __importDefault(require("./options"));
+class default_1 {
+    static initialize() {
+        this.shared.set(types_1.LocalFileSystemID, new Local_1.default);
+    }
+    static async open(scheme, user, host, port) {
+        const id = (0, URI_1.connectionID)(scheme, user, host, port);
+        const attrs = (scheme == 'sftp') ? SFtp_1.ATTRIBUTES : Ftp_1.ATTRIBUTES;
+        if (this.shared.inc(id)) {
+            return attrs;
+        }
+        const conn = await this.create(id, scheme, user, host, port);
+        await conn.open();
+        this.shared.set(id, conn);
+        return attrs;
+    }
+    static get(id) {
+        return this.shared.get(id);
+    }
+    static close(id) {
+        this.shared.dec(id)?.close();
+    }
+    static async list(id, path) {
+        const files = await this.get(id)?.ls(path) || [];
+        return files.map(f => ({ ...f, URI: (0, URI_1.createURI)(id, f.path) }));
+    }
+    static async transmit(id) {
+        if (id == types_1.LocalFileSystemID) {
+            return [new Local_1.default, () => { }];
+        }
+        const conn = await this.hold(id);
+        if (conn) {
+            return [conn[0], () => this.release(id, conn[1])];
+        }
+        return new Promise((resolve) => {
+            const onRelease = (poolId) => {
+                const { fs } = this.pools.get(id).get(poolId);
+                resolve([fs, () => this.release(id, poolId)]);
+            };
+            id in this.pending ? this.pending[id].push(onRelease) : (this.pending[id] = [onRelease]);
+        });
+    }
+    static async hold(id) {
+        !this.pools.has(id) && this.pools.set(id, new Map());
+        const pool = this.pools.get(id);
+        const conn = this.getIdle(id);
+        if (conn) {
+            return conn;
+        }
+        if (pool.size < this.getLimit(id)) {
+            return new Promise((resolve) => {
+                const connect = async () => {
+                    const conn = this.getIdle(id);
+                    if (conn) {
+                        resolve(conn);
+                        return;
+                    }
+                    const poolId = (0, uniqid_1.default)();
+                    try {
+                        const onClose = () => this.pools.get(id)?.delete(poolId);
+                        const fs = await this.createFromId(id, onClose);
+                        await fs.open();
+                        this.pools.get(id).set(poolId, { fs, idle: false });
+                        resolve([fs, poolId]);
+                    }
+                    catch (e) {
+                        const conn = this.getIdle(id);
+                        if (conn) {
+                            resolve(conn);
+                            return;
+                        }
+                    }
+                    resolve(null);
+                };
+                this.queue.push(connect);
+                if (this.queue.length == 1) {
+                    this.connectNext();
+                }
+            });
+        }
+        return null;
+    }
+    static getIdle(id) {
+        const conn = Array.from(this.pools.get(id)?.entries() || []).find(([, { idle }]) => idle !== false);
+        if (conn) {
+            conn[1].idle !== false && clearTimeout(conn[1].idle);
+            conn[1].idle = false;
+            return [conn[1].fs, conn[0]];
+        }
+        return null;
+    }
+    static async connectNext() {
+        this.queue
+            .splice(0, Math.max(this.maxStartups - this.numOfStartups, 0))
+            .map(connect => async () => { await connect(); this.numOfStartups--; this.connectNext(); })
+            .forEach(f => { this.numOfStartups++; f(); });
+    }
+    static release(id, poolId) {
+        const conn = this.pools.get(id)?.get(poolId);
+        if (conn) {
+            if (this.pending[id]?.length) {
+                this.pending[id].shift()(poolId);
+            }
+            else {
+                conn.idle = setTimeout(() => {
+                    conn.fs.close();
+                    this.pools.get(id)?.delete(poolId);
+                }, 2000);
+            }
+        }
+    }
+    static getLimit(id) {
+        return this.limits.has(id) ? this.limits.get(id) : 1024; // for vsftpd max_per_ip in /etc/vsftpd.conf
+    }
+    static async create(id, scheme, user, host, port, onClose = () => { }) {
+        if (options_1.default.log) {
+            return new log_1.LogFS(id, await this.createFS(scheme, user, host, port, await Password_1.default.get(id), onClose));
+        }
+        return this.createFS(scheme, user, host, port, await Password_1.default.get(id), onClose);
+    }
+    static async createFS(scheme, user, host, port, password, onClose) {
+        switch (scheme) {
+            case 'sftp': {
+                return new SFtp_1.default(host, user, password, port, error => log_1.default.error('SFTP error:', error), onClose);
+            }
+            case 'ftp': {
+                return new Ftp_1.default(host, user, password, port, error => log_1.default.error('FTP error:', error), onClose);
+            }
+            default:
+                throw new Error(`Unsupported scheme ${scheme}`);
+        }
+    }
+    static async createFromId(id, onClose = () => { }) {
+        const { scheme, user, host, port } = (0, URI_1.parseURI)(id);
+        return this.create(id, scheme, user, host, port, onClose);
+    }
+}
+default_1.numOfStartups = 0;
+default_1.maxStartups = 7; // for SFTP see MaxStartups in /etc/ssh/sshd_config
+default_1.shared = new ReferenceCountMap_1.default;
+// private static pools: Record<string, Record<string, {fs: FileSystem, idle: false|ReturnType<typeof setTimeout>}>> = {}
+default_1.pools = new Map();
+default_1.queue = [];
+default_1.pending = {};
+default_1.limits = new Map();
+exports.default = default_1;

package/dist/FileSystem.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystem = exports.FileAttributeType = void 0;
+var FileAttributeType;
+(function (FileAttributeType) {
+    FileAttributeType["String"] = "string";
+    FileAttributeType["Number"] = "number";
+    FileAttributeType["Date"] = "date";
+    FileAttributeType["Rights"] = "rights";
+})(FileAttributeType || (exports.FileAttributeType = FileAttributeType = {}));
+class FileSystem {
+}
+exports.FileSystem = FileSystem;

package/dist/FileWatcher.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const Local_1 = require("./Local");
+const ReferenceCountMap_1 = __importDefault(require("./utils/ReferenceCountMap"));
+class default_1 {
+    constructor(listener) {
+        this.listener = listener;
+        this.watched = new ReferenceCountMap_1.default;
+    }
+    async watch(path) {
+        if (this.watched.inc(path)) {
+            return;
+        }
+        try {
+            const ac = new AbortController();
+            this.watched.set(path, ac);
+            for await (const { eventType, filename } of (0, promises_1.watch)(path, { signal: ac.signal })) {
+                let newPath = path;
+                if (eventType == "rename" && (0, node_path_1.basename)(path) !== filename) {
+                    newPath = (0, node_path_1.join)((0, node_path_1.dirname)(path), filename);
+                    this.watched.renameKey(path, newPath);
+                }
+                try {
+                    this.listener(path, (0, Local_1.stat)(newPath), eventType);
+                }
+                catch (e) {
+                    this.listener(path, null, eventType);
+                }
+            }
+        }
+        catch (e) {
+            console.error('Error while watch file', e);
+        }
+    }
+    unwatch(dir) {
+        this.watched.dec(dir)?.abort();
+    }
+}
+exports.default = default_1;

package/dist/Local.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pwd = pwd;
+exports.stat = stat;
+exports.list = list;
+exports.move = move;
+exports.copy = copy;
+exports.del = del;
+exports.touch = touch;
+exports.watch = watch;
+exports.read = read;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+function pwd() {
+    return (0, node_os_1.homedir)();
+}
+function stat(path) {
+    path = (0, node_path_1.normalize)(path);
+    try {
+        let stat = (0, node_fs_1.lstatSync)(path);
+        let target;
+        if (stat.isSymbolicLink()) {
+            target = (0, node_fs_1.readlinkSync)(path);
+            if (!(0, node_path_1.isAbsolute)(target)) {
+                target = (0, node_path_1.normalize)((0, node_path_1.join)((0, node_path_1.dirname)(path), target));
+            }
+            stat = (0, node_fs_1.statSync)(target);
+        }
+        return {
+            path,
+            name: (0, node_path_1.basename)(path),
+            dir: stat.isDirectory(),
+            size: stat.size, // in bytes
+            modified: stat.mtime,
+            inode: stat.ino,
+            ...(target ? { target } : {})
+        };
+    }
+    catch (e) {
+        return null;
+    }
+}
+function list(dir) {
+    return (0, node_fs_1.readdirSync)(dir).map(name => stat((0, node_path_1.join)(dir, name))).filter(f => f);
+}
+async function move(from, to, force = false) {
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(to), { recursive: true });
+    const existing = stat(to);
+    if (existing) {
+        if (force) {
+            await (0, promises_1.unlink)(to);
+        }
+        else {
+            return existing;
+        }
+    }
+    await (0, promises_1.rename)(from, to);
+    return true;
+}
+async function copy(from, to, force = false) {
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(to), { recursive: true });
+    const existing = stat(to);
+    if (existing && !force) {
+        return existing;
+    }
+    await (0, promises_1.cp)(from, to, { recursive: true });
+    return true;
+}
+async function del(path) {
+    return (0, promises_1.rm)(path, { recursive: true, force: true });
+}
+async function touch(path, data) {
+    if (!stat(path)) {
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(path), { recursive: true });
+        data !== undefined ? await (0, promises_1.writeFile)(path, data) : await (await (0, promises_1.open)(path, 'a')).close();
+    }
+}
+function watch(path, listener) {
+    const watcher = (0, node_fs_1.watch)(path, listener);
+    return () => watcher.close();
+}
+async function read(path) {
+    return await (0, promises_1.readFile)(path, { encoding: 'utf8' });
+}

package/dist/LocalWatcher.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const Local_1 = require("./Local");
+const ReferenceCountMap_1 = __importDefault(require("./utils/ReferenceCountMap"));
+class default_1 {
+    constructor(listener, onMissing, transform = (files) => files) {
+        this.listener = listener;
+        this.onMissing = onMissing;
+        this.transform = transform;
+        this.watched = new ReferenceCountMap_1.default;
+    }
+    watch(dir) {
+        try {
+            this.watched.inc(dir) || this.watched.set(dir, (0, Local_1.watch)(dir, (event, target) => {
+                if (event == 'rename') {
+                    const child = (0, node_path_1.join)(dir, target);
+                    if (this.watched.has(child) && !(0, Local_1.stat)(child)) {
+                        this.watched.del(child);
+                        this.onMissing(child);
+                    }
+                }
+                try {
+                    this.listener(dir, this.transform((0, Local_1.list)(dir)), event, target);
+                }
+                catch (e) {
+                    this.watched.del(dir);
+                    this.onMissing(dir);
+                }
+            }));
+            const files = this.transform((0, Local_1.list)(dir));
+            this.listener(dir, files);
+            return files;
+        }
+        catch (e) {
+            this.watched.del(dir);
+            this.onMissing(dir);
+        }
+        return [];
+    }
+    unwatch(dir) {
+        this.watched.dec(dir)?.();
+    }
+}
+exports.default = default_1;

package/dist/Password.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+class Passwords {
+    static async load(dir, onMiss) {
+        this.saveFile = (0, node_path_1.join)(dir, 'credentials.json');
+        this.resolve = onMiss;
+        this.store = new Map(JSON.parse((await (0, promises_1.readFile)(this.saveFile)).toString()).map(([id, password]) => [id, [password, true]]));
+    }
+    static set(id, password, remember = false) {
+        if (password === false) {
+            this.pending.get(id)?.[1]();
+        }
+        else {
+            this.pending.get(id)?.[0](password);
+            remember && this.store.set(id, [password, false]);
+        }
+    }
+    static save(id, password) {
+        this.store.set(id, [password, true]);
+        this.dump();
+    }
+    static async get(id, skipMissing = false) {
+        if (this.store.has(id)) {
+            return this.store.get(id)[0];
+        }
+        if (skipMissing) {
+            return '';
+        }
+        const p = new Promise((resolve, reject) => this.pending.set(id, [resolve, reject]));
+        this.resolve(id);
+        return p;
+    }
+    static delete(id, saved) {
+        const found = this.store.get(id);
+        if (found && found[1] == saved) {
+            this.store.delete(id);
+            found[1] == true && this.dump();
+        }
+        this.pending.delete(id);
+    }
+    static dump() {
+        (0, promises_1.writeFile)(this.saveFile, JSON.stringify(Array.from(this.store.entries())
+            .filter(([, [, save]]) => save)
+            .map(([id, [password,]]) => [id, password])));
+    }
+}
+Passwords.saveFile = '';
+Passwords.pending = new Map();
+exports.default = Passwords;