fslib.js

/*
 * GNU AGPL-3.0 License
 *
 * Copyright (c) 2021 - present core.ai . All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License along
 * with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
 *
 */

// jshint ignore: start
/*global globalObject*/
/*eslint no-console: 0*/
/*eslint strict: ["error", "global"]*/

// Ensure globalObject is available in both browser and web worker contexts
// virtualfs.js sets this up, but we need a fallback for safety
if (typeof globalObject === 'undefined') {
    if (typeof window !== 'undefined') {
        window.globalObject = window;
    } else if (typeof self !== 'undefined') {
        self.globalObject = self;
    }
}

const {ERR_CODES, Errors} = require('./errno');
const {NativeFS} = require('./fslib_native');
const {TauriFS} = require('./fslib_tauri');
const {ElectronFS} = require('./fslib_electron');
const {NodeTauriFS} = require('./fslib_node_ws');
const {FilerFSModified} = require('./fslib_filer');
const {Constants} = require('./constants');
const {Mounts} = require('./fslib_mounts');
const {FsWatch} = require('./fslib_watch');
const {globalCopy} = require('./filerlib_copy.js');
const picomatch = require('picomatch/posix');
const ignore = require('ignore');
import * as iconv from 'iconv-lite';

let filerLib = null;
let filerShell = null;

/**
 * Offers functionality similar to mkdir -p
 *
 * Asynchronous operation. No arguments other than a possible exception
 * are given to the completion callback.
 */
function _mkdir_p (fsLib, path, mode, callback, _position) {
    const osSep = '/';
    const parts = filerLib.path.normalize(path).split(osSep);

    mode = mode || process.umask();
    _position = _position || 0;

    if (_position >= parts.length) {
        return callback(null);
    }

    var directory = parts.slice(0, _position + 1).join(osSep) || osSep;
    fsLib.stat(directory, function(err) {
        if (err === null) {
            _mkdir_p(fsLib, path, mode, callback, _position + 1);
        } else {
            fsLib.mkdir(directory, mode, function (error) {
                if (error && error.code !== 'EEXIST') {
                    return callback(error);
                } else {
                    _mkdir_p(fsLib, path, mode, callback, _position + 1);
                }
            });
        }
    });
}

function _ensure_mount_directory() {
    fileSystemLib.mkdirs(Constants.MOUNT_POINT_ROOT);
    fileSystemLib.mkdirs(Constants.TAURI_ROOT);
    NativeFS.refreshMountPoints();
}

function _getFirstFunctionIndex(argsArray) {
    for(let i=0; i<argsArray.length; i++){
        if (typeof argsArray[i] === 'function') {
            return i;
        }
    }
    return -1;
}

function _isSubPathOf(dir, subDir) {
    const relative = filerLib.path.relative(dir, subDir);
    return relative && !relative.startsWith('..') && !filerLib.path.isAbsolute(relative);
}

