@internxt/cli 1.3.2 → 1.4.1

package/dist/services/auth.service.js

@@ -5,6 +5,7 @@ const sdk_manager_service_1 = require("./sdk-manager.service");
 const keys_service_1 = require("./keys.service");
 const crypto_service_1 = require("./crypto.service");
 const config_service_1 = require("./config.service");
+const command_types_1 = require("../types/command.types");
 const validation_service_1 = require("./validation.service");
 class AuthService {
     static instance = new AuthService();
@@ -35,7 +36,8 @@ class AuthService {
             user: clearUser,
             token: token,
             newToken: newToken,
-            mnemonic: clearMnemonic,
+            lastLoggedInAt: new Date().toISOString(),
+            lastTokenRefreshAt: new Date().toISOString(),
         };
     };
     is2FANeeded = async (email) => {
@@ -45,35 +47,42 @@ class AuthService {
         });
         return securityDetails.tfaEnabled;
     };
-    getUser = async () => {
-        const usersClient = sdk_manager_service_1.SdkManager.instance.getUsers();
-        const { user } = await usersClient.refreshUser();
-        return user;
-    };
     getAuthDetails = async () => {
-        const loginCredentials = await config_service_1.ConfigService.instance.readUser();
-        if (!loginCredentials) {
-            throw new Error('Credentials not found, please login first');
-        }
-        const { token, newToken, mnemonic } = loginCredentials;
-        if (!token) {
-            throw new Error('Auth token not found, please login again');
+        let loginCreds = await config_service_1.ConfigService.instance.readUser();
+        if (!(loginCreds?.newToken && loginCreds?.token && loginCreds?.user?.mnemonic)) {
+            throw new command_types_1.MissingCredentialsError();
         }
-        if (!newToken) {
-            throw new Error('New Auth token not found, please login again');
+        const oldTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.token);
+        const newTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.newToken);
+        const isValidMnemonic = validation_service_1.ValidationService.instance.validateMnemonic(loginCreds.user.mnemonic);
+        if (!(oldTokenDetails.isValid && newTokenDetails.isValid && isValidMnemonic)) {
+            throw new command_types_1.InvalidCredentialsError();
         }
-        if (!mnemonic) {
-            throw new Error('Mnemonic not found, please login again');
+        if (oldTokenDetails.expiration.expired || newTokenDetails.expiration.expired) {
+            throw new command_types_1.ExpiredCredentialsError();
         }
-        if (!validation_service_1.ValidationService.instance.validateMnemonic(mnemonic)) {
-            throw new Error('Mnemonic is not valid, please login again');
+        const refreshOldToken = !oldTokenDetails.expiration.expired && oldTokenDetails.expiration.refreshRequired;
+        const refreshNewToken = !newTokenDetails.expiration.expired && newTokenDetails.expiration.refreshRequired;
+        if (refreshOldToken || refreshNewToken) {
+            loginCreds = await this.refreshUserTokens(loginCreds);
         }
-        return {
-            token,
-            newToken,
-            mnemonic,
-            user: loginCredentials.user,
+        return loginCreds;
+    };
+    refreshUserTokens = async (oldCreds) => {
+        const usersClient = sdk_manager_service_1.SdkManager.instance.getUsers(true);
+        const newCreds = await usersClient.getUserData({ userUuid: oldCreds.user.uuid });
+        const loginCreds = {
+            user: {
+                ...newCreds.user,
+                mnemonic: oldCreds.user.mnemonic,
+                privateKey: oldCreds.user.privateKey,
+            },
+            token: newCreds.oldToken,
+            newToken: newCreds.newToken,
+            lastLoggedInAt: oldCreds.lastLoggedInAt,
+            lastTokenRefreshAt: new Date().toISOString(),
         };
+        return loginCreds;
     };
 }
 exports.AuthService = AuthService;

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

@@ -1,5 +1,5 @@
 import { ConfigKeys } from '../types/config.types';
-import { CLICredentials, WebdavConfig } from '../types/command.types';
+import { LoginCredentials, WebdavConfig } from '../types/command.types';
 export declare class ConfigService {
     static readonly INTERNXT_CLI_DATA_DIR: string;
     static readonly INTERNXT_CLI_LOGS_DIR: string;
@@ -13,9 +13,9 @@ export declare class ConfigService {
     static readonly WEBDAV_DEFAULT_PROTOCOL = "https";
     static readonly instance: ConfigService;
     get: (key: keyof ConfigKeys) => string;
-    saveUser: (loginCredentials: CLICredentials) => Promise<void>;
+    saveUser: (loginCredentials: LoginCredentials) => Promise<void>;
     clearUser: () => Promise<void>;
-    readUser: () => Promise<CLICredentials | undefined>;
+    readUser: () => Promise<LoginCredentials | undefined>;
     saveWebdavConfig: (webdavConfig: WebdavConfig) => Promise<void>;
     readWebdavConfig: () => Promise<WebdavConfig>;
     ensureInternxtCliDataDirExists: () => Promise<void>;

package/dist/services/config.service.js

@@ -4,18 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigService = void 0;
-const path_1 = __importDefault(require("path"));
+const node_path_1 = __importDefault(require("node:path"));
 const os_1 = __importDefault(require("os"));
-const promises_1 = __importDefault(require("fs/promises"));
+const promises_1 = __importDefault(require("node:fs/promises"));
 const crypto_service_1 = require("./crypto.service");
 class ConfigService {
-    static INTERNXT_CLI_DATA_DIR = path_1.default.join(os_1.default.homedir(), '.internxt-cli');
-    static INTERNXT_CLI_LOGS_DIR = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'logs');
+    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 = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, '.inxtcli');
-    static DRIVE_SQLITE_FILE = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
-    static WEBDAV_SSL_CERTS_DIR = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'certs');
-    static WEBDAV_CONFIGS_FILE = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
+    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_LOCAL_URL = 'webdav.local.internxt.com';
     static WEBDAV_DEFAULT_PORT = '3005';
     static WEBDAV_DEFAULT_PROTOCOL = 'https';

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

@@ -1,7 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { CryptoProvider } from '@internxt/sdk';
-import { Transform } from 'stream';
+import { Transform } from 'node:stream';
 export declare class CryptoService {
     static readonly instance: CryptoService;
     static readonly cryptoProvider: CryptoProvider;

package/dist/services/crypto.service.js

@@ -1,40 +1,17 @@
 "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 (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CryptoService = void 0;
-const node_crypto_1 = __importStar(require("node:crypto"));
+const node_crypto_1 = require("node:crypto");
 const keys_service_1 = require("./keys.service");
 const config_service_1 = require("../services/config.service");
 const stream_utils_1 = require("../utils/stream.utils");
 class CryptoService {
     static instance = new CryptoService();
     static cryptoProvider = {
-        encryptPasswordHash(password, encryptedSalt) {
+        async encryptPasswordHash(password, encryptedSalt) {
             const salt = CryptoService.instance.decryptText(encryptedSalt);
             const hashObj = CryptoService.instance.passToHash({ password, salt });
-            return Promise.resolve(CryptoService.instance.encryptText(hashObj.hash));
+            return CryptoService.instance.encryptText(hashObj.hash);
         },
         async generateKeys(password) {
             const { privateKeyArmoredEncrypted, publicKeyArmored, revocationCertificate } = await keys_service_1.KeysService.instance.generateNewKeysWithEncrypted(password);
@@ -48,17 +25,15 @@ class CryptoService {
                 },
                 kyber: {
                     privateKeyEncrypted: null,
-                    publicKey: null
-                }
+                    publicKey: null,
+                },
             };
             return keys;
         },
     };
     passToHash = (passObject) => {
-        const salt = passObject.salt ? passObject.salt : node_crypto_1.default.randomBytes(128 / 8).toString('hex');
-        const hash = node_crypto_1.default
-            .pbkdf2Sync(passObject.password, Buffer.from(salt, 'hex'), 10000, 256 / 8, 'sha1')
-            .toString('hex');
+        const salt = passObject.salt ? passObject.salt : (0, node_crypto_1.randomBytes)(128 / 8).toString('hex');
+        const hash = (0, node_crypto_1.pbkdf2Sync)(passObject.password, Buffer.from(salt, 'hex'), 10000, 256 / 8, 'sha1').toString('hex');
         const hashedObjetc = {
             salt,
             hash,
@@ -74,9 +49,9 @@ class CryptoService {
         return this.decryptTextWithKey(encryptedText, APP_CRYPTO_SECRET);
     };
     encryptTextWithKey = (textToEncrypt, secret) => {
-        const salt = node_crypto_1.default.randomBytes(8);
+        const salt = (0, node_crypto_1.randomBytes)(8);
         const { key, iv } = this.getKeyAndIvFrom(secret, salt);
-        const cipher = node_crypto_1.default.createCipheriv('aes-256-cbc', key, iv);
+        const cipher = (0, node_crypto_1.createCipheriv)('aes-256-cbc', key, iv);
         const encrypted = Buffer.concat([cipher.update(textToEncrypt, 'utf8'), cipher.final()]);
         const openSSLstart = Buffer.from('Salted__');
         return Buffer.concat([openSSLstart, salt, encrypted]).toString('hex');
@@ -85,7 +60,7 @@ class CryptoService {
         const cypherText = Buffer.from(encryptedText, 'hex');
         const salt = cypherText.subarray(8, 16);
         const { key, iv } = this.getKeyAndIvFrom(secret, salt);
-        const decipher = node_crypto_1.default.createDecipheriv('aes-256-cbc', key, iv);
+        const decipher = (0, node_crypto_1.createDecipheriv)('aes-256-cbc', key, iv);
         const contentsToDecrypt = cypherText.subarray(16);
         return Buffer.concat([decipher.update(contentsToDecrypt), decipher.final()]).toString('utf8');
     };
@@ -123,7 +98,7 @@ class CryptoService {
         const md5Hashes = [];
         let digest = password;
         for (let i = 0; i < TRANSFORM_ROUNDS; i++) {
-            md5Hashes[i] = node_crypto_1.default.createHash('md5').update(digest).digest();
+            md5Hashes[i] = (0, node_crypto_1.createHash)('md5').update(digest).digest();
             digest = Buffer.concat([md5Hashes[i], password]);
         }
         const key = Buffer.concat([md5Hashes[0], md5Hashes[1]]);

package/dist/services/database/drive-file/drive-file.repository.d.ts

@@ -2,9 +2,9 @@ import { DriveFileItem } from '../../../types/drive.types';
 import { DriveFileModel } from './drive-file.model';
 import { DriveFile } from './drive-file.domain';
 export declare class DriveFileRepository {
-    findByRelativePath: (relativePath: DriveFile['relativePath']) => Promise<DriveFile | null>;
-    findById: (id: DriveFile['id']) => Promise<DriveFile | null>;
-    deleteById: (id: DriveFile['id']) => Promise<void>;
+    findByRelativePath: (relativePath: DriveFile["relativePath"]) => Promise<DriveFile | null>;
+    findById: (id: DriveFile["id"]) => Promise<DriveFile | null>;
+    deleteById: (id: DriveFile["id"]) => Promise<void>;
     createFile: (driveFileItem: DriveFileItem, relativePath: string) => Promise<DriveFile>;
     toDomain: (model: DriveFileModel) => DriveFile;
     static readonly clean: () => Promise<void>;

package/dist/services/database/drive-folder/drive-folder.repository.d.ts

@@ -2,9 +2,9 @@ import { DriveFolderItem } from '../../../types/drive.types';
 import { DriveFolder } from './drive-folder.domain';
 import { DriveFolderModel } from './drive-folder.model';
 export declare class DriveFolderRepository {
-    findByRelativePath: (relativePath: DriveFolder['relativePath']) => Promise<DriveFolder | null>;
-    findById: (id: DriveFolder['id']) => Promise<DriveFolder | null>;
-    deleteById: (id: DriveFolder['id']) => Promise<void>;
+    findByRelativePath: (relativePath: DriveFolder["relativePath"]) => Promise<DriveFolder | null>;
+    findById: (id: DriveFolder["id"]) => Promise<DriveFolder | null>;
+    deleteById: (id: DriveFolder["id"]) => Promise<void>;
     createFolder: (driveFolderItem: DriveFolderItem, relativePath: string) => Promise<DriveFolder>;
     toDomain: (model: DriveFolderModel) => DriveFolder;
     static readonly clean: () => Promise<void>;

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

@@ -2,14 +2,7 @@ import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { DriveFileItem } from '../../types/drive.types';
 export declare class DriveFileService {
     static readonly instance: DriveFileService;
-    createFile: (payload: {
-        name: string;
-        type: string;
-        size: number;
-        folderId: number;
-        fileId: string;
-        bucket: string;
-    }) => Promise<DriveFileItem>;
+    createFile: (payload: StorageTypes.FileEntryByUuid) => Promise<DriveFileItem>;
     getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
     moveFile: (payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
     renameFile: (fileUuid: string, payload: {

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

@@ -1,38 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveFileService = void 0;
-const lib_1 = require("@internxt/lib");
-const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const sdk_manager_service_1 = require("../sdk-manager.service");
-const config_service_1 = require("../config.service");
-const crypto_utils_1 = require("../../utils/crypto.utils");
 const drive_utils_1 = require("../../utils/drive.utils");
 class DriveFileService {
     static instance = new DriveFileService();
     createFile = async (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const encryptedName = lib_1.aes.encrypt(payload.name, `${config_service_1.ConfigService.instance.get('APP_CRYPTO_SECRET2')}-${payload.folderId}`, crypto_utils_1.CryptoUtils.getAesInit());
-        const driveFile = await storageClient.createFileEntry({
-            name: encryptedName,
-            size: payload.size,
-            folder_id: payload.folderId,
-            id: payload.fileId,
-            type: payload.type,
-            plain_name: payload.name,
-            bucket: payload.bucket,
-            encrypt_version: types_1.EncryptionVersion.Aes03,
-        });
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const driveFile = await storageClient.createFileEntryByUuid(payload);
         return {
-            size: Number(driveFile.size),
+            name: payload.plain_name,
+            encryptedName: driveFile.name,
+            id: driveFile.id,
             uuid: driveFile.uuid,
-            encryptedName,
-            name: payload.name,
-            bucket: payload.bucket,
+            size: driveFile.size,
+            bucket: driveFile.bucket,
             createdAt: new Date(driveFile.createdAt),
             updatedAt: new Date(driveFile.updatedAt),
-            fileId: payload.fileId,
-            id: driveFile.id,
-            type: payload.type,
+            fileId: driveFile.fileId,
+            type: driveFile.type,
             status: driveFile.status,
             folderId: driveFile.folderId,
             folderUuid: driveFile.folderUuid,

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

@@ -13,10 +13,7 @@ export declare class DriveFolderService {
     private readonly getAllSubfolders;
     private readonly getAllSubfiles;
     moveFolder: (payload: StorageTypes.MoveFolderUuidPayload) => Promise<StorageTypes.FolderMeta>;
-    createFolder(payload: {
-        folderName: string;
-        parentFolderId: number;
-    }): [Promise<StorageTypes.CreateFolderResponse>, RequestCanceler];
+    createFolder(payload: StorageTypes.CreateFolderByUuidPayload): [Promise<StorageTypes.CreateFolderResponse>, RequestCanceler];
     renameFolder: (payload: {
         folderUuid: string;
         name: string;

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

@@ -46,11 +46,8 @@ class DriveFolderService {
         return storageClient.moveFolderByUuid(payload);
     };
     createFolder(payload) {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.createFolder({
-            folderName: payload.folderName,
-            parentFolderId: payload.parentFolderId,
-        });
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        return storageClient.createFolderByUuid(payload);
     }
     renameFolder = (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);

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

@@ -2,6 +2,8 @@ import { StorageTypes } from '@internxt/sdk/dist/drive';
 export declare class TrashService {
     static readonly instance: TrashService;
     trashItems: (payload: StorageTypes.AddItemsToTrashPayload) => Promise<void>;
+    deleteFile: (payload: StorageTypes.DeleteFilePayload) => Promise<unknown>;
+    deleteFolder: (folderId: number) => Promise<unknown>;
     clearTrash: () => Promise<void>;
     getTrashFolderContent: () => Promise<{
         folders: StorageTypes.FetchPaginatedFolder[];

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

@@ -8,6 +8,14 @@ class TrashService {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
         return storageClient.addItemsToTrash(payload);
     };
+    deleteFile = (payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(false);
+        return storageClient.deleteFile(payload);
+    };
+    deleteFolder = (folderId) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(false);
+        return storageClient.deleteFolder(folderId);
+    };
     clearTrash = () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getTrash();
         return storageClient.clearTrash();

package/dist/services/keys.service.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+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.KeysService = void 0;
 const lib_1 = require("@internxt/lib");

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

@@ -1,11 +1,9 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { Network } from '@internxt/sdk';
+import { Readable } from 'node:stream';
 import { DownloadOptions, UploadOptions } from '../../types/network.types';
 import { CryptoService } from '../crypto.service';
 import { UploadService } from './upload.service';
 import { DownloadService } from './download.service';
-import { Readable } from 'node:stream';
 export declare class NetworkFacade {
     private readonly network;
     private readonly uploadService;

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

@@ -15,23 +15,30 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+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.NetworkFacade = void 0;
 const sdk_1 = require("@internxt/sdk");
 const NetworkUpload = __importStar(require("@internxt/sdk/dist/network/upload"));
 const NetworkDownload = __importStar(require("@internxt/sdk/dist/network/download"));
 const inxt_js_1 = require("@internxt/inxt-js");
-const crypto_1 = __importDefault(require("crypto"));
+const node_crypto_1 = require("node:crypto");
 const validation_service_1 = require("../validation.service");
 const hash_utils_1 = require("../../utils/hash.utils");
 const stream_utils_1 = require("../../utils/stream.utils");
@@ -54,7 +61,7 @@ class NetworkFacade {
             generateFileKey: (mnemonic, bucketId, index) => {
                 return inxt_js_1.Environment.utils.generateFileKey(mnemonic, bucketId, index);
             },
-            randomBytes: crypto_1.default.randomBytes,
+            randomBytes: node_crypto_1.randomBytes,
         };
     }
     async downloadToStream(bucketId, mnemonic, fileId, to, options) {
@@ -93,7 +100,6 @@ class NetworkFacade {
     async uploadFromStream(bucketId, mnemonic, size, from, options) {
         const hashStream = new hash_utils_1.HashStream();
         const abortable = options?.abortController ?? new AbortController();
-        let fileHash;
         let encryptionTransform;
         const progressTransform = new stream_utils_1.ProgressTransform({ totalBytes: size }, (progress) => {
             if (options?.progressCallback) {
@@ -120,6 +126,7 @@ class NetworkFacade {
         };
         const uploadOperation = async () => {
             const uploadResult = await NetworkUpload.uploadFile(this.network, this.cryptoLib, bucketId, mnemonic, size, encryptFile, uploadFile);
+            const fileHash = Buffer.from('');
             onProgress(1);
             return {
                 fileId: uploadResult,

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Readable } from 'node:stream';
 import { UploadOptions } from '../../types/network.types';
 export declare class UploadService {

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

@@ -12,10 +12,9 @@ export declare class SdkManager {
         throwErrorOnMissingCredentials: boolean;
     }) => SdkManagerApiSecurity;
     static readonly getAppDetails: () => AppDetails;
-    getAuthV2(): Auth;
-    getAuth(): Auth;
+    getAuth(useNewApi?: boolean): Auth;
     getPayments(): Drive.Payments;
-    getUsers(): Drive.Users;
+    getUsers(useNewApi?: boolean): Drive.Users;
     getReferrals(): Drive.Referrals;
     getStorage(useNewApi?: boolean): Drive.Storage;
     getTrash(): Drive.Trash;

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

@@ -29,17 +29,15 @@ class SdkManager {
             clientVersion: package_json_1.default.version,
         };
     };
-    getAuthV2() {
-        const DRIVE_NEW_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_NEW_API_URL, appDetails, apiSecurity);
-    }
-    getAuth() {
-        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getAuth(useNewApi = false) {
+        const DRIVE_API_URL = useNewApi
+            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
+            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Auth.client(DRIVE_API_URL, appDetails, apiSecurity);
+        return sdk_1.Auth.client(DRIVE_API_URL, appDetails, {
+            token: useNewApi ? apiSecurity?.newToken : apiSecurity?.token,
+        });
     }
     getPayments() {
         const PAYMENTS_API_URL = config_service_1.ConfigService.instance.get('PAYMENTS_API_URL');
@@ -49,11 +47,15 @@ class SdkManager {
             token: newToken,
         });
     }
-    getUsers() {
-        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getUsers(useNewApi = false) {
+        const DRIVE_API_URL = useNewApi
+            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
+            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, apiSecurity);
+        return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, {
+            token: useNewApi ? apiSecurity.newToken : apiSecurity.token,
+        });
     }
     getReferrals() {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');

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

@@ -6,4 +6,14 @@ export declare class ValidationService {
     validateUUIDv4: (uuid: string) => boolean;
     validateYesOrNoString: (message: string) => boolean;
     validateTCPIntegerPort: (port: string) => boolean;
+    validateStringIsNotEmpty: (str: string) => boolean;
+    validateDirectoryExists: (path: string) => Promise<boolean>;
+    validateFileExists: (path: string) => Promise<boolean>;
+    validateTokenAndCheckExpiration: (token?: string) => {
+        isValid: boolean;
+        expiration: {
+            expired: boolean;
+            refreshRequired: boolean;
+        };
+    };
 }

package/dist/services/validation.service.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidationService = void 0;
 const lib_1 = require("@internxt/lib");
 const bip39_1 = require("bip39");
+const promises_1 = __importDefault(require("node:fs/promises"));
 class ValidationService {
     static instance = new ValidationService();
     validateEmail = (email) => {
@@ -18,10 +22,45 @@ class ValidationService {
         return /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.test(uuid);
     };
     validateYesOrNoString = (message) => {
-        return message.length > 0 && /^(yes|no|y|n)$/i.test(message.toLowerCase().trim());
+        return message.length > 0 && /^(yes|no|y|n)$/i.test(message.trim());
     };
     validateTCPIntegerPort = (port) => {
         return /^\d+$/.test(port) && Number(port) >= 1 && Number(port) <= 65535;
     };
+    validateStringIsNotEmpty = (str) => {
+        return str.trim().length > 0;
+    };
+    validateDirectoryExists = async (path) => {
+        const directoryStat = await promises_1.default.stat(path);
+        return directoryStat.isDirectory();
+    };
+    validateFileExists = async (path) => {
+        const fileStat = await promises_1.default.stat(path);
+        return fileStat.isFile();
+    };
+    validateTokenAndCheckExpiration = (token) => {
+        if (!token || typeof token !== 'string') {
+            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+        }
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+        }
+        try {
+            const payload = JSON.parse(atob(parts[1]));
+            if (typeof payload.exp !== 'number') {
+                return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+            }
+            const currentTime = Math.floor(Date.now() / 1000);
+            const twoDaysInSeconds = 2 * 24 * 60 * 60;
+            const remainingSeconds = payload.exp - currentTime;
+            const expired = remainingSeconds <= 0;
+            const refreshRequired = remainingSeconds > 0 && remainingSeconds <= twoDaysInSeconds;
+            return { isValid: true, expiration: { expired, refreshRequired } };
+        }
+        catch {
+            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+        }
+    };
 }
 exports.ValidationService = ValidationService;