filefive 1.5.0 → 1.6.0

package/README.md

@@ -3,12 +3,12 @@
 </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, available on Mac, and Linux. 
+# FileFive: SFTP/FTP/AWS S3 GUI client and dual-panel file manager for macOS and Linux
+FileFive is a free open-source SFTP/FTP/Amazon S3 client and file manager with intuitive and modern dual-panel interface, available on Mac, and Linux. 
 
 It is installed as a Node.js package and uses the web browser as GUI.
 
-FileFive has a unique set of features and may be an alternative to FileZilla, Cyberduck, Transmit, and ForkLift.
+FileFive has a unique set of features and may be a free alternative to FileZilla Pro, Transmit, ForkLift and Cyberduck.
 
 <p align="center">
     <img src="https://github.com/miroshnikov/filefive/blob/main/docs/screenshots/screenshot-1.png" alt="FileFive" />
@@ -33,7 +33,7 @@ Run `f5` and FileFive will be opened in the default browser. Press <kbd>ctrl</kb
 > f5 --help
 Usage: F5 [options]
 
-SFTP/FTP client, dual-panel file manager in the browser
+SFTP/FTP/S3 client, dual-panel file manager in the browser
 
 Options:
   -V, --version        output the version number
@@ -43,21 +43,24 @@ Options:
 ```
 
 ## Features
-- Cross-platform, runs on Mac OS, Linux and any *nix with Node.js
-- Supports SSH File Transfer Protocol (SFTP) and FTP
-- Minimalistic and intuitive UI, mimicing the look and feel of VSCode Explorer view
-- Search/filter files using wildcards and JavaScript Regular Expressions
-- Synchronized browsing
-- Copy files keeping relative paths, allows synchronization files in nested folders in one click
-- Remote file editing
-- Files' Git statuses (uses your machine's Git installation)
-- Connections/servers are plain files stored on your filesystem, no need to export/import
-- Easy to backup connections and settings in `~/.f5` folder, e.g. by putting them into a Git repo
-- Drag & drop, copy & paste files support
-- Use browser tabs to browse more than one server or transfer files simultaneously
-- Utilize the built-in browser password manager to store passwords
-- Open files and folders in default app or Visual Studio Code
-- Theming: System preference, Light, Dark; a different color theme per connection
+- **Cross-platform**, runs on MacOS, Linux and any *nix with Node.js
+- Supports 
+  - SSH File Transfer Protocol (**SFTP**)
+  - File Transfer Protocol (**FTP**)
+  - Amazon Simple Storage Service (**Amazon S3**)
+- Minimalistic and intuitive UI, that **mimics the look and feel of VSCode Explorer view**, including VS Code file icon themes
+- **Search/filter** files using wildcards and **JavaScript Regular Expressions**
+- **Synchronized browsing**
+- Copy files keeping relative paths, allows **synchronization files in nested folders in one click**
+- **Remote file editing**
+- **Files' Git statuses** (uses your machine's Git installation)
+- Connections/servers are **plain files stored on your filesystem**, no need to export/import
+- **Easy to copy and backup connections and settings** in `~/.f5` folder, e.g. by putting them into a Git repo
+- **Drag & drop**, **copy & paste** files support
+- Use browser **tabs** to browse more than one server or transfer files simultaneously
+- Utilize the **built-in browser password manager** to store passwords
+- **Open files and folders** in default app or **Visual Studio Code**
+- **Theming**: System preference, Light, Dark; a different color theme per connection; the most popular file and folder icon themes from VS Code
 - Search On Type
 
 ## Feedbacks

package/dist/App.js

@@ -75,6 +75,8 @@ class App {
                     message: `
                         <p>A new version of the FileFive is available!</p>
                         <p>Current version: <em>${versions[0]}</em> → New version: <em>${versions[1]}</em></p>
