@internxt/cli 1.6.2 → 1.6.3

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

@@ -3,18 +3,21 @@ 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 }) {
+    uploadFolder = async ({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, debugMode, onProgress, reporter, }) => {
         const timer = cli_utils_1.CLIUtils.timer();
-        const network = cli_utils_1.CLIUtils.prepareNetwork({ jsonFlag, loginUserDetails });
+        cli_utils_1.CLIUtils.doing('Preparing Network', jsonFlag);
+        const { networkFacade, bucket } = await cli_utils_1.CLIUtils.prepareNetwork(loginUserDetails);
+        cli_utils_1.CLIUtils.done(jsonFlag);
         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.`);
+        if (debugMode) {
+            cli_utils_1.CLIUtils.success(reporter, `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;
@@ -27,19 +30,23 @@ class UploadFacade {
             destinationFolderUuid,
             currentProgress,
             emitProgress,
+            reporter,
+            debugMode,
         });
         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,
+            network: networkFacade,
             filesToUpload: scanResult.files,
             folderMap,
-            bucket: loginUserDetails.bucket,
+            bucket,
             destinationFolderUuid,
             currentProgress,
             emitProgress,
+            debugMode,
+            reporter,
         });
         const rootFolderName = (0, node_path_1.basename)(localPath);
         const rootFolderId = folderMap.get(rootFolderName) ?? '';
@@ -48,6 +55,6 @@ class UploadFacade {
             rootFolderId,
             uploadTimeMs: timer.stop(),
         };
-    }
+    };
 }
 exports.UploadFacade = UploadFacade;

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

@@ -2,7 +2,7 @@ import { UploadFilesConcurrentlyParams, UploadFileWithRetryParams } from './uplo
 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;
+    uploadFilesConcurrently: ({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }: UploadFilesConcurrentlyParams) => Promise<number>;
+    uploadFileWithRetry: ({ file, network, bucket, parentFolderUuid, debugMode, reporter, }: UploadFileWithRetryParams) => Promise<DriveFileItem | null>;
+    private readonly concurrencyArray;
 }

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

