filefive 1.0.0

package/dist/Queue.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queues = void 0;
+const node_path_1 = require("node:path");
+const types_1 = require("./types");
+const Local_1 = require("./Local");
+const URI_1 = require("./utils/URI");
+const ramda_1 = require("ramda");
+const rxjs_1 = require("rxjs");
+const Connection_1 = __importDefault(require("./Connection"));
+const log_1 = __importDefault(require("./log"));
+class Queue {
+    constructor(type, connId, src, dest, watcher, onState, onConflict, onError, onComplete) {
+        this.type = type;
+        this.connId = connId;
+        this.watcher = watcher;
+        this.onState = onState;
+        this.onConflict = onConflict;
+        this.onError = onError;
+        this.onComplete = onComplete;
+        this.queue = [];
+        this.queue$ = new rxjs_1.Subject();
+        this.totalCnt = 0;
+        this.doneCnt = 0;
+        this.totalSize = 0;
+        this.doneSize = 0;
+        this.pending = [];
+        this.touched = new Set();
+        if (type == types_1.QueueType.Download) {
+            this.download(src, (0, URI_1.parseURI)(dest)['path']);
+        }
+        else if (type == types_1.QueueType.Upload) {
+            this.upload(src.map(uri => (0, URI_1.parseURI)(uri)['path']), dest);
+        }
+        else {
+            this.remove(src.map(uri => (0, URI_1.parseURI)(uri)['path']));
+        }
+    }
+    resolve(action, forAll = false) {
+        forAll && (this.action = action);
+        const drained = !this.queue.length;
+        this.queue.push(...this.pending.splice(0, forAll ? this.pending.length : 1).map(f => ({ from: f.src, to: f.dest.path, action })));
+        drained && this.queue$.next(this.queue.shift());
+        if (this.pending.length) {
+            const { src, dest } = this.pending[0];
+            this.onConflict(src, dest);
+        }
+    }
+    close() {
+        if (this.processing?.closed === false) {
+            this.processing?.unsubscribe();
+            this.onComplete();
+            if (this.type == types_1.QueueType.Upload || this.type == types_1.QueueType.Remove) {
+                this.touched.forEach(path => this.watcher.refresh(this.connId + path));
+            }
+        }
+    }
+    async download(src, dest) {
+        await this.enqueue(src.map((0, ramda_1.pipe)(URI_1.parseURI, (0, ramda_1.prop)('path'))), dest, (0, ramda_1.memoizeWith)(ramda_1.identity, (path) => Connection_1.default.list(this.connId, path)));
+        const transmit = async (fs, from, to) => {
+            await (0, Local_1.touch)(to);
+            log_1.default.log(`start downloading ${from.path} -> ${to}`);
+            try {
+                await fs.get(from.path, to);
+            }
+            catch (error) {
+                this.onError(error);
+            }
+            log_1.default.log(`end downloading ${from.path}`);
+            this.sendState(from.size);
+        };
+        this.processing = this.queue$.subscribe(async ({ from, to, action }) => {
+            let a = action ?? this.action;
+            const existing = (0, Local_1.stat)(to);
+            if (existing) {
+                if (a) {
+                    if (a.type == types_1.QueueActionType.Skip) {
+                        this.sendState(from.size);
+                        return this.next();
+                    }
+                }
+                else {
+                    this.putOnHold(from, existing);
+                    return this.next();
+                }
+            }
+            const [fs, close] = await Connection_1.default.transmit(this.connId);
+            existing ?
+                this.applyAction(a, from, existing, transmit.bind(this, fs)).then(close) :
+                transmit(fs, from, to).then(close);
+            this.next();
+        });
+        this.next();
+    }
+    async upload(src, dest) {
+        const conn = Connection_1.default.get(this.connId);
+        const to = (0, URI_1.parseURI)(dest)['path'];
+        await this.enqueue(src, to, path => Promise.resolve((0, Local_1.list)(path)));
+        this.touched.add(to);
+        const transmit = async (fs, from, to) => {
+            if (!((0, Local_1.stat)(from.path))) {
+                return;
+            }
+            log_1.default.log(`start uploading ${from.path} -> ${to}`);
+            try {
+                const dir = (0, node_path_1.dirname)(to);
+                if (!this.touched.has(dir)) {
+                    await fs.mkdir(dir);
+                }
+                await fs.put(from.path, to);
+                this.touched.add(dir);
+            }
+            catch (error) {
+                this.onError(error);
+            }
+            log_1.default.log(`end uploading ${from.path}`);
+            this.sendState(from.size);
+        };
+        const ls = (0, ramda_1.memoizeWith)(ramda_1.identity, async (path) => {
+            try {
+                return await conn.ls(path);
+            }
+            catch (e) { }
+            return [];
+        });
+        const exists = async (path) => (await ls((0, node_path_1.dirname)(path))).find((0, ramda_1.whereEq)({ path }));
+        this.processing = this.queue$.subscribe(async ({ from, to, action }) => {
+            let a = action ?? this.action;
+            const existing = await exists(to);
+            if (existing) {
+                if (a) {
+                    if (a.type == types_1.QueueActionType.Skip) {
+                        this.sendState(from.size);
+                        return this.next();
+                    }
+                }
+                else {
+                    this.putOnHold(from, existing);
+                    return this.next();
+                }
+            }
+            const [fs, close] = await Connection_1.default.transmit(this.connId);
+            existing ?
+                this.applyAction(a, from, existing, transmit.bind(this, fs)).then(close) :
+                transmit(fs, from, to).then(close);
+            this.next();
+        });
+        this.next();
+    }
+    async remove(paths) {
+        this.totalCnt = paths.length;
+        const touched = new Map();
+        paths.forEach(async (path) => {
+            const dir = (0, node_path_1.dirname)(path);
+            const [conn, close] = await Connection_1.default.transmit(this.connId);
+            if (!touched.has(dir)) {
+                try {
+                    touched.set(dir, await conn.ls(dir));
+                }
+                catch (e) {
+                    touched.set(dir, null);
+                }
+            }
+            const name = (0, node_path_1.basename)(path);
+            const file = touched.get(dir)?.find(f => f.name == name);
+            if (file) {
+                try {
+                    await conn.rm(path, file.dir);
+                }
+                catch (error) {
+                    this.onError({
+                        type: types_1.FailureType.RemoteError,
+                        id: this.connId,
+                        error
+                    });
+                }
+            }
+            close();
+            this.sendState(0);
+            if (this.doneCnt == this.totalCnt) {
+                this.onComplete();
+                touched.forEach((files, dir) => {
+                    this.watcher.refresh((0, URI_1.createURI)(this.connId, dir));
+                });
+            }
+        });
+    }
+    next() {
+        if (this.queue.length) {
+            this.queue$.next(this.queue.shift());
+        }
+        else if (!this.pending.length) {
+            this.close();
+        }
+    }
+    async enqueue(paths, dest, ls) {
+        const add = async (path, to) => {
+            const from = (await ls((0, node_path_1.dirname)(path))).find((0, ramda_1.whereEq)({ path }));
+            from && (from.dir ?
+                (await ls(path)).forEach(async (f) => await add(f.path, (0, node_path_1.join)(to, (0, node_path_1.basename)(path)))) :
+                this.queue.push({ from, to: (0, node_path_1.join)(to, (0, node_path_1.basename)(path)) }));
+        };
+        for (const path of paths) {
+            await add(path, dest);
+        }
+        this.queue.forEach(({ from: { size } }) => { this.totalCnt++; this.totalSize += size; });
+    }
+    applyAction(action, from, to, transmit) {
+        switch (action.type) {
+            case types_1.QueueActionType.Replace:
+                return transmit(from, to.path);
+        }
+    }
+    putOnHold(src, dest) {
+        this.pending.push({ src, dest });
+        if (this.pending.length == 1) {
+            this.onConflict(src, dest);
+        }
+    }
+    sendState(size) {
+        this.doneCnt++;
+        this.doneSize += size;
+        this.onState({
+            totalCnt: this.totalCnt,
+            doneCnt: this.doneCnt,
+            totalSize: this.totalSize,
+            doneSize: this.doneSize,
+            pending: this.pending.length
+        });
+    }
+}
+exports.default = Queue;
+exports.queues = new Map();