const fileSystemLib = {
    mountNativeFolder: async function (...args) {
        // Opens a file picker(or use provided handle) to open the folder in the system with fs access api.
        // to be used in browsers like chrome/edge that supports fs access apis
        return NativeFS.mountNativeFolder(...args);
    },
    openTauriFilePickerAsync: function (options) {
        if(globalObject.__ELECTRON__) {
            return ElectronFS.openElectronFilePickerAsync(options);
        }
        return TauriFS.openTauriFilePickerAsync(options);
    },
    openTauriFileSaveDialogueAsync: function (options) {
        if(globalObject.__ELECTRON__) {
            return ElectronFS.openElectronFileSaveDialogueAsync(options);
        }
        return TauriFS.openTauriFileSaveDialogueAsync(options);
    },
    getTauriPlatformPath: function (virtualPath) {
        if(TauriFS.isTauriPath(virtualPath) || TauriFS.isTauriSubPath(virtualPath)) {
            return TauriFS.getTauriPlatformPath(virtualPath);
        }
        return null;
    },
    getTauriVirtualPath: function (platformPath) {
        return TauriFS.getTauriVirtualPath(platformPath);
    },
    readdir: function (...args) { // (path, options, callback)
        let path = args[0];
        if(TauriFS.isTauriPath(path) || TauriFS.isTauriSubPath(path)) {
            if(globalObject.__ELECTRON__) {
                return ElectronFS.readdir(...args);
            }
            return TauriFS.readdir(...args);
        }
        if(Mounts.isMountPath(path) || Mounts.isMountSubPath(path)) {
            return NativeFS.readdir(...args);
        }
        return filerLib.fs.readdir(...args);
    },
    stat: function (...args) { // (path, callback)
        let path = args[0];
        if(typeof path !== 'string') {
            let callback = args[_getFirstFunctionIndex(args)];
            return callback(new Errors.EINVAL(`Error Invalid path for stat: ${path}`));
        }
        if(TauriFS.isTauriSubPath(path)) {
            if(globalObject.__ELECTRON__) {
                return ElectronFS.stat(...args);
            }
            return TauriFS.stat(...args);
        }
        if(Mounts.isMountSubPath(path)) {
            return NativeFS.stat(...args);
        }
        return filerLib.fs.stat(...args);
    },
    readFile: function (...args) { // (path, options, callback)
        let path = args[0];
        if(TauriFS.isTauriSubPath(path)) {
            if(globalObject.__ELECTRON__) {
                return ElectronFS.readFile(...args);
            }
            return TauriFS.readFile(...args);
        } else if(Mounts.isMountSubPath(path)) {
            return NativeFS.readFile(...args);
        }
        return FilerFSModified.readFile(...args);
    },
    writeFile: function (...args) { // (path, data, options, callback)
        let path = args[0];
        let newFileCreated = false;
        function callbackInterceptor(...interceptedArgs) {
            let err = interceptedArgs.length >= 1 ? interceptedArgs[0] : null;
            if(!err){
                if(newFileCreated){
                    FsWatch.reportCreateEvent(path, false);
                } else {
                    FsWatch.reportChangeEvent(path);
                }
            }
            if(args.originalCallback){
                args.originalCallback(...interceptedArgs);
            }
        }
        let callbackIndex = _getFirstFunctionIndex(args);
        if(callbackIndex !== -1) {
            args.originalCallback = args[callbackIndex];
            args[callbackIndex] = callbackInterceptor;
        }

        if(TauriFS.isTauriSubPath(path)) {
            if(globalObject.__ELECTRON__) {
                return ElectronFS.writeFile(...args);
            }
            return TauriFS.writeFile(...args);
        }
        fileSystemLib.stat(path, (err)=>{
            if(err && err.code === ERR_CODES.ERROR_CODES.ENOENT){
                newFileCreated = true;
            }
            if(Mounts.isMountSubPath(path)) {
                return NativeFS.writeFile(...args);
            }
            return FilerFSModified.writeFile(...args);
        });
    },
    mkdir: function (...args) { // (path, mode, callback)
        let path = args[0];
        function callbackInterceptor(...interceptedArgs) {
            let err = interceptedArgs.length >= 1 ? interceptedArgs[0] : null;
            if(!err){
                FsWatch.reportCreateEvent(path, true);
            }
            if(args.originalCallback){
                args.originalCallback(...interceptedArgs);
            }
        }
        let callbackIndex = _getFirstFunctionIndex(args);
        if(callbackIndex !== -1) {
            args.originalCallback = args[callbackIndex];
            args[callbackIndex] = callbackInterceptor;
        }

        if(TauriFS.isTauriSubPath(path)) {
            if(globalObject.__ELECTRON__) {
                return ElectronFS.mkdirs(...args);
            }
            return TauriFS.mkdirs(...args);
        }
        if(Mounts.isMountSubPath(path)) {
            return NativeFS.mkdir(...args);
        }
        return filerLib.fs.mkdir(...args);
    },
    rename: function (oldPath, newPath, cb) {
        function callbackInterceptor(...args) {
            let err = args.length >= 1 ? args[0] : null;
            if(!err){
                if(!TauriFS.isTauriSubPath(oldPath) || !TauriFS.isTauriSubPath(newPath)) {
                    // we only need to manually handle watch events for non tauri paths as tauri watch is done at node
                    fileSystemLib.stat(newPath, (err, stat)=>{
                        const isDir = !err && stat.isDirectory();
                        if(!TauriFS.isTauriSubPath(oldPath)) {
                            FsWatch.reportUnlinkEvent(oldPath, isDir);
                        }
                        if(!TauriFS.isTauriSubPath(newPath)) {
                            FsWatch.reportCreateEvent(newPath, isDir);
                        }
                    });
                }
            }
            if(cb){
                cb(...args);
            }
        }
        if (_isSubPathOf(oldPath, newPath) || _isSubPathOf(newPath, oldPath)){
            callbackInterceptor(new Errors.EINVAL(`Error renaming as one is a sub-path of other: ${newPath}, ${oldPath}`));
            return ;
        }
        if(Mounts.isMountPath(oldPath) || Mounts.isMountPath(newPath)) {
            cb(new Errors.EPERM('Mount root directory cannot be renamed.'));
            return;
        } else if(TauriFS.isTauriPath(oldPath) || TauriFS.isTauriPath(newPath)) {
            cb(new Errors.EPERM('Tauri root directory cannot be renamed.'));
            return;
        }
        if(oldPath !== newPath && oldPath.toLowerCase() === newPath.toLowerCase()) {
            // in windows, we should be able to rename "a.txt" to "A.txt". Since windows is case-insensitive,
            // the below stat(A.txt) will return a stat for "a.txt" which is not what we want.
            if(TauriFS.isTauriSubPath(oldPath) && TauriFS.isTauriSubPath(newPath)) {
                if(globalObject.__ELECTRON__) {
                    return ElectronFS.rename(oldPath, newPath, callbackInterceptor);
                }
                return TauriFS.rename(oldPath, newPath, callbackInterceptor);
            } else if(Mounts.isMountSubPath(oldPath) && Mounts.isMountSubPath(newPath)) {
                return NativeFS.renameSameNameDiffCase(oldPath, newPath, callbackInterceptor);
            }
        }
        fileSystemLib.stat(newPath, (err)=>{
            if(!err){
                // the destination folder/file exists and we should not rename
                cb(new Errors.EEXIST('Cannot rename, The destination path exists: ' + newPath));
                return ;
            }
            if(TauriFS.isTauriSubPath(oldPath) && TauriFS.isTauriSubPath(newPath)) {
                if(globalObject.__ELECTRON__) {
                    return ElectronFS.rename(oldPath, newPath, callbackInterceptor);
                }
                return TauriFS.rename(oldPath, newPath, callbackInterceptor);
            } else if(Mounts.isMountSubPath(oldPath) && Mounts.isMountSubPath(newPath)) {
                return NativeFS.rename(oldPath, newPath, callbackInterceptor);
            }
            return filerLib.fs.rename(oldPath, newPath, callbackInterceptor);
        });
    },
    unlink: function (path, cb) {
        let isDir;
        function callbackInterceptor(...args) {
            let err = args.length >= 1 ? args[0] : null;
            if(!err){
                FsWatch.reportUnlinkEvent(path, isDir);
            }
            if(cb){
                cb(...args);
            }
        }

        if(Mounts.isMountPath(path) || TauriFS.isTauriPath(path)) {
            callbackInterceptor(new Errors.EPERM('Mount root directory cannot be deleted.'));
            return ;
        } else if(TauriFS.isTauriSubPath(path)) {
            if(globalObject.__ELECTRON__) {
                return ElectronFS.unlink(path, callbackInterceptor);
            }
            return TauriFS.unlink(path, callbackInterceptor);
        }

        fileSystemLib.stat(path, (err, stat)=>{
            isDir = !err && stat.isDirectory();
            // we do this to emit fs watch events for non-tauri path unlinks.
            // We only need to manually handle watch events for non tauri paths as tauri watch is done at node
            if(Mounts.isMountSubPath(path)) {
                return NativeFS.unlink(path, callbackInterceptor);
            }
            if (typeof path !== 'string') {
                callbackInterceptor(new Errors.EINVAL('Invalid arguments.'));
                return;
            }
            return filerShell.rm(path, { recursive: true }, callbackInterceptor);
        });
    },
    copy: function (src, dst, cb) {
        function callbackInterceptor(...args) {
            let err = args.length >= 1 ? args[0] : null;
            if(!err){
                fileSystemLib.stat(dst, (err, stat)=>{
                    const isDir = !err && stat.isDirectory();
                    FsWatch.reportCreateEvent(dst, isDir);
                });
            }
            if(cb){
                cb(...args);
            }
        }
        if (_isSubPathOf(src, dst)){
            callbackInterceptor(new Errors.EINVAL(`Error copying: ${dst} cannot be a subpath of ${src}`));
            return ;
        }
        // we have two implementation here even though the globalCopy fn is capable of copying anywhere. Native has its
        // own impl to prevent large number of file node io in fs access impl.
        // Ideally we should have a tauri copy impl too, but to unblock main thread while copy, we need to
        // spawn different threads in rust and write tauri handlers which is pretty complex atm. so instead we will
        // fall back to global copy here and will use node Tauri web socket fs adapter as and when it becomes available.
        if(Mounts.isMountSubPath(src) && Mounts.isMountSubPath(dst)) {
            return NativeFS.copy(src, dst, callbackInterceptor);
        } else if(TauriFS.isTauriSubPath(src) && TauriFS.isTauriSubPath(dst)) {
            if(globalObject.__ELECTRON__ && ElectronFS.canCopy()) {
                return ElectronFS.copy(src, dst, callbackInterceptor);
            }
            if(TauriFS.canCopy()) {
                return TauriFS.copy(src, dst, callbackInterceptor);
            }
            return globalCopy(src, dst, callbackInterceptor);
        } else {
            return globalCopy(src, dst, callbackInterceptor);
        }
    },
    showSaveDialog: function (options) {
        if(globalObject.__ELECTRON__){
            return fileSystemLib.openElectronFileSaveDialogueAsync(options);
        }
        // Default to Tauri for native environments (including workers via WebSocket)
        return fileSystemLib.openTauriFileSaveDialogueAsync(options);
    },
    watchAsync: function (path, gitIgnorePaths="") {
        if(TauriFS.isTauriPath(path)) {
            throw new Errors.EPERM('Cannot watch root directory!', path);
        } else if(TauriFS.isTauriSubPath(path)) {
            return NodeTauriFS.watchAsync(path, gitIgnorePaths);
        }
        return FsWatch.watchAsync(path, gitIgnorePaths);
    },
    unwatchAsync: function (eventEmitter) {
        if(eventEmitter.eventEmitterID) {
            return NodeTauriFS.unwatchAsync(eventEmitter);
        }
        return FsWatch.unwatchAsync(eventEmitter);
    },
    moveToTrash: function () {
        throw new Errors.ENOSYS('Phoenix fs moveToTrash function not yet supported.');
    },
    mkdirs: function (path, mode, recursive, callback) {
        // Determine if 'mode' is provided
        if (typeof mode !== 'number') {
            callback = recursive;
            recursive = mode;
            mode = 0o777; // Default mode (or any other default you'd like to set)
        }

        // Determine if 'recursive' is provided
        if (typeof recursive !== 'boolean') {
            callback = recursive;
            recursive = false;
        }

        // Determine if 'callback' is provided
        if (typeof callback !== 'function') {
            callback = function () {
                // Do Nothing
            };
        }

        if (!recursive) {
            fileSystemLib.mkdir(path, mode, callback);
        } else if(TauriFS.isTauriSubPath(path)) {
            if(globalObject.__ELECTRON__) {
                return ElectronFS.mkdirs(path, mode, true, callback);
            }
            return TauriFS.mkdirs(path, mode, true, callback);
        } else {
            _mkdir_p(fileSystemLib, path, mode, callback);
        }
    },
    testNodeWsEndpoint: function (wsEndPoint, echoData, echoBuffer) {
        return NodeTauriFS.testNodeWsEndpoint(wsEndPoint, echoData, echoBuffer);
    },
    setNodeWSEndpoint: function (wsEndPoint) {
        return NodeTauriFS.setNodeWSEndpoint(wsEndPoint);
    },
    stopNodeWSEndpoint: function (wsEndPoint) {
        return NodeTauriFS.stopNodeWSEndpoint(wsEndPoint);
    },
    getNodeWSEndpoint: function () {
        return NodeTauriFS.getNodeWSEndpoint();
    },
    forceUseNodeWSEndpoint: function (use) {
        if(globalObject.__ELECTRON__) {
            return ElectronFS.forceUseNodeWSEndpoint(use);
        }
        return TauriFS.forceUseNodeWSEndpoint(use);
    },
    preferNodeWSEndpoint: function (use) {
        if(globalObject.__ELECTRON__) {
            return ElectronFS.preferNodeWSEndpoint(use);
        }
        return TauriFS.preferNodeWSEndpoint(use);
    },
    BYTE_ARRAY_ENCODING: Constants.BYTE_ARRAY_ENCODING,
    MOUNT_POINT_ROOT: Constants.MOUNT_POINT_ROOT,
    TAURI_ROOT: Constants.TAURI_ROOT,
    ERR_CODES: {},
    WATCH_EVENTS: Constants.WATCH_EVENTS,
    isEncodingSupported: function (encoding) {
        if(encoding.toLowerCase() === Constants.BYTE_ARRAY_ENCODING){
            return true;
        }
        return iconv.encodingExists(encoding);
    },
    utils: {
        iconv,
        picomatch,
        ignore
    }
};