@@ -8,11 +8,11 @@ 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");
+const thumbnail_service_1 = require("../../thumbnail.service");
 class UploadFileService {
     static instance = new UploadFileService();
-    async uploadFilesConcurrently({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }) {
+    uploadFilesConcurrently = async ({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }) => {
         let bytesUploaded = 0;
         const concurrentFiles = this.concurrencyArray(filesToUpload, upload_types_1.MAX_CONCURRENT_UPLOADS);
         for (const fileArray of concurrentFiles) {
@@ -20,7 +20,9 @@ class UploadFileService {
                 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...`);
+                    if (debugMode) {
+                        cli_utils_1.CLIUtils.warning(reporter, `Parent folder not found for ${file.relativePath}, skipping...`);
+                    }
                     return null;
                 }
                 const createdFileUuid = await this.uploadFileWithRetry({
@@ -28,6 +30,8 @@ class UploadFileService {
                     network,
                     bucket,
                     parentFolderUuid,
+                    debugMode,
+                    reporter,
                 });
                 if (createdFileUuid) {
                     bytesUploaded += file.size;
@@ -38,8 +42,8 @@ class UploadFileService {
             }));
         }
         return bytesUploaded;
-    }
-    async uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }) {
+    };
+    uploadFileWithRetry = async ({ file, network, bucket, parentFolderUuid, debugMode, reporter, }) => {
         for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
             try {
                 const stats = await (0, promises_1.stat)(file.absolutePath);
@@ -53,7 +57,7 @@ class UploadFileService {
                     thumbnailUpload: 0,
                 };
                 if (fileSize > 0) {
-                    const { fileStream, bufferStream } = (0, thumbnail_utils_1.createFileStreamWithBuffer)({
+                    const { fileStream, bufferStream } = thumbnail_service_1.ThumbnailService.instance.createFileStreamWithBuffer({
                         path: file.absolutePath,
                         fileType,
                     });
@@ -84,51 +88,57 @@ class UploadFileService {
                 timings.driveUpload = driveTimer.stop();
                 const thumbnailTimer = cli_utils_1.CLIUtils.timer();
                 if (thumbnailStream && fileSize > 0) {
-                    void (0, thumbnail_utils_1.tryUploadThumbnail)({
+                    await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
                         bufferStream: thumbnailStream,
                         fileType,
-                        userBucket: bucket,
+                        bucket,
                         fileUuid: createdDriveFile.uuid,
                         networkFacade: network,
+                        size: fileSize,
                     });
                 }
                 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`);
+                if (debugMode) {
+                    const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
+                    const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(stats.size, timings.networkUpload);
+                    cli_utils_1.CLIUtils.success(reporter, `Uploaded '${file.name}' (${cli_utils_1.CLIUtils.formatBytesToString(stats.size)})`);
+                    cli_utils_1.CLIUtils.log(reporter, '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)) {
+                if (errors_utils_1.ErrorUtils.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})`);
+                    if (debugMode) {
+                        const retryMsg = `Failed to upload file ${file.name}, retrying in ${delay}ms...`;
+                        cli_utils_1.CLIUtils.warning(reporter, `${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`);
+                    cli_utils_1.CLIUtils.error(reporter, `Failed to upload file '${file.name}' after ${upload_types_1.MAX_RETRIES + 1} attempts`);
                     return null;
                 }
             }
         }
         return null;
-    }
-    concurrencyArray(array, arraySize) {
+    };
+    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

@@ -1,6 +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>;
+    createFolders: ({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }: CreateFoldersParams) => Promise<Map<string, string>>;
+    createFolderWithRetry: ({ folderName, parentFolderUuid, debugMode, reporter, }: CreateFolderWithRetryParams) => Promise<string | null>;
 }

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

@@ -6,9 +6,10 @@ 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");
+const cli_utils_1 = require("../../../utils/cli.utils");
 class UploadFolderService {
     static instance = new UploadFolderService();
-    async createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }) {
+    createFolders = async ({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }) => {
         const folderMap = new Map();
         for (const folder of foldersToCreate) {
             const parentPath = (0, node_path_1.dirname)(folder.relativePath);
@@ -20,6 +21,8 @@ class UploadFolderService {
             const createdFolderUuid = await this.createFolderWithRetry({
                 folderName: folder.name,
                 parentFolderUuid: parentUuid,
+                debugMode,
+                reporter,
             });
             if (createdFolderUuid) {
                 folderMap.set(folder.relativePath, createdFolderUuid);
@@ -28,11 +31,11 @@ class UploadFolderService {
             }
         }
         return folderMap;
-    }
-    async createFolderWithRetry({ folderName, parentFolderUuid }) {
+    };
+    createFolderWithRetry = async ({ folderName, parentFolderUuid, debugMode, reporter, }) => {
         for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
             try {
-                const [createFolderPromise] = drive_folder_service_1.DriveFolderService.instance.createFolder({
+                const [createFolderPromise] = await drive_folder_service_1.DriveFolderService.instance.createFolder({
                     plainName: folderName,
                     parentFolderUuid,
                 });
@@ -40,23 +43,25 @@ class UploadFolderService {
                 return createdFolder.uuid;
             }
             catch (error) {
-                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
-                    logger_utils_1.logger.info(`Folder ${folderName} already exists, skipping...`);
+                if (errors_utils_1.ErrorUtils.isAlreadyExistsError(error)) {
+                    logger_utils_1.logger.warn(`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})`);
+                    if (debugMode) {
+                        cli_utils_1.CLIUtils.warning(reporter, `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`);
+                    cli_utils_1.CLIUtils.error(reporter, `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

@@ -1,4 +1,5 @@
 import { LoginUserDetails } from '../../../types/command.types';
+import { LogReporter } from '../../../utils/cli.utils';
 import { FileSystemNode } from '../../local-filesystem/local-filesystem.types';
 import { NetworkFacade } from '../network-facade.service';
 export interface UploadResult {
@@ -12,6 +13,8 @@ export interface UploadFolderParams {
     loginUserDetails: LoginUserDetails;
     jsonFlag?: boolean;
     onProgress: (progress: UploadProgress) => void;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export interface UploadProgress {
     percentage: number;
@@ -25,10 +28,14 @@ export interface CreateFoldersParams {
         bytesUploaded: number;
     };
     emitProgress: () => void;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export interface CreateFolderWithRetryParams {
     folderName: string;
     parentFolderUuid: string;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export interface UploadFilesConcurrentlyParams {
     network: NetworkFacade;
@@ -41,12 +48,16 @@ export interface UploadFilesConcurrentlyParams {
         bytesUploaded: number;
     };
     emitProgress: () => void;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export interface UploadFileWithRetryParams {
     file: FileSystemNode;
     network: NetworkFacade;
     bucket: string;
     parentFolderUuid: string;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export declare const MAX_CONCURRENT_UPLOADS = 10;
 export declare const DELAYS_MS: number[];

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

@@ -1,5 +1,6 @@
 import { Auth, Drive, Network as NetworkModule } from '@internxt/sdk';
 import { ApiSecurity, AppDetails } from '@internxt/sdk/dist/shared';
+import { Workspaces } from '@internxt/sdk/dist/workspaces';
 export type SdkManagerApiSecurity = ApiSecurity;
 export declare class SdkManager {
     static readonly instance: SdkManager;
@@ -10,13 +11,14 @@ export declare class SdkManager {
         throwErrorOnMissingCredentials?: boolean | undefined;
     }) => SdkManagerApiSecurity;
     static readonly getAppDetails: () => AppDetails;
-    getAuth(): Auth;
-    getUsers(): Drive.Users;
-    getStorage(): Drive.Storage;
-    getTrash(): Drive.Trash;
-    getShare(): Drive.Share;
-    getNetwork(credentials: {
+    getAuth: () => Auth;
+    getUsers: () => Drive.Users;
+    getStorage: () => Drive.Storage;
+    getTrash: () => Drive.Trash;
+    getShare: () => Drive.Share;
+    getWorkspaces: () => Workspaces;
+    getNetwork: (credentials: {
         user: string;
         pass: string;
-    }): NetworkModule.Network;
+    }) => NetworkModule.Network;
 }

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

@@ -9,11 +9,19 @@ const drive_1 = require("@internxt/sdk/dist/drive");
 const config_service_1 = require("./config.service");
 const package_json_1 = __importDefault(require("../../package.json"));
 const network_utils_1 = require("../utils/network.utils");
+const workspaces_1 = require("@internxt/sdk/dist/workspaces");
+const MAX_RETRIES = 3;
 class SdkManager {
     static instance = new SdkManager();
     static apiSecurity;
     static init = (apiSecurity) => {
-        SdkManager.apiSecurity = apiSecurity;
+        const newApiSecurity = {
+            ...apiSecurity,
+            retryOptions: {
+                maxRetries: MAX_RETRIES,
+            },
+        };
+        SdkManager.apiSecurity = newApiSecurity;
     };
     static clean = () => {
         SdkManager.apiSecurity = undefined;
@@ -30,37 +38,43 @@ class SdkManager {
             desktopHeader: config_service_1.ConfigService.instance.get('DESKTOP_HEADER'),
         };
     };
-    getAuth() {
+    getAuth = () => {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Auth.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getUsers() {
+    };
+    getUsers = () => {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getStorage() {
+    };
+    getStorage = () => {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Storage.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getTrash() {
+    };
+    getTrash = () => {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return drive_1.Trash.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
-    }
-    getShare() {
+    };
+    getShare = () => {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Share.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
-    }
-    getNetwork(credentials) {
+    };
+    getWorkspaces = () => {
+        const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
+        const apiSecurity = SdkManager.getApiSecurity();
+        const appDetails = SdkManager.getAppDetails();
+        return workspaces_1.Workspaces.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
+    };
+    getNetwork = (credentials) => {
         const appDetails = SdkManager.getAppDetails();
         const auth = network_utils_1.NetworkUtils.getAuthFromCredentials({
             user: credentials.user,
@@ -70,6 +84,6 @@ class SdkManager {
             bridgeUser: auth.username,
             userId: auth.password,
         });
-    }
+    };
 }
 exports.SdkManager = SdkManager;

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

@@ -1,7 +1,25 @@
+import { Readable } from 'node:stream';
 import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { NetworkFacade } from './network/network-facade.service';
+import { BufferStream } from '../utils/stream.utils';
 export declare class ThumbnailService {
     static readonly instance: ThumbnailService;
-    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: string, networkFacade: NetworkFacade) => Promise<StorageTypes.Thumbnail | undefined>;
+    private static readonly MAX_THUMBNAIL_TIMEOUT;
+    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: string, networkFacade: NetworkFacade, fileSize: number) => Promise<StorageTypes.Thumbnail | undefined>;
     private readonly getThumbnailFromImageBuffer;
+    tryUploadThumbnail: ({ bufferStream, fileType, bucket, fileUuid, networkFacade, size, }: {
+        bufferStream?: BufferStream;
+        fileType: string;
+        bucket: string;
+        fileUuid: string;
+        networkFacade: NetworkFacade;
+        size: number;
+    }) => Promise<void>;
+    createFileStreamWithBuffer: ({ path, fileType, }: {
+        path: string;
+        fileType: string;
+    }) => {
+        bufferStream?: BufferStream;
+        fileStream: Readable;
+    };
 }

package/dist/services/thumbnail.service.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThumbnailService = void 0;
 const node_stream_1 = require("node:stream");
+const node_fs_1 = require("node:fs");
 const drive_file_service_1 = require("./drive/drive-file.service");
 const drive_1 = require("@internxt/sdk/dist/drive");
 const thumbnail_utils_1 = require("../utils/thumbnail.utils");
+const stream_utils_1 = require("../utils/stream.utils");
+const errors_utils_1 = require("../utils/errors.utils");
+const async_utils_1 = require("../utils/async.utils");
 let sharpDependency = null;
 const getSharp = async () => {
     if (!sharpDependency) {
@@ -19,9 +23,10 @@ const getSharp = async () => {
 };
 class ThumbnailService {
     static instance = new ThumbnailService();
-    uploadThumbnail = async (fileContent, fileType, userBucket, file_id, networkFacade) => {
+    static MAX_THUMBNAIL_TIMEOUT = 30000;
+    uploadThumbnail = async (fileContent, fileType, userBucket, file_id, networkFacade, fileSize) => {
         let thumbnailBuffer;
-        if ((0, thumbnail_utils_1.isImageThumbnailable)(fileType)) {
+        if (thumbnail_utils_1.ThumbnailUtils.isImageThumbnailable(fileType, fileSize)) {
             thumbnailBuffer = await this.getThumbnailFromImageBuffer(fileContent);
         }
         if (thumbnailBuffer) {
@@ -62,5 +67,27 @@ class ThumbnailService {
                 .toBuffer();
         }
     };
+    tryUploadThumbnail = async ({ bufferStream, fileType, bucket, fileUuid, networkFacade, size, }) => {
+        try {
+            const thumbnailBuffer = bufferStream?.getBuffer();
+            if (thumbnailBuffer) {
+                await async_utils_1.AsyncUtils.withTimeout(ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, bucket, fileUuid, networkFacade, size), ThumbnailService.MAX_THUMBNAIL_TIMEOUT, 'Thumbnail upload timeout');
+            }
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error);
+        }
+    };
+    createFileStreamWithBuffer = ({ path, fileType, }) => {
+        const readable = (0, node_fs_1.createReadStream)(path);
+        if (thumbnail_utils_1.ThumbnailUtils.isFileThumbnailable(fileType)) {
+            const bufferStream = new stream_utils_1.BufferStream();
+            return {
+                bufferStream,
+                fileStream: readable.pipe(bufferStream),
+            };
+        }
+        return { fileStream: readable };
+    };
 }
 exports.ThumbnailService = ThumbnailService;

package/dist/services/universal-link.service.d.ts

@@ -1,10 +1,12 @@
 import { LoginCredentials } from '../types/command.types';
+import { LogReporter } from '../utils/cli.utils';
 export declare class UniversalLinkService {
     static readonly instance: UniversalLinkService;
     getUserCredentials: (userSession: {
         mnemonic: string;
         token: string;
+        privateKey: string;
     }) => Promise<LoginCredentials>;
     buildLoginUrl: (redirectUri: string) => string;
-    loginSSO: (jsonFlag: boolean, reporter: (message: string) => void, hostIp?: string, forcedPort?: number) => Promise<LoginCredentials>;
+    loginSSO: (jsonFlag: boolean, reporter: LogReporter, hostIp?: string, forcedPort?: number) => Promise<LoginCredentials>;
 }

package/dist/services/universal-link.service.js

@@ -14,11 +14,22 @@ class UniversalLinkService {
     getUserCredentials = async (userSession) => {
         const clearMnemonic = Buffer.from(userSession.mnemonic, 'base64').toString('utf-8');
         const clearToken = Buffer.from(userSession.token, 'base64').toString('utf-8');
-        const loginCredentials = await auth_service_1.AuthService.instance.refreshUserToken(clearToken, clearMnemonic);
+        const clearPrivateKey = Buffer.from(userSession.privateKey, 'base64').toString('utf-8');
+        const loginCredentials = await auth_service_1.AuthService.instance.refreshUserToken(clearToken, clearMnemonic, clearPrivateKey);
         return {
             user: {
                 ...loginCredentials.user,
                 mnemonic: clearMnemonic,
+                keys: {
+                    ecc: {
+                        privateKey: clearPrivateKey,
+                        publicKey: loginCredentials.user.keys.ecc.publicKey,
+                    },
+                    kyber: {
+                        privateKey: loginCredentials.user.keys.kyber.privateKey,
+                        publicKey: loginCredentials.user.keys.kyber.publicKey,
+                    },
+                },
             },
             token: clearToken,
         };
@@ -41,10 +52,11 @@ class UniversalLinkService {
                 try {
                     const mnemonic = parsedUrl.searchParams.get('mnemonic');
                     const token = parsedUrl.searchParams.get('newToken');
-                    if (!mnemonic || !token) {
+                    const privateKey = parsedUrl.searchParams.get('privateKey');
+                    if (!mnemonic || !token || !privateKey) {
                         throw new Error('Login has failed, please try again');
                     }
-                    const loginCredentials = await this.getUserCredentials({ mnemonic, token });
+                    const loginCredentials = await this.getUserCredentials({ mnemonic, token, privateKey });
                     res.writeHead(302, {
                         Location: `${driveUrl}/auth-link-ok`,
                     });

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

@@ -1,7 +1,6 @@
-import { UsageResponseV2 } from '@internxt/sdk/dist/drive/storage/types';
 export declare class UsageService {
     static readonly instance: UsageService;
     static readonly INFINITE_LIMIT: number;
-    fetchUsage: () => Promise<UsageResponseV2>;
+    fetchUsage: () => Promise<number>;
     fetchSpaceLimit: () => Promise<number>;
 }

package/dist/services/usage.service.js

@@ -8,7 +8,7 @@ class UsageService {
     fetchUsage = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const driveUsage = await storageClient.spaceUsageV2();
-        return driveUsage;
+        return driveUsage.total;
     };
     fetchSpaceLimit = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

package/dist/services/validation.service.js

@@ -31,12 +31,22 @@ class ValidationService {
         return str.trim().length > 0;
     };
     validateDirectoryExists = async (path) => {
-        const directoryStat = await promises_1.default.stat(path);
-        return directoryStat.isDirectory();
+        try {
+            const directoryStat = await promises_1.default.stat(path);
+            return directoryStat.isDirectory();
+        }
+        catch {
+            return false;
+        }
     };
     validateFileExists = async (path) => {
-        const fileStat = await promises_1.default.stat(path);
-        return fileStat.isFile();
+        try {
+            const fileStat = await promises_1.default.stat(path);
+            return fileStat.isFile();
+        }
+        catch {
+            return false;
+        }
     };
     validateJwtAndCheckExpiration = (token) => {
         if (!token || typeof token !== 'string' || token.split('.').length !== 3) {

package/dist/{webdav/services → services/webdav}/webdav-folder.service.d.ts

@@ -1,12 +1,6 @@
-import { ConfigService } from '../../services/config.service';
-import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { DriveFolderItem } from '../../types/drive.types';
 export declare class WebDavFolderService {
-    private readonly dependencies;
-    constructor(dependencies: {
-        driveFolderService: DriveFolderService;
-        configService: ConfigService;
-    });
+    static readonly instance: WebDavFolderService;
     getDriveFolderItemFromPath: (path: string) => Promise<DriveFolderItem | undefined>;
     createFolder: ({ folderName, parentFolderUuid, }: {
         folderName: string;