package/dist/RemoteWatcher.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 node_path_1 = require("node:path");
+const ReferenceCountMap_1 = __importDefault(require("./utils/ReferenceCountMap"));
+const Connection_1 = __importDefault(require("./Connection"));
+const URI_1 = require("./utils/URI");
+class RemoteWatcher {
+    constructor(listener, onMissing, transform = (files) => files) {
+        this.listener = listener;
+        this.onMissing = onMissing;
+        this.transform = transform;
+        this.watched = new ReferenceCountMap_1.default;
+    }
+    watch(uri) {
+        this.watched.inc(uri) || this.watched.set(uri, false);
+        this.refresh(uri);
+    }
+    unwatch(uri) {
+        this.watched.dec(uri);
+    }
+    refresh(uri) {
+        if (this.watched.has(uri)) {
+            this.list(uri);
+            Array.from(this.watched.keys()).forEach(dir => {
+                if (dir.startsWith(uri + node_path_1.sep)) {
+                    this.list(dir);
+                }
+            });
+        }
+    }
+    list(uri) {
+        const { id, path } = (0, URI_1.parseURI)(uri);
+        Connection_1.default.list(id, path)
+            .then(files => this.listener(uri, this.transform(files)))
+            .catch(e => {
+            this.watched.del(uri);
+            this.onMissing(uri);
+        });
+    }
+}
+exports.default = RemoteWatcher;