for(let errCode of Object.values(ERR_CODES.FS_ERROR_CODES)){
    fileSystemLib.ERR_CODES[errCode] = errCode;
}

fileSystemLib.copyFile = fileSystemLib.copy;
fileSystemLib.name = 'phoenixFS';

function _populateSupportedEncodings() {
    if(iconv.encodingExists('utf8')) {
        // we do this as iconv bootstraps this
        const SUPPORTED_ENCODINGS = [];
        for(let encoding of Object.keys(iconv.encodings)) {
            // the Object.keys list contains encoding functions and privates. so filter
            if(iconv.encodingExists(encoding)) {
                SUPPORTED_ENCODINGS.push(encoding);
            }
        }
        SUPPORTED_ENCODINGS.push(fileSystemLib.BYTE_ARRAY_ENCODING);
        fileSystemLib.SUPPORTED_ENCODINGS = SUPPORTED_ENCODINGS;
    }
}

function initFsLib(FilerLib) {
    filerLib = FilerLib;
    FilerFSModified.initFilerLib(filerLib);
    filerShell = new filerLib.fs.Shell();
    globalObject.path = FilerLib.path;
    globalObject.Buffer = FilerLib.Buffer;
    globalObject.iconv = iconv;
    globalObject.fs = fileSystemLib;
    globalObject.fs.path = FilerLib.path;
    globalObject.fs.Buffer = FilerLib.Buffer;
    _populateSupportedEncodings();
    _ensure_mount_directory();
}

module.exports ={
    initFsLib
};