@internxt/cli 1.6.2 → 1.6.3

package/dist/services/drive/drive-folder.service.js

@@ -1,69 +1,195 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveFolderService = void 0;
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const sdk_manager_service_1 = require("../sdk-manager.service");
 const drive_utils_1 = require("../../utils/drive.utils");
+const auth_service_1 = require("../auth.service");
+const drive_folder_repository_1 = require("../database/drive-folder/drive-folder.repository");
+const drive_folder_domain_1 = require("../database/drive-folder/drive-folder.domain");
+const drive_file_repository_1 = require("../database/drive-file/drive-file.repository");
+const drive_file_domain_1 = require("../database/drive-file/drive-file.domain");
+const errors_utils_1 = require("../../utils/errors.utils");
+const database_utils_1 = require("../../utils/database.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
 class DriveFolderService {
     static instance = new DriveFolderService();
     getFolderMetaByUuid = async (uuid) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folderMeta = await storageClient.getFolderMeta(uuid);
-        return drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+        const folderItem = drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+        if (folderItem?.status !== types_1.FileStatus.EXISTS) {
+            throw new errors_utils_1.NotFoundError(`Folder with uuid ${uuid} not found`);
+        }
+        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate([folderItem]);
+        return folderItem;
     };
     getFolderMetaById = async (id) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folderMeta = await storageClient.getFolderMetaById(id);
-        return drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+        const folderItem = drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate([folderItem]);
+        return folderItem;
     };
     getFolderContent = async (folderUuid) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const folders = await this.getAllSubfolders(storageClient, folderUuid, 0);
-        const files = await this.getAllSubfiles(storageClient, folderUuid, 0);
+        const folders = await this.getFolderSubfolders(folderUuid);
+        const files = await this.getFolderSubfiles(folderUuid);
         return { folders, files };
     };
-    getAllSubfolders = async (storageClient, folderUuid, offset) => {
-        const [folderContentPromise] = storageClient.getFolderFoldersByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
-        const { folders } = await folderContentPromise;
+    getFolderSubfolders = async (folderUuid) => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        const currentWorkspaceCreds = currentWorkspace?.workspaceCredentials;
+        const folders = await this.getAllSubfolders(currentWorkspaceCreds, folderUuid, 0);
+        return folders;
+    };
+    getFolderSubfiles = async (folderUuid) => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        const currentWorkspaceCreds = currentWorkspace?.workspaceCredentials;
+        const files = await this.getAllSubfiles(currentWorkspaceCreds, folderUuid, 0);
+        return files;
+    };
+    getAllSubfolders = async (currentWorkspace, folderUuid, offset) => {
+        let folders;
+        if (currentWorkspace) {
+            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+            const [workspaceContentPromise] = workspaceClient.getFolders(currentWorkspace.id, folderUuid, offset, 50, 'plainName', 'ASC');
+            folders = (await workspaceContentPromise).result;
+        }
+        else {
+            const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+            const [personalFolderContentPromise] = storageClient.getFolderFoldersByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
+            folders = (await personalFolderContentPromise).folders;
+        }
+        folders = folders.filter((folder) => folder.status === types_1.FileStatus.EXISTS);
+        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate(folders.map((folder) => new drive_folder_domain_1.DriveFolder({
+            uuid: folder.uuid,
+            name: folder.plainName,
+            parentUuid: folder.parentUuid,
+            status: types_1.FileStatus.EXISTS,
+            createdAt: new Date(folder.createdAt),
+            updatedAt: new Date(folder.updatedAt),
+            creationTime: new Date(folder.creationTime ?? folder.createdAt),
+            modificationTime: new Date(folder.modificationTime ?? folder.updatedAt),
+        })));
         if (folders.length > 0) {
-            return folders.concat(await this.getAllSubfolders(storageClient, folderUuid, offset + folders.length));
+            return folders.concat(await this.getAllSubfolders(currentWorkspace, folderUuid, offset + folders.length));
         }
         else {
             return folders;
         }
     };