package/dist/Session.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Session {
+    static create() {
+        const sid = crypto.randomUUID();
+        this.sessions.set(sid, {});
+        return sid;
+    }
+    static remove(sid) {
+        this.sessions.delete(sid);
+    }
+    static get(sid) {
+        return this.sessions.get(sid);
+    }
+    static set(sid, settings) {
+        const s = this.sessions.get(sid);
+        s && this.sessions.set(sid, Object.assign(s, settings));
+    }
+}
+Session.sessions = new Map();
+exports.default = Session;

package/dist/commands/clear.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const node_path_1 = require("node:path");
+const types_1 = require("../types");
+const URI_1 = require("../utils/URI");
+const Connection_1 = __importDefault(require("../Connection"));
+const App_1 = __importDefault(require("../App"));
+async function default_1(file, force) {
+    if (!force) {
+        App_1.default.onError({ type: types_1.FailureType.ConfirmClear, file });
+        return;
+    }
+    const { id, path } = (0, URI_1.parseURI)(file);
+    await Connection_1.default.get(id).write(path, '');
+    if (id != types_1.LocalFileSystemID) {
+        App_1.default.remoteWatcher.refresh((0, URI_1.createURI)(id, (0, node_path_1.dirname)(path)));
+    }
+}

package/dist/commands/connect.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explorerSettings = explorerSettings;
+exports.default = default_1;
+const node_fs_1 = require("node:fs");
+const path_1 = require("path");
+const types_1 = require("../types");
+const Local_1 = require("../fs/Local");
+const URI_1 = require("../utils/URI");
+const Connection_1 = __importDefault(require("../Connection"));
+const Password_1 = __importDefault(require("../Password"));
+const Session_1 = __importDefault(require("../Session"));
+const ramda_1 = require("ramda");
+function explorerSettings(attributes, config) {
+    return {
+        columns: config ? [
+            ...config.columns
+                .map(({ name, width }) => {
+                const attribute = attributes.find((0, ramda_1.whereEq)({ name }));
+                return attribute ? { ...attribute, visible: true, width } : null;
+            })
+                .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 })),
+        ...({
+            sort: config?.sort ?? ['name', types_1.SortOrder.Asc],
+            history: config?.history ?? [],
+            filter: config?.filter ?? null
+        })
+    };
+}
+async function default_1(file, onError) {
+    const stat = (0, node_fs_1.statSync)(file);
+    if (!stat.isFile() && !stat.isSymbolicLink()) {
+        return false;
+    }
+    let config;
+    try {
+        config = JSON.parse((0, node_fs_1.readFileSync)(file).toString());
+    }
+    catch (e) {
+        throw new Error(`Invalid connection file ${file}`);
+    }
+    if (!(0, ramda_1.where)({
+        scheme: ramda_1.isNotEmpty,
+        user: ramda_1.isNotEmpty,
+        host: ramda_1.isNotEmpty,
+        port: ramda_1.isNotEmpty
+    }, config)) {
+        throw new Error(`Invalid connection file ${file}`);
+    }
+    const id = (0, URI_1.connectionID)(config.scheme, config.user, config.host, config.port);
+    try {
+        await Password_1.default.get(id);
+    }
+    catch (e) {
+        return false;
+    }
+    try {
+        const attributes = await Connection_1.default.open(config.scheme, config.user, config.host, config.port);
+        const pwd = await Connection_1.default.get(id).pwd();
+        const settings = {
+            name: (0, path_1.parse)(file).name,
+            attributes,
+            pwd,
+            theme: config.theme ?? 'black',
+            local: explorerSettings(Local_1.ATTRIBUTES, config.local),
+            remote: explorerSettings(attributes, config.remote),
+            path: {
+                local: config.path?.local,
+                remote: config.path?.remote ?? pwd
+            },
+            sync: config.sync ?? null
+        };
+        return { id, sid: Session_1.default.create(), settings };
+    }
+    catch (e) {
+        Password_1.default.delete(id, false);
+        onError(id, e);
+        return false;
+    }
+}

