@internxt/cli 1.6.2 → 1.6.4

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,20 +23,19 @@ 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) {
             const size = thumbnailBuffer.length;
-            const fileId = await new Promise((resolve, reject) => {
-                networkFacade.uploadFile(node_stream_1.Readable.from(thumbnailBuffer), size, userBucket, (err, res) => {
-                    if (err) {
-                        return reject(err);
-                    }
-                    resolve(res);
-                }, () => { });
+            const fileId = await networkFacade.uploadFile({
+                from: node_stream_1.Readable.from(thumbnailBuffer),
+                size: size,
+                bucketId: userBucket,
+                progressCallback: () => { },
             });
             const createdThumbnailFile = await drive_file_service_1.DriveFileService.instance.createThumbnail({
                 fileUuid: file_id,
@@ -62,5 +65,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;

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

@@ -1,25 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavFolderService = void 0;
+const config_service_1 = require("../../services/config.service");
+const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
 const errors_utils_1 = require("../../utils/errors.utils");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const async_utils_1 = require("../../utils/async.utils");
 const auth_service_1 = require("../../services/auth.service");
 const drive_utils_1 = require("../../utils/drive.utils");
 class WebDavFolderService {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
+    static instance = new WebDavFolderService();
     getDriveFolderItemFromPath = async (path) => {
         const { url } = await webdav_utils_1.WebDavUtils.getRequestedResource(path, false);
-        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
-            url,
-            driveFolderService: this.dependencies.driveFolderService,
-        });
+        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource(url);
     };
     createFolder = async ({ folderName, parentFolderUuid, }) => {
-        const [createFolderPromise] = this.dependencies.driveFolderService.createFolder({
+        const [createFolderPromise] = await drive_folder_service_1.DriveFolderService.instance.createFolder({
             plainName: folderName,
             parentFolderUuid: parentFolderUuid,
         });
@@ -28,7 +24,7 @@ class WebDavFolderService {
         return drive_utils_1.DriveUtils.createFolderResponseToItem(newFolder);
     };
     createParentPathOrThrow = async (parentPath) => {
-        const { createFullPath } = await this.dependencies.configService.readWebdavConfig();
+        const { createFullPath } = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (!createFullPath) {
             throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${webdav_utils_1.WebDavUtils.decodeUrl(parentPath, false)},
         createFullPath flag is set to: ${createFullPath}`);

package/dist/types/command.types.d.ts

@@ -1,3 +1,5 @@
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
+import { NetworkCredentials } from './network.types';
 export interface LoginUserDetails {
     userId: string;
     uuid: string;
@@ -23,9 +25,21 @@ export interface LoginUserDetails {
     avatar: string | null;
     emailVerified: boolean;
 }
+export interface WorkspaceCredentialsDetails {
+    id: string;
+    bucket: string;
+    workspaceUserId: string;
+    credentials: NetworkCredentials;
+    token: string;
+}
+export interface Workspace {
+    workspaceData: WorkspaceData;
+    workspaceCredentials: WorkspaceCredentialsDetails;
+}
 export interface LoginCredentials {
     user: LoginUserDetails;
     token: string;
+    workspace?: Workspace;
 }
 export interface WebdavConfig {
     host: string;
@@ -33,6 +47,10 @@ export interface WebdavConfig {
     protocol: 'http' | 'https';
     timeoutMinutes: number;
     createFullPath: boolean;
+    customAuth: boolean;
+    username: string;
+    password: string;
+    deleteFilesPermanently: boolean;
 }
 export declare class NotValidEmailError extends Error {
     constructor();
@@ -70,6 +88,12 @@ export declare class EmptyFileNameError extends Error {
 export declare class EmptyFolderNameError extends Error {
     constructor();
 }
+export declare class EmptyCustomAuthUsernameError extends Error {
+    constructor();
+}
+export declare class EmptyCustomAuthPasswordError extends Error {
+    constructor();
+}
 export declare class NotValidPortError extends Error {
     constructor();
 }
@@ -79,6 +103,12 @@ export declare class NotValidDirectoryError extends Error {
 export declare class NotValidFileError extends Error {
     constructor();
 }
+export declare class NotValidWorkspaceUuidError extends Error {
+    constructor();
+}
+export declare class MissingCredentialsWhenUsingAuthError extends Error {
+    constructor();
+}
 export interface PaginatedItem {
     name: string;
     type: string;
@@ -87,8 +117,21 @@ export interface PaginatedItem {
     modified: string;
 }
 export interface PromptOptions {
-    type: 'input' | 'password' | 'mask' | 'confirm';
+    type: 'input' | 'password' | 'mask' | 'confirm' | 'list';
     confirm?: {
         default: boolean;
     };
+    choices?: {
+        values: string[];
+        default?: number;
+    };
+}
+export interface PaginatedWorkspace {
+    name: string;
+    id: string;
+    usedSpace: string;
+    availableSpace: string;
+    owner: string;
+    address: string;
+    created: string;
 }

package/dist/types/command.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyFolderNameError = exports.EmptyFileNameError = exports.InvalidCredentialsError = exports.ExpiredCredentialsError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.NotValidFileIdError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
+exports.MissingCredentialsWhenUsingAuthError = exports.NotValidWorkspaceUuidError = exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyCustomAuthPasswordError = exports.EmptyCustomAuthUsernameError = exports.EmptyFolderNameError = exports.EmptyFileNameError = exports.InvalidCredentialsError = exports.ExpiredCredentialsError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.NotValidFileIdError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
 class NotValidEmailError extends Error {
     constructor() {
         super('Email is not valid');
@@ -85,6 +85,20 @@ class EmptyFolderNameError extends Error {
     }
 }
 exports.EmptyFolderNameError = EmptyFolderNameError;
+class EmptyCustomAuthUsernameError extends Error {
+    constructor() {
+        super('Custom auth username can not be empty');
+        Object.setPrototypeOf(this, EmptyCustomAuthUsernameError.prototype);
+    }
+}
+exports.EmptyCustomAuthUsernameError = EmptyCustomAuthUsernameError;
+class EmptyCustomAuthPasswordError extends Error {
+    constructor() {
+        super('Custom auth password can not be empty');
+        Object.setPrototypeOf(this, EmptyCustomAuthPasswordError.prototype);
+    }
+}
+exports.EmptyCustomAuthPasswordError = EmptyCustomAuthPasswordError;
 class NotValidPortError extends Error {
     constructor() {
         super('Port should be a number between 1 and 65535');
@@ -106,3 +120,17 @@ class NotValidFileError extends Error {
     }
 }
 exports.NotValidFileError = NotValidFileError;
+class NotValidWorkspaceUuidError extends Error {
+    constructor() {
+        super('Workspace UUID is not valid (it must be a valid v4 UUID)');
+        Object.setPrototypeOf(this, NotValidWorkspaceUuidError.prototype);
+    }
+}
+exports.NotValidWorkspaceUuidError = NotValidWorkspaceUuidError;
+class MissingCredentialsWhenUsingAuthError extends Error {
+    constructor() {
+        super('When using custom WebDAV authentication, both username and password must be provided');
+        Object.setPrototypeOf(this, MissingCredentialsWhenUsingAuthError.prototype);
+    }
+}
+exports.MissingCredentialsWhenUsingAuthError = MissingCredentialsWhenUsingAuthError;

package/dist/types/config.types.d.ts

@@ -1,4 +1,5 @@
 export interface ConfigKeys {
+    readonly NODE_ENV: string;
     readonly DRIVE_WEB_URL: string;
     readonly DRIVE_NEW_API_URL: string;
     readonly APP_CRYPTO_SECRET: string;

package/dist/types/drive.types.d.ts

@@ -1,19 +1,20 @@
-import { DriveFolderData, FileMeta } from '@internxt/sdk/dist/drive/storage/types';
-export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVersion' | 'size' | 'createdAt' | 'updatedAt' | 'creationTime' | 'modificationTime' | 'type'> & {
+import { FileMeta, FolderMeta } from '@internxt/sdk/dist/drive/storage/types';
+export type DriveFileItem = Pick<FileMeta, 'uuid' | 'name' | 'bucket' | 'folderUuid' | 'status'> & {
     itemType: 'file';
     size: number;
     createdAt: Date;
     updatedAt: Date;
     creationTime: Date;
     modificationTime: Date;
-    type?: string | null;
+    type: string | null;
+    fileId: string | null;
 };
-export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
+export type DriveFolderItem = Pick<FolderMeta, 'uuid' | 'name' | 'bucket'> & {
     itemType: 'folder';
-    encryptedName: string;
-    uuid: string;
     createdAt: Date;
     updatedAt: Date;
+    creationTime: Date;
+    modificationTime: Date;
     status: 'EXISTS' | 'TRASHED';
     parentUuid: string | null;
 };

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

@@ -1,7 +1,13 @@
+import { NetworkFacade } from '../services/network/network-facade.service';
 export interface NetworkCredentials {
     user: string;
     pass: string;
 }
+export interface NetworkOptions {
+    networkFacade: NetworkFacade;
+    bucket: string;
+    mnemonic: string;
+}
 export type DownloadProgressCallback = (downloadedBytes: number) => void;
 export type UploadProgressCallback = (uploadedBytes: number) => void;
 export interface NetworkOperationBaseOptions {

package/dist/utils/async.utils.d.ts

@@ -1,3 +1,4 @@
 export declare class AsyncUtils {
-    static sleep(ms: number): Promise<void>;
+    static readonly sleep: (ms: number) => Promise<void>;
+    static readonly withTimeout: <T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string) => Promise<T>;
 }

package/dist/utils/async.utils.js

@@ -2,8 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncUtils = void 0;
 class AsyncUtils {
-    static sleep(ms) {
+    static sleep = (ms) => {
         return new Promise((resolve) => setTimeout(resolve, ms));
-    }
+    };
+    static withTimeout = async (promise, timeoutMs, errorMessage = 'Operation timed out') => {
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error(errorMessage));
+            }, timeoutMs);
+        });
+        return Promise.race([promise, timeoutPromise]).finally(() => {
+            clearTimeout(timeoutId);
+        });
+    };
 }
 exports.AsyncUtils = AsyncUtils;

package/dist/utils/cli.utils.d.ts

@@ -1,22 +1,24 @@
 import cliProgress from 'cli-progress';
 import { Header } from 'tty-table';
-import { LoginUserDetails, PromptOptions } from '../types/command.types';
-import { NetworkFacade } from '../services/network/network-facade.service';
+import { LoginCredentials, LoginUserDetails, PromptOptions } from '../types/command.types';
+import { NetworkCredentials, NetworkOptions } from '../types/network.types';
+export type LogReporter = (message: string) => void;
 export declare class CLIUtils {
     static readonly clearPreviousLine: (jsonFlag?: boolean) => void;
-    static readonly warning: (reporter: (message: string) => void, message: string) => void;
-    static readonly error: (reporter: (message: string) => void, message: string) => void;
-    static readonly success: (reporter: (message: string) => void, message: string) => void;
-    static readonly log: (reporter: (message: string) => void, message: string) => void;
+    static readonly warning: (reporter: LogReporter, message: string) => void;
+    static readonly error: (reporter: LogReporter, message: string) => void;
+    static readonly success: (reporter: LogReporter, message: string) => void;
+    static readonly log: (reporter: LogReporter, message: string) => void;
     static readonly consoleLog: (message: string) => void;
     static readonly doing: (message: string, jsonFlag?: boolean) => void;
     static readonly done: (jsonFlag?: boolean) => void;
     static readonly failed: (jsonFlag?: boolean) => void;
     static readonly progress: (opts: cliProgress.Options, jsonFlag?: boolean) => cliProgress.SingleBar | undefined;
-    static readonly table: (reporter: (message: string) => void, header: Header[], rows: object[]) => void;
+    static readonly table: (reporter: LogReporter, header: Header[], rows: object[]) => void;
     static readonly generateTableHeaderFromType: <T extends object>() => Header[];
     static readonly CommonFlags: {
         'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly getValueFromFlag: (flag: {
         value?: string;
@@ -32,13 +34,13 @@ export declare class CLIUtils {
         validate: (value: string) => Promise<boolean> | boolean;
         error: Error;
         canBeEmpty?: boolean;
-    }, reporter: (message: string) => void) => Promise<string>;
+    }, reporter: LogReporter) => Promise<string>;
     static readonly getDestinationFolderUuid: ({ destinationFolderUuidFlag, destinationFlagName, nonInteractive, reporter, }: {
         destinationFolderUuidFlag: string | undefined;
         destinationFlagName: string;
         nonInteractive: boolean;
-        reporter: (message: string) => void;
-    }) => Promise<string | undefined>;
+        reporter: LogReporter;
+    }) => Promise<string>;
     private static readonly promptWithAttempts;
     static readonly timer: () => {
         stop: () => number;
@@ -49,14 +51,17 @@ export declare class CLIUtils {
     static readonly catchError: ({ error, logReporter, command, jsonFlag, }: {
         error: Error;
         command?: string;
-        logReporter: (message: string) => void;
+        logReporter: LogReporter;
         jsonFlag?: boolean;
     }) => void;
     static readonly parseEmpty: (input: string) => Promise<string>;
-    static readonly prepareNetwork: ({ jsonFlag, loginUserDetails, }: {
-        jsonFlag?: boolean;
-        loginUserDetails: LoginUserDetails;
-    }) => NetworkFacade;
+    static readonly prepareNetwork: (loginUserDetails: LoginUserDetails) => Promise<NetworkOptions>;
+    static readonly fallbackToRootFolderIdIfEmpty: (folderId: string) => Promise<string>;
+    static readonly getNetworkCreds: (userCredentials: LoginCredentials["user"]) => Promise<{
+        bucket: string;
+        credentials: NetworkCredentials;
+        mnemonic: string;
+    }>;
 }
 export declare class NoFlagProvidedError extends Error {
     constructor(flag: string);

package/dist/utils/cli.utils.js

@@ -15,8 +15,7 @@ const sdk_manager_service_1 = require("../services/sdk-manager.service");
 const inxt_js_1 = require("@internxt/inxt-js");
 const config_service_1 = require("../services/config.service");
 const network_facade_service_1 = require("../services/network/network-facade.service");
-const download_service_1 = require("../services/network/download.service");
-const crypto_service_1 = require("../services/crypto.service");
+const auth_service_1 = require("../services/auth.service");
 class CLIUtils {
     static clearPreviousLine = (jsonFlag) => {
         if (!jsonFlag) {
@@ -77,6 +76,12 @@ class CLIUtils {
             description: 'Prevents the CLI from being interactive. When enabled, the CLI will not request input through the console and will throw errors directly.',
             required: false,
         }),
+        debug: core_1.Flags.boolean({
+            env: 'INXT_DEBUG',
+            helpGroup: 'helper',
+            description: 'Enables debug mode. When enabled, the CLI will print debug messages to the console.',
+            required: false,
+        }),
     };
     static getValueFromFlag = async (flag, command, validation, reporter) => {
         if (flag.value) {
@@ -117,12 +122,7 @@ class CLIUtils {
             error: new command_types_1.NotValidFolderUuidError(),
             canBeEmpty: true,
         }, reporter);
-        if (destinationFolderUuid.trim().length === 0) {
-            return undefined;
-        }
-        else {
-            return destinationFolderUuid;
-        }
+        return destinationFolderUuid;
     };
     static promptWithAttempts = async (prompt, maxAttempts, validation, reporter) => {
         let isValid = false;
@@ -212,22 +212,52 @@ class CLIUtils {
         }
     };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);
-    static prepareNetwork = ({ jsonFlag, loginUserDetails, }) => {
-        CLIUtils.doing('Preparing Network', jsonFlag);
+    static prepareNetwork = async (loginUserDetails) => {
+        const { credentials, mnemonic, bucket } = await this.getNetworkCreds(loginUserDetails);
         const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
-            user: loginUserDetails.bridgeUser,
-            pass: loginUserDetails.userId,
+            user: credentials.user,
+            pass: credentials.pass,
         });
         const environment = new inxt_js_1.Environment({
-            bridgeUser: loginUserDetails.bridgeUser,
-            bridgePass: loginUserDetails.userId,
+            bridgeUser: credentials.user,
+            bridgePass: credentials.pass,
+            encryptionKey: mnemonic,
             bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
-            encryptionKey: loginUserDetails.mnemonic,
             appDetails: sdk_manager_service_1.SdkManager.getAppDetails(),
         });
-        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
-        CLIUtils.done(jsonFlag);
-        return networkFacade;
+        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment);
+        return { networkFacade, bucket, mnemonic };
+    };
+    static fallbackToRootFolderIdIfEmpty = async (folderId) => {
+        if (folderId.trim().length === 0) {
+            return await auth_service_1.AuthService.instance.getCurrentRootFolder();
+        }
+        else {
+            return folderId;
+        }
+    };
+    static getNetworkCreds = async (userCredentials) => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        if (currentWorkspace) {
+            return {
+                bucket: currentWorkspace.workspaceCredentials.bucket,
+                credentials: {
+                    user: currentWorkspace.workspaceCredentials.credentials.user,
+                    pass: currentWorkspace.workspaceCredentials.credentials.pass,
+                },
+                mnemonic: currentWorkspace.workspaceData.workspaceUser.key,
+            };
+        }
+        else {
+            return {
+                bucket: userCredentials.bucket,
+                credentials: {
+                    user: userCredentials.bridgeUser,
+                    pass: userCredentials.userId,
+                },
+                mnemonic: userCredentials.mnemonic,
+            };
+        }
     };
 }
 exports.CLIUtils = CLIUtils;

package/dist/utils/crypto.utils.d.ts

@@ -1,6 +1,8 @@
 export declare class CryptoUtils {
-    static getAesInit(): {
+    static readonly getAesInit: () => {
         iv: string;
         salt: string;
     };
+    static readonly extendSecret: (secret: Uint8Array, length: number) => Promise<string>;
+    static readonly XORhex: (a: string, b: string) => string;
 }

package/dist/utils/crypto.utils.js

@@ -1,10 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CryptoUtils = void 0;
+const hash_wasm_1 = require("hash-wasm");
 const config_service_1 = require("../services/config.service");
 class CryptoUtils {
-    static getAesInit() {
+    static getAesInit = () => {
         return { iv: config_service_1.ConfigService.instance.get('APP_MAGIC_IV'), salt: config_service_1.ConfigService.instance.get('APP_MAGIC_SALT') };
-    }
+    };
+    static extendSecret = (secret, length) => {
+        return (0, hash_wasm_1.blake3)(secret, length);
+    };
+    static XORhex = (a, b) => {
+        let res = '', i = a.length, j = b.length;
+        if (i != j) {
+            throw new Error('Can XOR only strings with identical length');
+        }
+        while (i-- > 0 && j-- > 0)
+            res = (Number.parseInt(a.charAt(i), 16) ^ Number.parseInt(b.charAt(j), 16)).toString(16) + res;
+        return res;
+    };
 }
 exports.CryptoUtils = CryptoUtils;