@internxt/cli 1.6.0 → 1.6.2

package/dist/services/config.service.js

@@ -4,23 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigService = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const os_1 = __importDefault(require("os"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const crypto_service_1 = require("./crypto.service");
+const errors_utils_1 = require("../utils/errors.utils");
+const configs_1 = require("../constants/configs");
 class ConfigService {
-    static INTERNXT_CLI_DATA_DIR = node_path_1.default.join(os_1.default.homedir(), '.internxt-cli');
-    static INTERNXT_CLI_LOGS_DIR = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'logs');
-    static INTERNXT_TMP_DIR = os_1.default.tmpdir();
-    static CREDENTIALS_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, '.inxtcli');
-    static DRIVE_SQLITE_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
-    static WEBDAV_SSL_CERTS_DIR = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'certs');
-    static WEBDAV_CONFIGS_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
-    static WEBDAV_DEFAULT_HOST = '127.0.0.1';
-    static WEBDAV_DEFAULT_PORT = '3005';
-    static WEBDAV_DEFAULT_PROTOCOL = 'https';
-    static WEBDAV_DEFAULT_TIMEOUT = 0;
-    static WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
     static instance = new ConfigService();
     get = (key) => {
         const value = process.env[key];
@@ -32,17 +20,24 @@ class ConfigService {
         await this.ensureInternxtCliDataDirExists();
         const credentialsString = JSON.stringify(loginCredentials);
         const encryptedCredentials = crypto_service_1.CryptoService.instance.encryptText(credentialsString);
-        await promises_1.default.writeFile(ConfigService.CREDENTIALS_FILE, encryptedCredentials, 'utf8');
+        await promises_1.default.writeFile(configs_1.CREDENTIALS_FILE, encryptedCredentials, 'utf8');
     };
     clearUser = async () => {
-        const stat = await promises_1.default.stat(ConfigService.CREDENTIALS_FILE);
-        if (stat.size === 0)
-            throw new Error('Credentials file is already empty');
-        return promises_1.default.writeFile(ConfigService.CREDENTIALS_FILE, '', 'utf8');
+        try {
+            const stat = await promises_1.default.stat(configs_1.CREDENTIALS_FILE);
+            if (stat.size === 0)
+                return;
+            await promises_1.default.writeFile(configs_1.CREDENTIALS_FILE, '', 'utf8');
+        }
+        catch (error) {
+            if (!(0, errors_utils_1.isFileNotFoundError)(error)) {
+                throw error;
+            }
+        }
     };
     readUser = async () => {
         try {
-            const encryptedCredentials = await promises_1.default.readFile(ConfigService.CREDENTIALS_FILE, 'utf8');
+            const encryptedCredentials = await promises_1.default.readFile(configs_1.CREDENTIALS_FILE, 'utf8');
             const credentialsString = crypto_service_1.CryptoService.instance.decryptText(encryptedCredentials);
             const loginCredentials = JSON.parse(credentialsString);
             return loginCredentials;
@@ -54,52 +49,52 @@ class ConfigService {
     saveWebdavConfig = async (webdavConfig) => {
         await this.ensureInternxtCliDataDirExists();
         const configs = JSON.stringify(webdavConfig);
-        await promises_1.default.writeFile(ConfigService.WEBDAV_CONFIGS_FILE, configs, 'utf8');
+        await promises_1.default.writeFile(configs_1.WEBDAV_CONFIGS_FILE, configs, 'utf8');
     };
     readWebdavConfig = async () => {
         try {
-            const configsData = await promises_1.default.readFile(ConfigService.WEBDAV_CONFIGS_FILE, 'utf8');
+            const configsData = await promises_1.default.readFile(configs_1.WEBDAV_CONFIGS_FILE, 'utf8');
             const configs = JSON.parse(configsData);
             return {
-                host: configs?.host ?? ConfigService.WEBDAV_DEFAULT_HOST,
-                port: configs?.port ?? ConfigService.WEBDAV_DEFAULT_PORT,
-                protocol: configs?.protocol ?? ConfigService.WEBDAV_DEFAULT_PROTOCOL,
-                timeoutMinutes: configs?.timeoutMinutes ?? ConfigService.WEBDAV_DEFAULT_TIMEOUT,
-                createFullPath: configs?.createFullPath ?? ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
+                host: configs?.host ?? configs_1.WEBDAV_DEFAULT_HOST,
+                port: configs?.port ?? configs_1.WEBDAV_DEFAULT_PORT,
+                protocol: configs?.protocol ?? configs_1.WEBDAV_DEFAULT_PROTOCOL,
+                timeoutMinutes: configs?.timeoutMinutes ?? configs_1.WEBDAV_DEFAULT_TIMEOUT,
+                createFullPath: configs?.createFullPath ?? configs_1.WEBDAV_DEFAULT_CREATE_FULL_PATH,
             };
         }
         catch {
             return {
-                host: ConfigService.WEBDAV_DEFAULT_HOST,
-                port: ConfigService.WEBDAV_DEFAULT_PORT,
-                protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
-                timeoutMinutes: ConfigService.WEBDAV_DEFAULT_TIMEOUT,
-                createFullPath: ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
+                host: configs_1.WEBDAV_DEFAULT_HOST,
+                port: configs_1.WEBDAV_DEFAULT_PORT,
+                protocol: configs_1.WEBDAV_DEFAULT_PROTOCOL,
+                timeoutMinutes: configs_1.WEBDAV_DEFAULT_TIMEOUT,
+                createFullPath: configs_1.WEBDAV_DEFAULT_CREATE_FULL_PATH,
             };
         }
     };
     ensureInternxtCliDataDirExists = async () => {
         try {
-            await promises_1.default.access(ConfigService.INTERNXT_CLI_DATA_DIR);
+            await promises_1.default.access(configs_1.INTERNXT_CLI_DATA_DIR);
         }
         catch {
-            await promises_1.default.mkdir(ConfigService.INTERNXT_CLI_DATA_DIR);
+            await promises_1.default.mkdir(configs_1.INTERNXT_CLI_DATA_DIR);
         }
     };
     ensureWebdavCertsDirExists = async () => {
         try {
-            await promises_1.default.access(ConfigService.WEBDAV_SSL_CERTS_DIR);
+            await promises_1.default.access(configs_1.WEBDAV_SSL_CERTS_DIR);
         }
         catch {
-            await promises_1.default.mkdir(ConfigService.WEBDAV_SSL_CERTS_DIR);
+            await promises_1.default.mkdir(configs_1.WEBDAV_SSL_CERTS_DIR);
         }
     };
     ensureInternxtLogsDirExists = async () => {
         try {
-            await promises_1.default.access(ConfigService.INTERNXT_CLI_LOGS_DIR);
+            await promises_1.default.access(configs_1.INTERNXT_CLI_LOGS_DIR);
         }
         catch {
-            await promises_1.default.mkdir(ConfigService.INTERNXT_CLI_LOGS_DIR);
+            await promises_1.default.mkdir(configs_1.INTERNXT_CLI_LOGS_DIR);
         }
     };
 }

package/dist/services/drive/drive-folder.service.d.ts

@@ -30,7 +30,7 @@ export declare class DriveFolderService {
         files: {
             id: number;
             uuid: string;
-            fileId: string;
+            fileId: string | null;
             name: string;
             type: string;
             size: string;

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

@@ -32,7 +32,7 @@ export declare class TrashService {
         files: {
             id: number;
             uuid: string;
-            fileId: string;
+            fileId: string | null;
             name: string;
             type: string;
             size: string;

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

@@ -0,0 +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>;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFilesystemService = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const logger_utils_1 = require("../../utils/logger.utils");
+class LocalFilesystemService {
+    static instance = new LocalFilesystemService();
+    async scanLocalDirectory(path) {
+        const folders = [];
+        const files = [];
+        const parentPath = (0, node_path_1.dirname)(path);
+        const totalBytes = await this.scanRecursive(path, parentPath, folders, files);
+        return {
+            folders,
+            files,
+            totalItems: folders.length + files.length,
+            totalBytes,
+        };
+    }
+    async scanRecursive(currentPath, parentPath, folders, files) {
+        try {
+            const stats = await node_fs_1.promises.stat(currentPath);
+            const relativePath = (0, node_path_1.relative)(parentPath, currentPath);
+            if (stats.isFile() && stats.size > 0) {
+                const fileInfo = (0, node_path_1.parse)(currentPath);
+                files.push({
+                    type: 'file',
+                    name: fileInfo.name,
+                    absolutePath: currentPath,
+                    relativePath,
+                    size: stats.size,
+                });
+                return stats.size;
+            }
+            if (stats.isDirectory()) {
+                folders.push({
+                    type: 'folder',
+                    name: (0, node_path_1.basename)(currentPath),
+                    absolutePath: currentPath,
+                    relativePath,
+                    size: 0,
+                });
+                const entries = await node_fs_1.promises.readdir(currentPath, { withFileTypes: true });
+                const validEntries = entries.filter((e) => !e.isSymbolicLink());
+                const bytesArray = await Promise.all(validEntries.map((e) => this.scanRecursive((0, node_path_1.join)(currentPath, e.name), parentPath, folders, files)));
+                return bytesArray.reduce((sum, bytes) => sum + bytes, 0);
+            }
+            return 0;
+        }
+        catch (error) {
+            logger_utils_1.logger.warn(`Error scanning path ${currentPath}: ${error.message} - skipping...`);
+            return 0;
+        }
+    }
+}
+exports.LocalFilesystemService = LocalFilesystemService;

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

@@ -0,0 +1,13 @@
+export interface FileSystemNode {
+    type: 'file' | 'folder';
+    name: string;
+    size: number;
+    absolutePath: string;
+    relativePath: string;
+}
+export interface ScanResult {
+    folders: FileSystemNode[];
+    files: FileSystemNode[];
+    totalItems: number;
+    totalBytes: number;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFacade = void 0;
+const node_path_1 = require("node:path");
+const cli_utils_1 = require("../../../utils/cli.utils");
+const logger_utils_1 = require("../../../utils/logger.utils");
+const local_filesystem_service_1 = require("../../local-filesystem/local-filesystem.service");
+const upload_folder_service_1 = require("./upload-folder.service");
+const upload_file_service_1 = require("./upload-file.service");
+const async_utils_1 = require("../../../utils/async.utils");
+class UploadFacade {
+    static instance = new UploadFacade();
+    async uploadFolder({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, onProgress }) {
+        const timer = cli_utils_1.CLIUtils.timer();
+        const network = cli_utils_1.CLIUtils.prepareNetwork({ jsonFlag, loginUserDetails });
+        const scanResult = await local_filesystem_service_1.LocalFilesystemService.instance.scanLocalDirectory(localPath);
+        logger_utils_1.logger.info(`Scanned folder ${localPath}: found ${scanResult.totalItems} items, total size ${scanResult.totalBytes} bytes.`);
+        const currentProgress = { itemsUploaded: 0, bytesUploaded: 0 };
+        const emitProgress = () => {
+            const itemProgress = currentProgress.itemsUploaded / scanResult.totalItems;
+            const sizeProgress = currentProgress.bytesUploaded / scanResult.totalBytes;
+            const percentage = Math.floor((itemProgress * 0.5 + sizeProgress * 0.5) * 100);
+            onProgress({ percentage });
+        };
+        const folderMap = await upload_folder_service_1.UploadFolderService.instance.createFolders({
+            foldersToCreate: scanResult.folders,
+            destinationFolderUuid,
+            currentProgress,
+            emitProgress,
+        });
+        if (folderMap.size === 0) {
+            throw new Error('Failed to create folders, cannot upload files');
+        }
+        await async_utils_1.AsyncUtils.sleep(500);
+        const totalBytes = await upload_file_service_1.UploadFileService.instance.uploadFilesConcurrently({
+            network,
+            filesToUpload: scanResult.files,
+            folderMap,
+            bucket: loginUserDetails.bucket,
+            destinationFolderUuid,
+            currentProgress,
+            emitProgress,
+        });
+        const rootFolderName = (0, node_path_1.basename)(localPath);
+        const rootFolderId = folderMap.get(rootFolderName) ?? '';
+        return {
+            totalBytes,
+            rootFolderId,
+            uploadTimeMs: timer.stop(),
+        };
+    }
+}
+exports.UploadFacade = UploadFacade;

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

@@ -0,0 +1,8 @@
+import { UploadFilesConcurrentlyParams, UploadFileWithRetryParams } from './upload.types';
+import { DriveFileItem } from '../../../types/drive.types';
+export declare class UploadFileService {
+    static readonly instance: UploadFileService;
+    uploadFilesConcurrently({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }: UploadFilesConcurrentlyParams): Promise<number>;
+    uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }: UploadFileWithRetryParams): Promise<DriveFileItem | null>;
+    private concurrencyArray;
+}

package/dist/services/network/upload/upload-file.service.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFileService = void 0;
+const logger_utils_1 = require("../../../utils/logger.utils");
+const upload_types_1 = require("./upload.types");
+const drive_file_service_1 = require("../../drive/drive-file.service");
+const node_path_1 = require("node:path");
+const errors_utils_1 = require("../../../utils/errors.utils");
+const promises_1 = require("node:fs/promises");
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
+const thumbnail_utils_1 = require("../../../utils/thumbnail.utils");
+const cli_utils_1 = require("../../../utils/cli.utils");
+class UploadFileService {
+    static instance = new UploadFileService();
+    async uploadFilesConcurrently({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }) {
+        let bytesUploaded = 0;
+        const concurrentFiles = this.concurrencyArray(filesToUpload, upload_types_1.MAX_CONCURRENT_UPLOADS);
+        for (const fileArray of concurrentFiles) {
+            await Promise.allSettled(fileArray.map(async (file) => {
+                const parentPath = (0, node_path_1.dirname)(file.relativePath);
+                const parentFolderUuid = parentPath === '.' || parentPath === '' ? destinationFolderUuid : folderMap.get(parentPath);
+                if (!parentFolderUuid) {
+                    logger_utils_1.logger.warn(`Parent folder not found for ${file.relativePath}, skipping...`);
+                    return null;
+                }
+                const createdFileUuid = await this.uploadFileWithRetry({
+                    file,
+                    network,
+                    bucket,
+                    parentFolderUuid,
+                });
+                if (createdFileUuid) {
+                    bytesUploaded += file.size;
+                    currentProgress.bytesUploaded += file.size;
+                    currentProgress.itemsUploaded++;
+                }
+                emitProgress();
+            }));
+        }
+        return bytesUploaded;
+    }
+    async uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }) {
+        for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
+            try {
+                const stats = await (0, promises_1.stat)(file.absolutePath);
+                const fileSize = stats.size ?? 0;
+                const fileType = (0, node_path_1.extname)(file.absolutePath).replaceAll('.', '');
+                let fileId;
+                let thumbnailStream;
+                const timings = {
+                    networkUpload: 0,
+                    driveUpload: 0,
+                    thumbnailUpload: 0,
+                };
+                if (fileSize > 0) {
+                    const { fileStream, bufferStream } = (0, thumbnail_utils_1.createFileStreamWithBuffer)({
+                        path: file.absolutePath,
+                        fileType,
+                    });
+                    const uploadTimer = cli_utils_1.CLIUtils.timer();
+                    thumbnailStream = bufferStream;
+                    fileId = await new Promise((resolve, reject) => {
+                        network.uploadFile(fileStream, fileSize, bucket, (err, res) => {
+                            if (err) {
+                                return reject(err);
+                            }
+                            resolve(res);
+                        }, () => { });
+                    });
+                    timings.networkUpload = uploadTimer.stop();
+                }
+                const driveTimer = cli_utils_1.CLIUtils.timer();
+                const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
+                    plainName: file.name,
+                    type: fileType,
+                    size: fileSize,
+                    folderUuid: parentFolderUuid,
+                    fileId,
+                    bucket,
+                    encryptVersion: types_1.EncryptionVersion.Aes03,
+                    creationTime: stats.birthtime?.toISOString(),
+                    modificationTime: stats.mtime?.toISOString(),
+                });
+                timings.driveUpload = driveTimer.stop();
+                const thumbnailTimer = cli_utils_1.CLIUtils.timer();
+                if (thumbnailStream && fileSize > 0) {
+                    void (0, thumbnail_utils_1.tryUploadThumbnail)({
+                        bufferStream: thumbnailStream,
+                        fileType,
+                        userBucket: bucket,
+                        fileUuid: createdDriveFile.uuid,
+                        networkFacade: network,
+                    });
+                }
+                timings.thumbnailUpload = thumbnailTimer.stop();
+                const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
+                const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(stats.size, timings.networkUpload);
+                logger_utils_1.logger.info(`Uploaded '${file.name}' (${cli_utils_1.CLIUtils.formatBytesToString(stats.size)})`);
+                logger_utils_1.logger.info(`Timing breakdown:\n
+          Network upload: ${cli_utils_1.CLIUtils.formatDuration(timings.networkUpload)} (${throughputMBps.toFixed(2)} MB/s)\n
+          Drive upload: ${cli_utils_1.CLIUtils.formatDuration(timings.driveUpload)}\n
+          Thumbnail: ${cli_utils_1.CLIUtils.formatDuration(timings.thumbnailUpload)}\n
+          Total: ${cli_utils_1.CLIUtils.formatDuration(totalTime)}\n`);
+                return createdDriveFile;
+            }
+            catch (error) {
+                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
+                    const msg = `File ${file.name} already exists, skipping...`;
+                    logger_utils_1.logger.info(msg);
+                    return null;
+                }
+                if (attempt < upload_types_1.MAX_RETRIES) {
+                    const delay = upload_types_1.DELAYS_MS[attempt];
+                    const retryMsg = `Failed to upload file ${file.name}, retrying in ${delay}ms...`;
+                    logger_utils_1.logger.warn(`${retryMsg} (attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else {
+                    logger_utils_1.logger.error(`Failed to upload file ${file.name} after ${upload_types_1.MAX_RETRIES + 1} attempts`);
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    concurrencyArray(array, arraySize) {
+        const arrays = [];
+        for (let i = 0; i < array.length; i += arraySize) {
+            arrays.push(array.slice(i, i + arraySize));
+        }
+        return arrays;
+    }
+}
+exports.UploadFileService = UploadFileService;

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

@@ -0,0 +1,6 @@
+import { CreateFoldersParams, CreateFolderWithRetryParams } from './upload.types';
+export declare class UploadFolderService {
+    static readonly instance: UploadFolderService;
+    createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }: CreateFoldersParams): Promise<Map<string, string>>;
+    createFolderWithRetry({ folderName, parentFolderUuid }: CreateFolderWithRetryParams): Promise<string | null>;
+}

package/dist/services/network/upload/upload-folder.service.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFolderService = void 0;
+const node_path_1 = require("node:path");
+const errors_utils_1 = require("../../../utils/errors.utils");
+const logger_utils_1 = require("../../../utils/logger.utils");
+const drive_folder_service_1 = require("../../drive/drive-folder.service");
+const upload_types_1 = require("./upload.types");
+class UploadFolderService {
+    static instance = new UploadFolderService();
+    async createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }) {
+        const folderMap = new Map();
+        for (const folder of foldersToCreate) {
+            const parentPath = (0, node_path_1.dirname)(folder.relativePath);
+            const parentUuid = parentPath === '.' ? destinationFolderUuid : folderMap.get(parentPath);
+            if (!parentUuid) {
+                logger_utils_1.logger.warn(`Parent folder not found for ${folder.relativePath}, skipping...`);
+                continue;
+            }
+            const createdFolderUuid = await this.createFolderWithRetry({
+                folderName: folder.name,
+                parentFolderUuid: parentUuid,
+            });
+            if (createdFolderUuid) {
+                folderMap.set(folder.relativePath, createdFolderUuid);
+                currentProgress.itemsUploaded++;
+                emitProgress();
+            }
+        }
+        return folderMap;
+    }
+    async createFolderWithRetry({ folderName, parentFolderUuid }) {
+        for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
+            try {
+                const [createFolderPromise] = drive_folder_service_1.DriveFolderService.instance.createFolder({
+                    plainName: folderName,
+                    parentFolderUuid,
+                });
+                const createdFolder = await createFolderPromise;
+                return createdFolder.uuid;
+            }
+            catch (error) {
+                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
+                    logger_utils_1.logger.info(`Folder ${folderName} already exists, skipping...`);
+                    return null;
+                }
+                if (attempt < upload_types_1.MAX_RETRIES) {
+                    const delay = upload_types_1.DELAYS_MS[attempt];
+                    logger_utils_1.logger.warn(`Failed to create folder ${folderName},
+                retrying in ${delay}ms... (attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else {
+                    logger_utils_1.logger.error(`Failed to create folder ${folderName} after ${upload_types_1.MAX_RETRIES + 1} attempts`);
+                    throw error;
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.UploadFolderService = UploadFolderService;

package/dist/services/network/upload/upload.types.d.ts

@@ -0,0 +1,53 @@
+import { LoginUserDetails } from '../../../types/command.types';
+import { FileSystemNode } from '../../local-filesystem/local-filesystem.types';
+import { NetworkFacade } from '../network-facade.service';
+export interface UploadResult {
+    totalBytes: number;
+    rootFolderId: string;
+    uploadTimeMs: number;
+}
+export interface UploadFolderParams {
+    localPath: string;
+    destinationFolderUuid: string;
+    loginUserDetails: LoginUserDetails;
+    jsonFlag?: boolean;
+    onProgress: (progress: UploadProgress) => void;
+}
+export interface UploadProgress {
+    percentage: number;
+    currentFile?: string;
+}
+export interface CreateFoldersParams {
+    foldersToCreate: FileSystemNode[];
+    destinationFolderUuid: string;
+    currentProgress: {
+        itemsUploaded: number;
+        bytesUploaded: number;
+    };
+    emitProgress: () => void;
+}
+export interface CreateFolderWithRetryParams {
+    folderName: string;
+    parentFolderUuid: string;
+}
+export interface UploadFilesConcurrentlyParams {
+    network: NetworkFacade;
+    filesToUpload: FileSystemNode[];
+    folderMap: Map<string, string>;
+    bucket: string;
+    destinationFolderUuid: string;
+    currentProgress: {
+        itemsUploaded: number;
+        bytesUploaded: number;
+    };
+    emitProgress: () => void;
+}
+export interface UploadFileWithRetryParams {
+    file: FileSystemNode;
+    network: NetworkFacade;
+    bucket: string;
+    parentFolderUuid: string;
+}
+export declare const MAX_CONCURRENT_UPLOADS = 10;
+export declare const DELAYS_MS: number[];
+export declare const MAX_RETRIES = 2;

package/dist/services/network/upload/upload.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RETRIES = exports.DELAYS_MS = exports.MAX_CONCURRENT_UPLOADS = void 0;
+exports.MAX_CONCURRENT_UPLOADS = 10;
+exports.DELAYS_MS = [500, 1000, 2000];
+exports.MAX_RETRIES = 2;

package/dist/services/sdk-manager.service.d.ts

@@ -6,8 +6,8 @@ export declare class SdkManager {
     private static apiSecurity?;
     static readonly init: (apiSecurity: SdkManagerApiSecurity) => void;
     static readonly clean: () => void;
-    static readonly getApiSecurity: (config?: {
-        throwErrorOnMissingCredentials: boolean;
+    static readonly getApiSecurity: ({ throwErrorOnMissingCredentials }?: {
+        throwErrorOnMissingCredentials?: boolean | undefined;
     }) => SdkManagerApiSecurity;
     static readonly getAppDetails: () => AppDetails;
     getAuth(): Auth;

package/dist/services/sdk-manager.service.js

@@ -18,8 +18,8 @@ class SdkManager {
     static clean = () => {
         SdkManager.apiSecurity = undefined;
     };
-    static getApiSecurity = (config = { throwErrorOnMissingCredentials: true }) => {
-        if (!SdkManager.apiSecurity && config.throwErrorOnMissingCredentials)
+    static getApiSecurity = ({ throwErrorOnMissingCredentials = true } = {}) => {
+        if (!SdkManager.apiSecurity && throwErrorOnMissingCredentials)
             throw new Error('Api security properties not found in SdkManager');
         return SdkManager.apiSecurity;
     };

package/dist/services/thumbnail.service.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThumbnailService = void 0;
 const node_stream_1 = require("node:stream");
@@ -42,7 +9,7 @@ let sharpDependency = null;
 const getSharp = async () => {
     if (!sharpDependency) {
         try {
-            sharpDependency = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
+            sharpDependency = (await import('sharp')).default;
         }
         catch {
             return null;

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

@@ -9,6 +9,11 @@ export declare class ValidationService {
     validateStringIsNotEmpty: (str: string) => boolean;
     validateDirectoryExists: (path: string) => Promise<boolean>;
     validateFileExists: (path: string) => Promise<boolean>;
+    validateJwtAndCheckExpiration: (token?: string) => number | null;
+    checkTokenExpiration: (expirationTimestamp: number) => {
+        expired: boolean;
+        refreshRequired: boolean;
+    };
     validateTokenAndCheckExpiration: (token?: string) => {
         isValid: boolean;
         expiration: {