-    getAllSubfiles = async (storageClient, folderUuid, offset) => {
-        const [folderContentPromise] = storageClient.getFolderFilesByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
-        const { files } = await folderContentPromise;
+    getAllSubfiles = async (currentWorkspace, folderUuid, offset) => {
+        let files;
+        if (currentWorkspace) {
+            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+            const [workspaceContentPromise] = workspaceClient.getFiles(currentWorkspace.id, folderUuid, offset, 50, 'plainName', 'ASC');
+            files = (await workspaceContentPromise).result;
+        }
+        else {
+            const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+            const [folderContentPromise] = storageClient.getFolderFilesByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
+            files = (await folderContentPromise).files;
+        }
+        files = files.filter((file) => file.status === types_1.FileStatus.EXISTS);
         if (files.length > 0) {
-            return files.concat(await this.getAllSubfiles(storageClient, folderUuid, offset + files.length));
+            await drive_file_repository_1.FileRepository.instance.deleteByParentUuid(folderUuid);
+            await drive_file_repository_1.FileRepository.instance.createOrUpdate(files.map((file) => new drive_file_domain_1.DriveFile({
+                uuid: file.uuid,
+                name: file.plainName,
+                type: file.type,
+                folderUuid: file.folderUuid,
+                status: types_1.FileStatus.EXISTS,
+                bucket: file.bucket,
+                size: Number(file.size ?? 0),
+                fileId: file.fileId,
+                createdAt: new Date(file.createdAt),
+                updatedAt: new Date(file.updatedAt),
+                creationTime: new Date(file.creationTime ?? file.createdAt),
+                modificationTime: new Date(file.modificationTime ?? file.updatedAt),
+            })));
+            return files.concat(await this.getAllSubfiles(currentWorkspace, folderUuid, offset + files.length));
         }
         else {
             return files;
         }
     };
-    moveFolder = (uuid, payload) => {
+    moveFolder = async (uuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.moveFolderByUuid(uuid, payload);
+        const folderMeta = await storageClient.moveFolderByUuid(uuid, payload);
+        const folderItem = drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate([folderItem]);
+        return folderMeta;
     };
-    createFolder(payload) {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.createFolderByUuid(payload);
-    }
-    renameFolder = (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.updateFolderNameWithUUID(payload);
+    createFolder = async (payload) => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        if (currentWorkspace) {
+            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+            return workspaceClient.createFolder({
+                workspaceId: currentWorkspace.workspaceCredentials.id,
+                parentFolderUuid: payload.parentFolderUuid,
+                plainName: payload.plainName,
+            });
+        }
+        else {
+            const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+            return storageClient.createFolderByUuid(payload);
+        }
     };
-    getFolderMetadataByPath = async (path) => {
+    renameFolder = async (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const folderMeta = await storageClient.getFolderByPath(encodeURIComponent(path));
-        return drive_utils_1.DriveUtils.driveFolderMetaToItem({
-            ...folderMeta,
-            createdAt: folderMeta.createdAt ?? folderMeta.created_at,
-            updatedAt: folderMeta.updatedAt ?? folderMeta.updated_at,
-            plainName: folderMeta.plainName ?? folderMeta.plain_name,
-            parentId: folderMeta.parentId ?? folderMeta.parent_id,
-            parentUuid: folderMeta.parentUuid ?? folderMeta.parent_uuid,
+        await storageClient.updateFolderNameWithUUID(payload);
+        await drive_folder_repository_1.FolderRepository.instance.updateByUuid(payload.folderUuid, { name: payload.name });
+    };
+    getByParentUuidAndName = async (parentUuid, name) => {
+        const subFolders = await this.getFolderSubfolders(parentUuid);
+        const folderMeta = subFolders.find((folder) => folder.plainName === name || folder.name === name);
+        if (folderMeta?.status !== types_1.FileStatus.EXISTS) {
+            throw new errors_utils_1.NotFoundError('Folder not found');
+        }
+        return {
+            itemType: 'folder',
+            name: folderMeta.plainName,
+            uuid: folderMeta.uuid,
+            parentUuid: folderMeta.parentUuid,
+            status: types_1.FileStatus.EXISTS,
+            createdAt: new Date(folderMeta.createdAt),
+            updatedAt: new Date(folderMeta.updatedAt),
+            creationTime: new Date(folderMeta.creationTime),
+            modificationTime: new Date(folderMeta.modificationTime),
+            bucket: folderMeta.bucket,
+        };
+    };
+    getByPath = async (path, parentUuid) => {
+        const onFound = async (uuid) => {
+            const folder = await this.getFolderMetaByUuid(uuid);
+            return folder;
+        };
+        const folder = await database_utils_1.DatabaseUtils.getFolderByPathGeneric({
+            path,
+            parentUuid,
+            onFound,
+            getByParentAndName: this.getByParentUuidAndName.bind(this),
         });
+        if (!folder) {
+            throw new errors_utils_1.NotFoundError('Folder not found');
+        }
+        return folder;
+    };
+    getFolderMetadataByPath = async (path) => {
+        const rootFolderUuid = await auth_service_1.AuthService.instance.getCurrentRootFolder();
+        const localFolderDB = await drive_folder_repository_1.FolderRepository.instance.getByPath(path, rootFolderUuid);
+        if (localFolderDB) {
+            try {
+                const folder = await this.getFolderMetaByUuid(localFolderDB.uuid);
+                if (folder) {
+                    return folder;
+                }
+            }
+            catch {
+                logger_utils_1.logger.error('Folder not found when getting folder by path on local DB', { path, rootFolderUuid });
+            }
+        }
+        return this.getByPath(path, rootFolderUuid);
     };
 }
 exports.DriveFolderService = DriveFolderService;

package/dist/services/drive/trash.service.d.ts

@@ -2,6 +2,9 @@ import { StorageTypes } from '@internxt/sdk/dist/drive';
 export declare class TrashService {
     static readonly instance: TrashService;
     trashItems: (payload: StorageTypes.AddItemsToTrashPayload) => Promise<void>;
+    deleteItemPermanently: (itemType: "file" | "folder", id: string) => Promise<void> | Promise<{
+        deleted: boolean;
+    }>;
     deleteFile: (fileId: string) => Promise<{
         deleted: boolean;
     }>;

package/dist/services/drive/trash.service.js

@@ -2,12 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrashService = void 0;
 const sdk_manager_service_1 = require("../sdk-manager.service");
+const auth_service_1 = require("../auth.service");
 class TrashService {
     static instance = new TrashService();
     trashItems = (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.addItemsToTrash(payload);
     };
+    deleteItemPermanently = (itemType, id) => {
+        if (itemType === 'file') {
+            return this.deleteFile(id);
+        }
+        else {
+            return this.deleteFolder(id);
+        }
+    };
     deleteFile = (fileId) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.deleteFileByUuid(fileId);
@@ -16,34 +25,61 @@ class TrashService {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.deleteFolderByUuid(folderId);
     };
-    clearTrash = () => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getTrash();
-        return storageClient.clearTrash();
+    clearTrash = async () => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        const currentWorkspaceCreds = currentWorkspace?.workspaceCredentials;
+        if (currentWorkspaceCreds) {
+            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+            return workspaceClient.emptyPersonalTrash(currentWorkspaceCreds.id);
+        }
+        else {
+            const trashClient = sdk_manager_service_1.SdkManager.instance.getTrash();
+            return trashClient.clearTrash();
+        }
     };
     getTrashFolderContent = async () => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getTrash();
-        const folders = await this.getAllTrashSubfolders(storageClient, 0);
-        const files = await this.getAllTrashSubfiles(storageClient, 0);
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        const currentWorkspaceCreds = currentWorkspace?.workspaceCredentials;
+        const folders = await this.getAllTrashSubfolders(currentWorkspaceCreds, 0);
+        const files = await this.getAllTrashSubfiles(currentWorkspaceCreds, 0);
         return { folders, files };
     };
-    getAllTrashSubfolders = async (storageClient, offset) => {
-        const folderContentPromise = storageClient.getTrashedFilesPaginated(50, offset, 'folders', true);
-        const { result: folders } = (await folderContentPromise);
+    getAllTrashSubfolders = async (currentWorkspace, offset) => {
+        let folders;
+        if (currentWorkspace) {
+            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+            const promise = workspaceClient.getPersonalTrash(currentWorkspace.id, 'folder', offset, 50);
+            folders = (await promise).result;
+        }
+        else {
+            const trashClient = sdk_manager_service_1.SdkManager.instance.getTrash();
+            const promise = trashClient.getTrashedFilesPaginated(50, offset, 'folders', true);
+            folders = (await promise).result;
+        }
         if (folders.length > 0) {
-            return folders.concat(await this.getAllTrashSubfolders(storageClient, offset + folders.length));
+            return folders.concat(await this.getAllTrashSubfolders(currentWorkspace, offset + folders.length));
         }
         else {
             return folders;
         }
     };
-    getAllTrashSubfiles = async (storageClient, offset) => {
-        const folderContentPromise = storageClient.getTrashedFilesPaginated(50, offset, 'files', true);
-        const { result: folders } = (await folderContentPromise);
-        if (folders.length > 0) {
-            return folders.concat(await this.getAllTrashSubfiles(storageClient, offset + folders.length));
+    getAllTrashSubfiles = async (currentWorkspace, offset) => {
+        let files;
+        if (currentWorkspace) {
+            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+            const promise = workspaceClient.getPersonalTrash(currentWorkspace.id, 'file', offset, 50);
+            files = (await promise).result;
         }
         else {
-            return folders;
+            const trashClient = sdk_manager_service_1.SdkManager.instance.getTrash();
+            const promise = trashClient.getTrashedFilesPaginated(50, offset, 'files', true);
+            files = (await promise).result;
+        }
+        if (files.length > 0) {
+            return files.concat(await this.getAllTrashSubfiles(currentWorkspace, offset + files.length));
+        }
+        else {
+            return files;
         }
     };
 }

package/dist/services/drive/workspace.service.d.ts

@@ -0,0 +1,7 @@
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
+import { LoginCredentials, WorkspaceCredentialsDetails } from '../../types/command.types';
+export declare class WorkspaceService {
+    static readonly instance: WorkspaceService;
+    getAvailableWorkspaces: (user: LoginCredentials["user"]) => Promise<WorkspaceData[]>;
+    getWorkspaceCredentials: (workspaceId: string) => Promise<WorkspaceCredentialsDetails>;
+}

package/dist/services/drive/workspace.service.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceService = void 0;
+const sdk_manager_service_1 = require("../sdk-manager.service");
+const crypto_service_1 = require("../crypto.service");
+class WorkspaceService {
+    static instance = new WorkspaceService();
+    getAvailableWorkspaces = async (user) => {
+        const workspacesClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+        const workspaces = await workspacesClient.getWorkspaces();
+        const decryptedMnemonicWorkspaces = await crypto_service_1.CryptoService.instance.decryptWorkspacesMnemonic(workspaces.availableWorkspaces, user);
+        return decryptedMnemonicWorkspaces;
+    };
+    getWorkspaceCredentials = async (workspaceId) => {
+        const workspacesClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+        const workspaceCredentialsRaw = await workspacesClient.getWorkspaceCredentials(workspaceId);
+        const workspaceCredentials = {
+            id: workspaceCredentialsRaw.workspaceId,
+            bucket: workspaceCredentialsRaw.bucket,
+            workspaceUserId: workspaceCredentialsRaw.workspaceUserId,
+            credentials: {
+                user: workspaceCredentialsRaw.credentials.networkUser,
+                pass: workspaceCredentialsRaw.credentials.networkPass,
+            },
+            token: workspaceCredentialsRaw.tokenHeader,
+        };
+        return workspaceCredentials;
+    };
+}
+exports.WorkspaceService = WorkspaceService;

package/dist/services/keys.service.d.ts

@@ -8,4 +8,11 @@ export declare class KeysService {
         publicKeyArmored: string;
         revocationCertificate: string;
     }>;
+    hybridDecryptMessageWithPrivateKey: ({ encryptedMessageInBase64, privateKeyInBase64, privateKyberKeyInBase64, }: {
+        encryptedMessageInBase64: string;
+        privateKeyInBase64: string;
+        privateKyberKeyInBase64?: string;
+    }) => Promise<string>;
+    private readonly decryptMessageWithPrivateKey;
+    private readonly comparePrivateKeyCiphertextIDs;
 }

package/dist/services/keys.service.js

@@ -32,11 +32,16 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeysService = void 0;
 const lib_1 = require("@internxt/lib");
 const openpgp = __importStar(require("openpgp"));
 const crypto_utils_1 = require("../utils/crypto.utils");
+const pqc_kem_kyber512_node_1 = __importDefault(require("@dashlane/pqc-kem-kyber512-node"));
+const WORDS_HYBRID_MODE_IN_BASE64 = 'SHlicmlkTW9kZQ==';
 class KeysService {
     static instance = new KeysService();
     encryptPrivateKey = (privateKey, password) => {
@@ -57,5 +62,55 @@ class KeysService {
             revocationCertificate: Buffer.from(revocationCertificate).toString('base64'),
         };
     };
+    hybridDecryptMessageWithPrivateKey = async ({ encryptedMessageInBase64, privateKeyInBase64, privateKyberKeyInBase64, }) => {
+        let eccCiphertextStr = encryptedMessageInBase64;
+        let kyberSecret;
+        const ciphertexts = encryptedMessageInBase64.split('$');
+        const prefix = ciphertexts[0];
+        const isHybridMode = prefix === WORDS_HYBRID_MODE_IN_BASE64;
+        if (isHybridMode) {
+            if (!privateKyberKeyInBase64) {
+                throw new Error('Attempted to decrypt hybrid ciphertex without Kyber key');
+            }
+            const kem = await (0, pqc_kem_kyber512_node_1.default)();
+            const kyberCiphertextBase64 = ciphertexts[1];
+            eccCiphertextStr = ciphertexts[2];
+            const privateKyberKey = Buffer.from(privateKyberKeyInBase64, 'base64');
+            const kyberCiphertext = Buffer.from(kyberCiphertextBase64, 'base64');
+            const decapsulate = await kem.decapsulate(new Uint8Array(kyberCiphertext), new Uint8Array(privateKyberKey));
+            kyberSecret = decapsulate.sharedSecret;
+        }
+        const decryptedMessage = await this.decryptMessageWithPrivateKey({
+            encryptedMessage: atob(eccCiphertextStr),
+            privateKeyInBase64,
+        });
+        if (isHybridMode && kyberSecret) {
+            const bits = decryptedMessage.length * 4;
+            const secretHex = await crypto_utils_1.CryptoUtils.extendSecret(kyberSecret, bits);
+            const xored = crypto_utils_1.CryptoUtils.XORhex(decryptedMessage, secretHex);
+            return Buffer.from(xored, 'hex').toString('utf8');
+        }
+        return decryptedMessage;
+    };
+    decryptMessageWithPrivateKey = async ({ encryptedMessage, privateKeyInBase64, }) => {
+        const privateKeyArmored = Buffer.from(privateKeyInBase64, 'base64').toString();
+        const privateKey = await openpgp.readPrivateKey({ armoredKey: privateKeyArmored });
+        const message = await openpgp.readMessage({
+            armoredMessage: encryptedMessage,
+        });
+        if (!this.comparePrivateKeyCiphertextIDs(privateKey, message)) {
+            throw new Error('The key does not correspond to the ciphertext');
+        }
+        const { data: decryptedMessage } = await openpgp.decrypt({
+            message,
+            decryptionKeys: privateKey,
+        });
+        return decryptedMessage.toString();
+    };
+    comparePrivateKeyCiphertextIDs = (privateKey, encryptedMessage) => {
+        const messageKeyID = encryptedMessage.getEncryptionKeyIDs()[0].toHex();
+        const privateKeyID = privateKey.getSubkeys()[0].getKeyID().toHex();
+        return messageKeyID === privateKeyID;
+    };
 }
 exports.KeysService = KeysService;

package/dist/services/local-filesystem/local-filesystem.service.d.ts

@@ -1,6 +1,6 @@
 import { FileSystemNode, ScanResult } from './local-filesystem.types';
 export declare class LocalFilesystemService {
     static readonly instance: LocalFilesystemService;
-    scanLocalDirectory(path: string): Promise<ScanResult>;
-    scanRecursive(currentPath: string, parentPath: string, folders: FileSystemNode[], files: FileSystemNode[]): Promise<number>;
+    scanLocalDirectory: (path: string) => Promise<ScanResult>;
+    scanRecursive: (currentPath: string, parentPath: string, folders: FileSystemNode[], files: FileSystemNode[]) => Promise<number>;
 }

package/dist/services/local-filesystem/local-filesystem.service.js

@@ -6,7 +6,7 @@ const node_path_1 = require("node:path");
 const logger_utils_1 = require("../../utils/logger.utils");
 class LocalFilesystemService {
     static instance = new LocalFilesystemService();
-    async scanLocalDirectory(path) {
+    scanLocalDirectory = async (path) => {
         const folders = [];
         const files = [];
         const parentPath = (0, node_path_1.dirname)(path);
@@ -17,8 +17,8 @@ class LocalFilesystemService {
             totalItems: folders.length + files.length,
             totalBytes,
         };
-    }
-    async scanRecursive(currentPath, parentPath, folders, files) {
+    };
+    scanRecursive = async (currentPath, parentPath, folders, files) => {
         try {
             const stats = await node_fs_1.promises.stat(currentPath);
             const relativePath = (0, node_path_1.relative)(parentPath, currentPath);
@@ -52,6 +52,6 @@ class LocalFilesystemService {
             logger_utils_1.logger.warn(`Error scanning path ${currentPath}: ${error.message} - skipping...`);
             return 0;
         }
-    }
+    };
 }
 exports.LocalFilesystemService = LocalFilesystemService;

package/dist/services/network/download.service.d.ts

@@ -1,9 +1,9 @@
 import { DownloadProgressCallback } from '../../types/network.types';
 export declare class DownloadService {
     static readonly instance: DownloadService;
-    downloadFile(url: string, options: {
+    downloadFile: (url: string, options: {
         progressCallback?: DownloadProgressCallback;
         abortController?: AbortController;
         rangeHeader?: string;
-    }): Promise<ReadableStream<Uint8Array>>;
+    }) => Promise<ReadableStream<Uint8Array>>;
 }

package/dist/services/network/download.service.js

@@ -7,7 +7,7 @@ exports.DownloadService = void 0;
 const axios_1 = __importDefault(require("axios"));
 class DownloadService {
     static instance = new DownloadService();
-    async downloadFile(url, options) {
+    downloadFile = async (url, options) => {
         const response = await axios_1.default.get(url, {
             responseType: 'stream',
             onDownloadProgress(progressEvent) {
@@ -30,6 +30,6 @@ class DownloadService {
             },
         });
         return readable;
-    }
+    };
 }
 exports.DownloadService = DownloadService;

package/dist/services/network/network-facade.service.d.ts

@@ -2,17 +2,13 @@ import { Network } from '@internxt/sdk';
 import { Environment } from '@internxt/inxt-js';
 import { Readable } from 'node:stream';
 import { DownloadOptions } from '../../types/network.types';
-import { CryptoService } from '../crypto.service';
-import { DownloadService } from './download.service';
 import { RangeOptions } from '../../utils/network.utils';
 import { ActionState } from '@internxt/inxt-js/build/api';
 export declare class NetworkFacade {
     private readonly network;
     private readonly environment;
-    private readonly downloadService;
-    private readonly cryptoService;
     private readonly cryptoLib;
-    constructor(network: Network.Network, environment: Environment, downloadService: DownloadService, cryptoService: CryptoService);
-    downloadToStream(bucketId: string, mnemonic: string, fileId: string, size: number, to: WritableStream, rangeOptions?: RangeOptions, options?: DownloadOptions): Promise<[Promise<void>, AbortController]>;
-    uploadFile(from: Readable, size: number, bucketId: string, finishedCallback: (err: Error | null, res: string | null) => void, progressCallback: (progress: number) => void): ActionState;
+    constructor(network: Network.Network, environment: Environment);
+    downloadToStream: (bucketId: string, mnemonic: string, fileId: string, size: number, to: WritableStream, rangeOptions?: RangeOptions, options?: DownloadOptions) => Promise<[Promise<void>, AbortController]>;
+    uploadFile: (from: Readable, size: number, bucketId: string, finishedCallback: (err: Error | null, res: string | null) => void, progressCallback: (progress: number) => void) => ActionState;
 }

package/dist/services/network/network-facade.service.js

@@ -38,19 +38,17 @@ const sdk_1 = require("@internxt/sdk");
 const NetworkDownload = __importStar(require("@internxt/sdk/dist/network/download"));
 const inxt_js_1 = require("@internxt/inxt-js");
 const node_crypto_1 = require("node:crypto");
+const crypto_service_1 = require("../crypto.service");
+const download_service_1 = require("./download.service");
 const validation_service_1 = require("../validation.service");
 const TWENTY_GIGABYTES = 20 * 1024 * 1024 * 1024;
 class NetworkFacade {
     network;
     environment;
-    downloadService;
-    cryptoService;
     cryptoLib;
-    constructor(network, environment, downloadService, cryptoService) {
+    constructor(network, environment) {
         this.network = network;
         this.environment = environment;
-        this.downloadService = downloadService;
-        this.cryptoService = cryptoService;
         this.cryptoLib = {
             algorithm: sdk_1.Network.ALGORITHMS.AES256CTR,
             validateMnemonic: (mnemonic) => {
@@ -62,7 +60,7 @@ class NetworkFacade {
             randomBytes: node_crypto_1.randomBytes,
         };
     }
-    async downloadToStream(bucketId, mnemonic, fileId, size, to, rangeOptions, options) {
+    downloadToStream = async (bucketId, mnemonic, fileId, size, to, rangeOptions, options) => {
         const encryptedContentStreams = [];
         let fileStream;
         const abortable = options?.abortController ?? new AbortController();
@@ -77,7 +75,7 @@ class NetworkFacade {
             if (rangeOptions) {
                 startOffsetByte = rangeOptions.parsed.start;
             }
-            fileStream = this.cryptoService.decryptStream(encryptedContentStreams, Buffer.from(key), Buffer.from(iv), startOffsetByte);
+            fileStream = crypto_service_1.CryptoService.instance.decryptStream(encryptedContentStreams, Buffer.from(key), Buffer.from(iv), startOffsetByte);
             await fileStream.pipeTo(to);
         };
         const downloadFile = async (downloadables) => {
@@ -88,7 +86,7 @@ class NetworkFacade {
                 if (abortable.signal.aborted) {
                     throw new Error('Download aborted');
                 }
-                const encryptedContentStream = await this.downloadService.downloadFile(downloadable.url, {
+                const encryptedContentStream = await download_service_1.DownloadService.instance.downloadFile(downloadable.url, {
                     progressCallback: onProgress,
                     abortController: options?.abortController,
                     rangeHeader: rangeOptions?.range,
@@ -100,8 +98,8 @@ class NetworkFacade {
             await NetworkDownload.downloadFile(fileId, bucketId, mnemonic, this.network, this.cryptoLib, Buffer.from, downloadFile, decryptFile);
         };
         return [downloadOperation(), abortable];
-    }
-    uploadFile(from, size, bucketId, finishedCallback, progressCallback) {
+    };
+    uploadFile = (from, size, bucketId, finishedCallback, progressCallback) => {
         if (size > TWENTY_GIGABYTES) {
             throw new Error('File is too big (more than 20 GB)');
         }
@@ -123,6 +121,6 @@ class NetworkFacade {
                 progressCallback,
             });
         }
-    }
+    };
 }
 exports.NetworkFacade = NetworkFacade;

package/dist/services/network/upload/upload-facade.service.d.ts

@@ -1,7 +1,7 @@
 import { UploadFolderParams } from './upload.types';
 export declare class UploadFacade {
     static readonly instance: UploadFacade;
-    uploadFolder({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, onProgress }: UploadFolderParams): Promise<{
+    uploadFolder: ({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, debugMode, onProgress, reporter, }: UploadFolderParams) => Promise<{
         totalBytes: number;
         rootFolderId: string;
         uploadTimeMs: number;