package/dist/commands/copy.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const URI_1 = require("../utils/URI");
+const types_1 = require("../types");
+const Queue_1 = require("../queues/Queue");
+const Session_1 = __importDefault(require("../Session"));
+const Copy_1 = __importDefault(require("../queues/Copy"));
+const Download_1 = __importDefault(require("../queues/Download"));
+const Upload_1 = __importDefault(require("../queues/Upload"));
+const uniqid_1 = __importDefault(require("../utils/uniqid"));
+const App_1 = __importDefault(require("../App"));
+const ramda_1 = require("ramda");
+function default_1(src, dest, move, filter, sid, onComplete = () => { }) {
+    if (!src.length) {
+        return;
+    }
+    const { id: fromId } = (0, URI_1.parseURI)(src[0]);
+    const { id: toId, path: toPath } = (0, URI_1.parseURI)(dest);
+    const from = src.map((0, ramda_1.pipe)(URI_1.parseURI, (0, ramda_1.prop)('path')));
+    const id = (0, uniqid_1.default)();
+    let queueType;
+    let connection;
+    let queue;
+    const onConflict = (from, to) => {
+        if (sid) {
+            const action = Session_1.default.get(sid)?.action;
+            if (action) {
+                Queue_1.queues.get(id)?.resolve(action, true);
+                return;
+            }
+        }
+        App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Ask, queueType, from, to, sid });
+    };
+    const onFinish = () => {
+        Queue_1.queues.delete(id);
+        App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Complete });
+        onComplete();
+    };
+    if (fromId == toId) {
+        queueType = move ? types_1.QueueType.Move : types_1.QueueType.Copy;
+        connection = fromId;
+        queue = new Copy_1.default(connection, from, toPath, filter, state => App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Update, state }), onConflict.bind(queue), error => {
+            App_1.default.onError({
+                type: types_1.FailureType.RemoteError,
+                id: fromId,
+                message: error.message ?? String(error)
+            });
+        }, onFinish, App_1.default.remoteWatcher, move);
+    }
+    else {
+        queueType = (0, URI_1.isLocal)(dest) ? types_1.QueueType.Download : types_1.QueueType.Upload;
+        connection = queueType == types_1.QueueType.Download ? fromId : toId;
+        queue = queueType == types_1.QueueType.Download ?
+            new Download_1.default(connection, from, toPath, filter, state => App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Update, state }), onConflict.bind(queue), error => App_1.default.onError(error), onFinish) :
+            new Upload_1.default(connection, from, toPath, filter, state => App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Update, state }), onConflict.bind(queue), error => App_1.default.onError(error), onFinish, App_1.default.remoteWatcher);
+    }
+    Queue_1.queues.set(id, queue);
+    App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Create, queueType, connection });
+    queue.create();
+    return id;
+}

package/dist/commands/disconnect.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const Session_1 = __importDefault(require("../Session"));
+const Connection_1 = __importDefault(require("../Connection"));
+function default_1(id, sid) {
+    Session_1.default.remove(sid);
+    Connection_1.default.close(id);
+}

package/dist/commands/duplicate.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 });
+exports.default = default_1;
+const node_path_1 = require("node:path");
+const URI_1 = require("../utils/URI");
+const types_1 = require("../types");
+const Queue_1 = require("../queues/Queue");
+const Duplicate_1 = __importDefault(require("../queues/Duplicate"));
+const uniqid_1 = __importDefault(require("../utils/uniqid"));
+const App_1 = __importDefault(require("../App"));
+function default_1(src, filter) {
+    if (!src.length) {
+        return;
+    }
+    const { id: connection } = (0, URI_1.parseURI)(src[0]);
+    const targets = new Map();
+    src.forEach(uri => {
+        const { path } = (0, URI_1.parseURI)(uri);
+        const parent = (0, node_path_1.dirname)(path);
+        if (!targets.has(parent)) {
+            targets.set(parent, []);
+        }
+        targets.get(parent).push(path);
+    });
+    for (const [to, from] of targets) {
+        const id = (0, uniqid_1.default)();
+        const queue = new Duplicate_1.default(connection, from, to, filter, state => App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Update, state }), (from, to) => App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Ask, queueType: types_1.QueueType.Copy, from, to }), error => {
+            App_1.default.onError({
+                type: types_1.FailureType.RemoteError,
+                id: connection,
+                message: error.message ?? String(error)
+            });
+        }, () => {
+            Queue_1.queues.delete(id);
+            App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Complete });
+        }, App_1.default.remoteWatcher);
+        Queue_1.queues.set(id, queue);
+        App_1.default.onQueueUpdate(id, { type: types_1.QueueEventType.Create, queueType: types_1.QueueType.Copy, connection });
+        queue.create();
+    }
+}