+                        <p>To update, run:</p>
+                        <pre> npm update -g filefive</pre>
                     `
                 });
             }

package/dist/Connection.js

@@ -47,17 +47,23 @@ 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 S3_1 = __importStar(require("./fs/S3"));
 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, password, privatekey) {
-        const id = (0, URI_1.connectionID)(scheme, user, host, port);
-        const attrs = (scheme == 'sftp') ? SFtp_1.ATTRIBUTES : Ftp_1.ATTRIBUTES;
+    static async open(protocol, user, host, port, password, privatekey) {
+        const id = (0, URI_1.connectionID)(protocol, user, host, port);
+        const attrs = {
+            sftp: SFtp_1.ATTRIBUTES,
+            ftp: Ftp_1.ATTRIBUTES,
+            s3: S3_1.ATTRIBUTES
+        }[protocol];
         if (this.shared.inc(id)) {
             return attrs;
         }
+        this.protocols.set(id, protocol);
         if (privatekey) {
             if (privatekey.startsWith('~')) {
                 privatekey = (0, node_path_1.join)((0, node_os_1.homedir)(), privatekey.substring(1));
@@ -183,15 +189,23 @@ class default_1 {
             return;
         }
         const [authType, credential] = this.credentials.get(id);
-        switch (scheme) {
+        const protocol = this.protocols.get(id);
+        if (!protocol) {
+            throw new Error(`Protocol ${protocol} not found`);
+        }
+        switch (protocol) {
             case 'sftp': {
                 return new SFtp_1.default(host, user, authType == 'password' ? credential : '', authType == 'key' ? credential : null, port, error => log_1.default.error('SFTP error:', error), onClose);
             }
             case 'ftp': {
                 return new Ftp_1.default(host, user, credential, port, error => log_1.default.error('FTP error:', error), onClose);
             }
+            case 's3': {
+                return new S3_1.default(`${scheme}:\\${host}`, user, credential, 'us-east-1', // TODO
+                port, error => log_1.default.error('S3 error:', error), onClose);
+            }
             default:
-                throw new Error(`Unsupported scheme ${scheme}`);
+                throw new Error(`Unsupported protocol ${protocol}`);
         }
     }
 }
@@ -202,5 +216,6 @@ default_1.pools = new Map();
 default_1.queue = [];
 default_1.pending = {};
 default_1.limits = new Map();
+default_1.protocols = new Map();
 default_1.credentials = new Map();
 exports.default = default_1;

package/dist/commands/connect.js

@@ -25,8 +25,8 @@ function explorerSettings(attributes, config) {
                 .filter(ramda_1.isNotNil),
             ...attributes
                 .filter(({ name }) => !config.columns.find(c => name == c.name))
-                .map(a => ({ ...a, visible: false, width: 300 }))
-        ] : attributes.map(a => ({ ...a, visible: true, width: 300 })),
+                .map(a => ({ ...a, visible: false, width: 250 }))
+        ] : attributes.map(a => ({ ...a, visible: true, width: 250 })),
         ...({
             sort: config?.sort ?? ['name', types_1.SortOrder.Asc],
             history: config?.history ?? [],

package/dist/commands/saveSettings.js

@@ -10,6 +10,7 @@ async function default_1(path, changes) {
     const config = {
         mode: settings.mode,
         theme: settings.theme,
+        fileTheme: settings.fileTheme,
         timeFmt: settings.timeFmt,
         sizeFmt: settings.sizeFmt,
         local: (0, saveConnection_1.getSettings)(settings.local),

package/dist/commands/settings.js

@@ -10,19 +10,24 @@ const Local_1 = require("../Local");
 const Local_2 = require("../fs/Local");
 const connect_1 = require("./connect");
 const keybindings_json_1 = __importDefault(require("../keybindings.json"));
+const languages_json_1 = __importDefault(require("../icon-themes/languages.json"));
+function loadFileIcons(theme) {
+    return import(`../icon-themes/${theme}.json`, { with: { type: "json" } });
+}
 async function default_1(path) {
     let config = null;
     try {
         config = JSON.parse(await (0, Local_1.read)(path));
     }
     catch (e) { }
-    return {
+    const settings = {
         home: (0, node_os_1.homedir)(),
         settings: (0, node_path_1.join)((0, node_os_1.homedir)(), '.f5', 'settings.json'),
         connections: (0, node_path_1.join)((0, node_os_1.homedir)(), '.f5', 'connections'),
         keybindings: keybindings_json_1.default,
         mode: config?.mode ?? 'system',
         theme: config?.theme ?? 'black',
+        fileTheme: config?.fileTheme ?? '',
         timeFmt: config?.timeFmt ?? 'yyyy-MM-dd HH:mm',
         sizeFmt: config?.sizeFmt ?? '0.0 b',
         local: (0, connect_1.explorerSettings)(Local_2.ATTRIBUTES, config?.local),
@@ -30,4 +35,8 @@ async function default_1(path) {
         path: config?.path ?? { local: (0, node_os_1.homedir)(), remote: (0, node_os_1.homedir)() },
         sync: config?.sync ?? null
     };
+    if (settings.fileTheme) {
+        settings.fileIcons = { languages: languages_json_1.default, ...(await loadFileIcons(settings.fileTheme)).default };
+    }
+    return settings;
 }

package/dist/fs/Local.js

@@ -62,7 +62,7 @@ class Local extends FileSystem_1.FileSystem {
         await (0, promises_1.cp)(from, to, { recursive, force: true });
     }
     async write(path, data) {
-        await (0, promises_1.writeFile)(path, data);
+        return (0, promises_1.writeFile)(path, data);
     }
 }
 exports.default = Local;

package/dist/fs/S3.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATTRIBUTES = void 0;
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const path_1 = require("../utils/path");
+const FileSystem_1 = require("../FileSystem");
+const client_s3_1 = require("@aws-sdk/client-s3");
+// https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/
+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"
+    }
+];
+class S3 extends FileSystem_1.FileSystem {
+    constructor(host = 'https://s3.amazonaws.com', // the global endpoint (auto-detects the bucket's region)
+    accessKeyId, secretAccessKey, region = 'us-east-1', // the default region, particularly for legacy or unspecified requests
+    port = 443, onError = (e) => { }, onClose = () => { }) {
+        super();
+        this.host = host;
+        this.accessKeyId = accessKeyId;
+        this.secretAccessKey = secretAccessKey;
+        this.region = region;
+        this.port = port;
+        this.onError = onError;
+        this.onClose = onClose;
+    }
+    async open() {
+        try {
+            this.connection = new client_s3_1.S3Client({
+                endpoint: `${this.host}:${this.port}`,
+                region: this.region,
+                forcePathStyle: true, // Needed for MinIO and some other non-AWS services
+                credentials: {
+                    accessKeyId: this.accessKeyId,
+                    secretAccessKey: this.secretAccessKey
+                }
+            });
+        }
+        catch (e) {
+            this.onError(e);
+        }
+        return Promise.resolve(true);
+    }
+    close() {
+        this.connection && this.onClose();
+        this.connection?.destroy();
+        this.connection = null;
+    }
+    opened() {
+        return this.connection != null;
+    }
+    async pwd() {
+        return Promise.resolve('/');
+    }
+    async ls(dir) {
+        const parts = (0, path_1.split)(dir);
+        if (!parts.length) {
+            return this.listBuckets();
+        }
+        const target = parts.length > 1 ? parts.slice(1).join('/') + '/' : undefined;
+        const output = await this.connection.send(new client_s3_1.ListObjectsCommand({
+            Bucket: parts[0],
+            MaxKeys: 1000,
+            Delimiter: '/',
+            Prefix: target
+        }));
+        return [
+            ...(output.CommonPrefixes ?? []).map(prefix => ({
+                path: (0, node_path_1.resolve)('/', parts[0], prefix.Prefix),
+                name: (0, node_path_1.basename)(prefix.Prefix),
+                dir: true,
+                size: 0,
+                modified: new Date()
+            })),
+            ...(output.Contents ?? [])
+                .filter(({ Key }) => Key != target)
+                .map(item => ({
+                path: (0, node_path_1.resolve)('/', parts[0], item.Key),
+                name: (0, node_path_1.basename)(item.Key),
+                dir: false,
+                size: item.Size,
+                modified: new Date(item.LastModified)
+            }))
+        ];
+    }
+    async get(fromRemote, toLocal) {
+        const parts = (0, path_1.split)(fromRemote);
+        const output = await this.connection.send(new client_s3_1.GetObjectCommand({
+            Bucket: parts[0],
+            Key: parts.slice(1).join('/')
+        }));
+        if (output.Body) {
+            const body = output.Body;
+            const writeStream = (0, node_fs_1.createWriteStream)(toLocal);
+            body.pipe(writeStream);
+            return new Promise((resolve, reject) => {
+                writeStream.on('finish', resolve);
+                writeStream.on('error', reject);
+            });
+        }
+        return Promise.resolve();
+    }
+    async put(fromLocal, toRemote) {
+        const parts = (0, path_1.split)(toRemote);
+        const { UploadId } = await this.connection.send(new client_s3_1.CreateMultipartUploadCommand({
+            Bucket: parts[0],
+            Key: parts.slice(1).join('/')
+        }));
+        const partSize = 5 * 1024 * 1024;
+        const fromStream = (0, node_fs_1.createReadStream)(fromLocal, { highWaterMark: partSize });
+        let buffer = [];
+        let partNumber = 1;
+        const uploadParts = [];
+        const uploadPart = async () => {
+            const { ETag } = await this.connection.send(new client_s3_1.UploadPartCommand({
+                Bucket: parts[0],
+                Key: parts.slice(1).join('/'),
+                PartNumber: partNumber,
+                UploadId,
+                Body: Buffer.concat(buffer)
+            }));
+            uploadParts.push({ ETag, PartNumber: partNumber });
+            partNumber++;
+            buffer = [];
+        };
+        for await (const chunk of fromStream) {
+            buffer.push(chunk);
+            if (buffer.length >= partSize) {
+                await uploadPart();
+            }
+        }
+        if (buffer.length) {
+            await uploadPart();
+        }
+        await this.connection.send(new client_s3_1.CompleteMultipartUploadCommand({
+            Bucket: parts[0],
+            Key: parts.slice(1).join('/'),
+            UploadId,
+            MultipartUpload: { Parts: uploadParts }
+        }));
+    }
+    async rm(path, recursive) {
+        const parts = (0, path_1.split)(path);
+        await this.connection.send(new client_s3_1.DeleteObjectCommand({
+            Bucket: parts[0],
+            Key: parts.slice(1).join('/') + (recursive ? '/' : '')
+        }));
+    }
+    async mkdir(path) {
+        const parts = (0, path_1.split)(path);
+        try {
+            await this.connection.send(new client_s3_1.PutObjectCommand({
+                Bucket: parts[0],
+                Key: parts.slice(1).join('/') + '/',
+                Body: ''
+            }));
+        }
+        catch (e) {
+            this.onError(e);
+        }
+    }
+    async rename(from, to) {
+        return this.mv(from, to);
+    }
+    async mv(from, to) {
+        const isDir = (await this.ls((0, node_path_1.dirname)(from))).find(({ path }) => path == from)?.dir ?? false;
+        await this.cp(from, to, isDir);
+        const recursiveRm = async (path) => {
+            await Promise.all((await this.ls(path)).map(f => f.dir ? recursiveRm(f.path) : this.rm(f.path, false)));
+            await this.rm(path, true);
+        };
+        await (isDir ? recursiveRm(from) : this.rm(from, isDir));
+    }
+    async cp(from, to, recursive) {
+        if (recursive) {
+            await Promise.all((await this.ls(from)).map(f => this.cp(f.path, (0, node_path_1.resolve)(to, f.name), f.dir)));
+        }
+        else {
+            const parts = (0, path_1.split)(from);
+            await this.connection.send(new client_s3_1.CopyObjectCommand({
+                Bucket: parts[0],
+                CopySource: (0, node_path_1.resolve)(from) + (recursive ? '/' : ''),
+                Key: (0, path_1.split)(to).slice(1).join('/') + (recursive ? '/' : '')
+            }));
+        }
+    }
+    async write(path, s) {
+        const parts = (0, path_1.split)(path);
+        try {
+            await this.connection.send(new client_s3_1.PutObjectCommand({
+                Bucket: parts[0],
+                Key: parts.slice(1).join('/'),
+                Body: s
+            }));
+        }
+        catch (e) {
+            this.onError(e);
+        }
+    }
+    async listBuckets() {
+        const output = await this.connection.send(new client_s3_1.ListBucketsCommand({}));
+        return (output.Buckets ?? []).map(bucket => ({
+            path: (0, node_path_1.join)('/', bucket.Name),
+            name: bucket.Name,
+            dir: true,
+            size: 0,
+            modified: bucket.CreationDate ? new Date(bucket.CreationDate) : new Date()
+        }));
+    }
+}
+exports.default = S3;