package/dist/commands/getConnection.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const Local_1 = require("../Local");
+const Password_1 = __importDefault(require("../Password"));
+const URI_1 = require("../utils/URI");
+async function default_1(path) {
+    if (!(0, Local_1.stat)(path)) {
+        return null;
+    }
+    const config = JSON.parse(await (0, Local_1.read)(path));
+    config.password = await Password_1.default.get((0, URI_1.connectionID)(config.scheme, config.user, config.host, config.port), true);
+    return config;
+}

package/dist/commands/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+const connect_1 = __importDefault(require("./connect"));
+const disconnect_1 = __importDefault(require("./disconnect"));
+const watch_1 = __importDefault(require("./watch"));
+const unwatch_1 = __importDefault(require("./unwatch"));
+const copy_1 = __importDefault(require("./copy"));
+const remove_1 = __importDefault(require("./remove"));
+const clear_1 = __importDefault(require("./clear"));
+const mkdir_1 = __importDefault(require("./mkdir"));
+const read_1 = __importDefault(require("./read"));
+const write_1 = __importDefault(require("./write"));
+const settings_1 = __importDefault(require("./settings"));
+const rename_1 = __importDefault(require("./rename"));
+const getConnection_1 = __importDefault(require("./getConnection"));
+const saveConnection_1 = __importDefault(require("./saveConnection"));
+const saveSettings_1 = __importDefault(require("./saveSettings"));
+const duplicate_1 = __importDefault(require("./duplicate"));
+const resolve_1 = __importDefault(require("./resolve"));
+exports.commands = {
+    connect: connect_1.default,
+    disconnect: disconnect_1.default,
+    getSettings: settings_1.default,
+    watch: watch_1.default,
+    unwatch: unwatch_1.default,
+    copy: copy_1.default,
+    duplicate: duplicate_1.default,
+    remove: remove_1.default,
+    clear: clear_1.default,
+    mkdir: mkdir_1.default,
+    read: read_1.default,
+    write: write_1.default,
+    rename: rename_1.default,
+    getConnection: getConnection_1.default,
+    saveConnection: saveConnection_1.default,
+    saveSettings: saveSettings_1.default,
+    resolve: resolve_1.default
+};

package/dist/commands/mkdir.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const types_1 = require("../types");
+const promises_1 = require("node:fs/promises");
+const Connection_1 = __importDefault(require("../Connection"));
+const URI_1 = require("../utils/URI");
+const node_path_1 = require("node:path");
+const path_1 = require("../utils/path");
+const App_1 = __importDefault(require("../App"));
+async function default_1(name, parent) {
+    let { id, path } = (0, URI_1.parseURI)(parent);
+    try {
+        if (id == types_1.LocalFileSystemID) {
+            await (0, promises_1.mkdir)((0, node_path_1.join)(path, name), { recursive: true });
+        }
+        else {
+            const parts = (0, path_1.split)(name);
+            const conn = Connection_1.default.get(id);
+            for (let i = 0; i < parts.length; i++) {
+                path = (0, node_path_1.join)(path, parts[i]);
+                try {
+                    await conn.mkdir(path);
+                }
+                catch (e) {
+                    if (i == parts.length - 1) {
+                        throw e;
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        App_1.default.onError({ type: types_1.FailureType.RemoteError, id, message: 'message' in error ? error.message : String(error) });
+    }
+    if (!(0, URI_1.isLocal)(parent)) {
+        App_1.default.remoteWatcher.refresh(parent);
+    }
+}

package/dist/commands/read.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const Local_1 = require("../Local");
+const URI_1 = require("../utils/URI");
+async function default_1(file) {
+    const { id, path } = (0, URI_1.parseURI)(file);
+    if ((0, URI_1.isLocal)(file)) {
+        return (0, Local_1.read)(path);
+    }
+    // TODO
+    return '';
+}