@internxt/cli 1.6.1 → 1.6.3

package/dist/commands/workspaces-use.d.ts

@@ -0,0 +1,27 @@
+import { Command } from '@oclif/core';
+import { Workspace } from '../types/command.types';
+export default class WorkspacesUse extends Command {
+    static readonly args: {};
+    static readonly description: string;
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        personal: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+    } | {
+        success: boolean;
+        workspace: Workspace;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getWorkspaceUuid;
+    private extractUuidFromWorkspaceString;
+    private getWorkspace;
+    private setWorkspace;
+}

package/dist/commands/workspaces-use.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const workspace_service_1 = require("../services/drive/workspace.service");
+const format_utils_1 = require("../utils/format.utils");
+const validation_service_1 = require("../services/validation.service");
+const sdk_manager_service_1 = require("../services/sdk-manager.service");
+const workspaces_unset_1 = __importDefault(require("./workspaces-unset"));
+const database_service_1 = require("../services/database/database.service");
+class WorkspacesUse extends core_1.Command {
+    static args = {};
+    static description = 'Set the active workspace context for the current user session. ' +
+        'Once a workspace is selected, WebDAV and all of the subsequent CLI commands ' +
+        'will operate within that workspace until it is changed or unset.';
+    static aliases = ['workspaces:use'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The id of the workspace to activate. ' +
+                'Use <%= config.bin %> workspaces list to view your available workspace ids.',
+            required: false,
+            exclusive: ['personal'],
+        }),
+        personal: core_1.Flags.boolean({
+            char: 'p',
+            description: 'Change to the personal drive space. It unsets the active workspace context for the current user session.',
+            required: false,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(WorkspacesUse);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const reporter = this.log.bind(this);
+        if (flags['personal']) {
+            return workspaces_unset_1.default.unsetWorkspace(userCredentials, reporter);
+        }
+        const workspace = await this.getWorkspace(userCredentials, flags['id'], nonInteractive, reporter);
+        await this.setWorkspace(userCredentials, workspace);
+        const message = `Workspace ${workspace.workspaceCredentials.id} selected successfully. Now WebDAV and ` +
+            'all of the CLI commands will operate within this workspace until it is changed or unset.';
+        cli_utils_1.CLIUtils.success(reporter, message);
+        return { success: true, workspace };
+    };
+    catch = async (error) => {
+        const { flags } = await this.parse(WorkspacesUse);
+        cli_utils_1.CLIUtils.catchError({
+            error,
+            command: this.id,
+            logReporter: this.log.bind(this),
+            jsonFlag: flags['json'],
+        });
+        this.exit(1);
+    };
+    getWorkspaceUuid = async (workspaceUuidFlag, availableWorkspaces, nonInteractive, reporter) => {
+        const workspaceUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: workspaceUuidFlag ? `[${workspaceUuidFlag}]` : undefined,
+            name: WorkspacesUse.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the workspace you want to use?',
+                options: {
+                    type: 'list',
+                    choices: { values: availableWorkspaces },
+                },
+            },
+        }, {
+            validate: (value) => validation_service_1.ValidationService.instance.validateUUIDv4(this.extractUuidFromWorkspaceString(value)),
+            error: new command_types_1.NotValidWorkspaceUuidError(),
+        }, reporter);
+        return this.extractUuidFromWorkspaceString(workspaceUuid);
+    };
+    extractUuidFromWorkspaceString = (workspaceString) => workspaceString.match(/\[(.*?)\]/)?.[1] ?? workspaceString;
+    getWorkspace = async (userCredentials, workspaceUuidFlag, nonInteractive, reporter) => {
+        const workspaces = await workspace_service_1.WorkspaceService.instance.getAvailableWorkspaces(userCredentials.user);
+        const availableWorkspaces = workspaces.map((workspaceData) => {
+            const name = workspaceData.workspace.name;
+            const id = workspaceData.workspace.id;
+            const totalUsedSpace = Number(workspaceData.workspaceUser?.driveUsage ?? 0) + Number(workspaceData.workspaceUser?.backupsUsage ?? 0);
+            const spaceLimit = Number(workspaceData.workspaceUser?.spaceLimit ?? 0);
+            const usedSpace = format_utils_1.FormatUtils.humanFileSize(totalUsedSpace);
+            const availableSpace = format_utils_1.FormatUtils.formatLimit(spaceLimit);
+            return `[${id}] Name: ${name} | Used Space: ${usedSpace} | Available Space: ${availableSpace}`;
+        });
+        const workspaceUuid = await this.getWorkspaceUuid(workspaceUuidFlag, availableWorkspaces, nonInteractive, reporter);
+        const workspaceCredentials = await workspace_service_1.WorkspaceService.instance.getWorkspaceCredentials(workspaceUuid);
+        const selectedWorkspace = workspaces.find((workspace) => workspace.workspace.id === workspaceUuid);
+        if (!selectedWorkspace)
+            throw new command_types_1.NotValidWorkspaceUuidError();
+        return { workspaceCredentials, workspaceData: selectedWorkspace };
+    };
+    setWorkspace = async (userCredentials, workspace) => {
+        sdk_manager_service_1.SdkManager.init({ token: userCredentials.token, workspaceToken: workspace.workspaceCredentials.token });
+        await config_service_1.ConfigService.instance.saveUser({
+            ...userCredentials,
+            workspace,
+        });
+        void database_service_1.DatabaseService.instance.clear();
+    };
+}
+exports.default = WorkspacesUse;

package/dist/constants/configs.d.ts

@@ -0,0 +1,13 @@
+export declare const INTERNXT_CLI_DATA_DIR: string;
+export declare const INTERNXT_CLI_LOGS_DIR: string;
+export declare const CREDENTIALS_FILE: string;
+export declare const DRIVE_SQLITE_FILE: string;
+export declare const WEBDAV_SSL_CERTS_DIR: string;
+export declare const WEBDAV_CONFIGS_FILE: string;
+export declare const WEBDAV_DEFAULT_HOST = "127.0.0.1";
+export declare const WEBDAV_DEFAULT_PORT = "3005";
+export declare const WEBDAV_DEFAULT_PROTOCOL = "https";
+export declare const WEBDAV_DEFAULT_TIMEOUT = 0;
+export declare const WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
+export declare const WEBDAV_DEFAULT_CUSTOM_AUTH = false;
+export declare const WEBDAV_DEFAULT_DELETE_FILES_PERMANENTLY = false;

package/dist/constants/configs.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBDAV_DEFAULT_DELETE_FILES_PERMANENTLY = exports.WEBDAV_DEFAULT_CUSTOM_AUTH = exports.WEBDAV_DEFAULT_CREATE_FULL_PATH = exports.WEBDAV_DEFAULT_TIMEOUT = exports.WEBDAV_DEFAULT_PROTOCOL = exports.WEBDAV_DEFAULT_PORT = exports.WEBDAV_DEFAULT_HOST = exports.WEBDAV_CONFIGS_FILE = exports.WEBDAV_SSL_CERTS_DIR = exports.DRIVE_SQLITE_FILE = exports.CREDENTIALS_FILE = exports.INTERNXT_CLI_LOGS_DIR = exports.INTERNXT_CLI_DATA_DIR = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+exports.INTERNXT_CLI_DATA_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.internxt-cli');
+exports.INTERNXT_CLI_LOGS_DIR = node_path_1.default.join(exports.INTERNXT_CLI_DATA_DIR, 'logs');
+exports.CREDENTIALS_FILE = node_path_1.default.join(exports.INTERNXT_CLI_DATA_DIR, '.inxtcli');
+exports.DRIVE_SQLITE_FILE = node_path_1.default.join(exports.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.db');
+exports.WEBDAV_SSL_CERTS_DIR = node_path_1.default.join(exports.INTERNXT_CLI_DATA_DIR, 'certs');
+exports.WEBDAV_CONFIGS_FILE = node_path_1.default.join(exports.INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
+exports.WEBDAV_DEFAULT_HOST = '127.0.0.1';
+exports.WEBDAV_DEFAULT_PORT = '3005';
+exports.WEBDAV_DEFAULT_PROTOCOL = 'https';
+exports.WEBDAV_DEFAULT_TIMEOUT = 0;
+exports.WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
+exports.WEBDAV_DEFAULT_CUSTOM_AUTH = false;
+exports.WEBDAV_DEFAULT_DELETE_FILES_PERMANENTLY = false;

package/dist/hooks/prerun/auth_check.js

@@ -13,17 +13,26 @@ const sdk_manager_service_1 = require("../../services/sdk-manager.service");
 const auth_service_1 = require("../../services/auth.service");
 const webdav_1 = __importDefault(require("../../commands/webdav"));
 const webdav_config_1 = __importDefault(require("../../commands/webdav-config"));
-const CommandsToSkip = [whoami_1.default, login_1.default, login_legacy_1.default, logout_1.default, logs_1.default, webdav_1.default, webdav_config_1.default];
+const database_service_1 = require("../../services/database/database.service");
+const Autocomplete = {
+    name: 'autocomplete',
+    id: 'autocomplete',
+};
+const CommandsToSkip = [whoami_1.default, login_1.default, login_legacy_1.default, logout_1.default, logs_1.default, webdav_1.default, webdav_config_1.default, Autocomplete];
 const hook = async function (opts) {
     const { Command, argv } = opts;
     const jsonFlag = argv.includes('--json');
-    if (!CommandsToSkip.map((command) => command.name).includes(Command.name)) {
+    const commandsToSkipNames = CommandsToSkip.map((command) => command.name?.toLowerCase()).filter(Boolean);
+    const commandsToSkipIds = CommandsToSkip.map((command) => command.id?.toLowerCase()).filter(Boolean);
+    if (!commandsToSkipNames.includes(Command.name?.toLowerCase()) &&
+        !commandsToSkipIds.includes(Command.id?.toLowerCase())) {
         cli_utils_1.CLIUtils.doing('Checking credentials', jsonFlag);
         try {
-            const { token } = await auth_service_1.AuthService.instance.getAuthDetails();
-            sdk_manager_service_1.SdkManager.init({ token });
+            const { token, workspace } = await auth_service_1.AuthService.instance.getAuthDetails();
+            sdk_manager_service_1.SdkManager.init({ token, workspaceToken: workspace?.workspaceCredentials.token });
             cli_utils_1.CLIUtils.done(jsonFlag);
             cli_utils_1.CLIUtils.clearPreviousLine(jsonFlag);
+            await database_service_1.DatabaseService.instance.initialize();
         }
         catch (error) {
             const err = error;

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

@@ -1,9 +1,12 @@
-import { LoginCredentials } from '../types/command.types';
+import { LoginCredentials, Workspace } from '../types/command.types';
 export declare class AuthService {
     static readonly instance: AuthService;
     doLogin: (email: string, password: string, twoFactorCode?: string) => Promise<LoginCredentials>;
     is2FANeeded: (email: string) => Promise<boolean>;
     getAuthDetails: () => Promise<LoginCredentials>;
-    refreshUserToken: (oldToken: string, mnemonic: string) => Promise<LoginCredentials>;
+    refreshUserToken: (oldToken: string, mnemonic: string, privateKey: string) => Promise<LoginCredentials>;
+    refreshWorkspaceCredentials: (loginCreds: LoginCredentials) => Promise<Workspace | undefined>;
+    getCurrentWorkspace: () => Promise<Workspace | undefined>;
+    getCurrentRootFolder: () => Promise<string>;
     logout: () => Promise<void>;
 }

package/dist/services/auth.service.js

@@ -6,6 +6,7 @@ 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");
+const workspace_service_1 = require("./drive/workspace.service");
 class AuthService {
     static instance = new AuthService();
     doLogin = async (email, password, twoFactorCode) => {
@@ -18,6 +19,11 @@ class AuthService {
         const data = await authClient.loginAccess(loginDetails, crypto_service_1.CryptoService.cryptoProvider);
         const { user, newToken } = data;
         const clearMnemonic = crypto_service_1.CryptoService.instance.decryptTextWithKey(user.mnemonic, password);
+        const clearPrivateKey = Buffer.from(crypto_service_1.CryptoService.instance.decryptPrivateKey(user.keys.ecc.privateKey, password)).toString('base64');
+        user.keys.ecc.privateKey = clearPrivateKey;
+        if (user.keys?.kyber?.privateKey) {
+            user.keys.kyber.privateKey = Buffer.from(crypto_service_1.CryptoService.instance.decryptPrivateKey(user.keys.kyber.privateKey, password)).toString('base64');
+        }
         const clearUser = {
             ...user,
             mnemonic: clearMnemonic,
@@ -47,13 +53,22 @@ class AuthService {
         if (tokenDetails.expiration.expired) {
             throw new command_types_1.ExpiredCredentialsError();
         }
-        const refreshToken = tokenDetails.expiration.refreshRequired;
-        if (refreshToken) {
-            loginCreds = await this.refreshUserToken(loginCreds.token, loginCreds.user.mnemonic);
+        if (tokenDetails.expiration.refreshRequired) {
+            try {
+                loginCreds = await this.refreshUserToken(loginCreds.token, loginCreds.user.mnemonic, loginCreds.user.keys.ecc.privateKey);
+            }
+            catch (error) {
+                await config_service_1.ConfigService.instance.clearUser();
+                throw error;
+            }
         }
+        const workspaceCreds = await this.refreshWorkspaceCredentials(loginCreds);
+        loginCreds.workspace = workspaceCreds;
+        sdk_manager_service_1.SdkManager.init({ token: loginCreds.token, workspaceToken: workspaceCreds?.workspaceCredentials.token });
+        await config_service_1.ConfigService.instance.saveUser(loginCreds);
         return loginCreds;
     };
-    refreshUserToken = async (oldToken, mnemonic) => {
+    refreshUserToken = async (oldToken, mnemonic, privateKey) => {
         sdk_manager_service_1.SdkManager.init({ token: oldToken });
         const isValidMnemonic = validation_service_1.ValidationService.instance.validateMnemonic(mnemonic);
         if (!isValidMnemonic) {
@@ -66,16 +81,63 @@ class AuthService {
             user: {
                 ...newCreds.user,
                 mnemonic: mnemonic,
+                keys: {
+                    ecc: {
+                        privateKey: privateKey,
+                        publicKey: newCreds.user.keys.ecc.publicKey,
+                    },
+                    kyber: {
+                        privateKey: newCreds.user.keys.kyber.privateKey,
+                        publicKey: newCreds.user.keys.kyber.publicKey,
+                    },
+                },
             },
             token: newCreds.newToken,
         };
-        await config_service_1.ConfigService.instance.saveUser(newLoginCreds);
         return newLoginCreds;
     };
+    refreshWorkspaceCredentials = async (loginCreds) => {
+        if (loginCreds.workspace?.workspaceCredentials && loginCreds.workspace?.workspaceData) {
+            const workspaceToken = loginCreds.workspace.workspaceCredentials.token;
+            const workspaceUuid = loginCreds.workspace.workspaceCredentials.id;
+            const workspaceTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(workspaceToken);
+            if (!workspaceTokenDetails.isValid) {
+                throw new command_types_1.InvalidCredentialsError();
+            }
+            if (workspaceTokenDetails.expiration.expired) {
+                throw new command_types_1.ExpiredCredentialsError();
+            }
+            if (workspaceTokenDetails.expiration.refreshRequired) {
+                sdk_manager_service_1.SdkManager.init({ token: loginCreds.token, workspaceToken: loginCreds.workspace.workspaceCredentials.token });
+                const workspaceCredentials = await workspace_service_1.WorkspaceService.instance.getWorkspaceCredentials(workspaceUuid);
+                return {
+                    workspaceCredentials,
+                    workspaceData: loginCreds.workspace.workspaceData,
+                };
+            }
+            else {
+                return loginCreds.workspace;
+            }
+        }
+    };
+    getCurrentWorkspace = async () => {
+        const loginCreds = await config_service_1.ConfigService.instance.readUser();
+        if (!loginCreds?.token || !loginCreds?.user?.mnemonic) {
+            throw new command_types_1.MissingCredentialsError();
+        }
+        return loginCreds.workspace;
+    };
+    getCurrentRootFolder = async () => {
+        const loginCreds = await config_service_1.ConfigService.instance.readUser();
+        if (!loginCreds?.token || !loginCreds?.user?.mnemonic) {
+            throw new command_types_1.MissingCredentialsError();
+        }
+        return loginCreds.workspace?.workspaceData?.workspaceUser?.rootFolderId ?? loginCreds.user.rootFolderId;
+    };
     logout = async () => {
         try {
             const user = await config_service_1.ConfigService.instance.readUser();
-            if (!user || !user.token) {
+            if (!user?.token) {
                 return;
             }
             const authClient = sdk_manager_service_1.SdkManager.instance.getAuth();

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

@@ -1,20 +1,8 @@
 import { ConfigKeys } from '../types/config.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;
-    static readonly INTERNXT_TMP_DIR: string;
-    static readonly CREDENTIALS_FILE: string;
-    static readonly DRIVE_SQLITE_FILE: string;
-    static readonly WEBDAV_SSL_CERTS_DIR: string;
-    static readonly WEBDAV_CONFIGS_FILE: string;
-    static readonly WEBDAV_DEFAULT_HOST = "127.0.0.1";
-    static readonly WEBDAV_DEFAULT_PORT = "3005";
-    static readonly WEBDAV_DEFAULT_PROTOCOL = "https";
-    static readonly WEBDAV_DEFAULT_TIMEOUT = 0;
-    static readonly WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
     static readonly instance: ConfigService;
-    get: (key: keyof ConfigKeys) => string;
+    get: (key: keyof ConfigKeys, throwIfNotFound?: boolean) => string;
     saveUser: (loginCredentials: LoginCredentials) => Promise<void>;
     clearUser: () => Promise<void>;
     readUser: () => Promise<LoginCredentials | undefined>;

package/dist/services/config.service.js

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

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

@@ -1,4 +1,6 @@
 import { CryptoProvider } from '@internxt/sdk';
+import { LoginCredentials } from '../types/command.types';
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
 export declare class CryptoService {
     static readonly instance: CryptoService;
     static readonly cryptoProvider: CryptoProvider;
@@ -15,4 +17,7 @@ export declare class CryptoService {
     decryptTextWithKey: (encryptedText: string, secret: string) => string;
     decryptStream: (inputSlices: ReadableStream<Uint8Array>[], key: Buffer, iv: Buffer, startOffsetByte?: number) => ReadableStream<any>;
     private readonly getKeyAndIvFrom;
+    private readonly decryptWorkspaceMnemonic;
+    decryptWorkspacesMnemonic: (workspaces: WorkspaceData[], user: LoginCredentials["user"]) => Promise<WorkspaceData[]>;
+    decryptPrivateKey: (privateKey: string, password: string) => string;
 }

package/dist/services/crypto.service.js

@@ -5,6 +5,7 @@ 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");
+const lib_1 = require("@internxt/lib");
 class CryptoService {
     static instance = new CryptoService();
     static cryptoProvider = {
@@ -115,5 +116,47 @@ class CryptoService {
         const iv = md5Hashes[2];
         return { key, iv };
     };
+    decryptWorkspaceMnemonic = async (encryptionKey, user) => {
+        const privateKeyInBase64 = user.keys?.ecc?.privateKey;
+        const privateKyberKeyInBase64 = user.keys?.kyber?.privateKey;
+        if (!privateKeyInBase64) {
+            throw new Error('Missing privateKey in user keys');
+        }
+        try {
+            return await keys_service_1.KeysService.instance.hybridDecryptMessageWithPrivateKey({
+                encryptedMessageInBase64: encryptionKey,
+                privateKeyInBase64,
+                privateKyberKeyInBase64,
+            });
+        }
+        catch {
+            throw new Error('Failed to decrypt workspace mnemonic');
+        }
+    };
+    decryptWorkspacesMnemonic = async (workspaces, user) => {
+        return await Promise.all(workspaces.map(async (workspace) => {
+            return {
+                ...workspace,
+                workspaceUser: {
+                    ...workspace.workspaceUser,
+                    key: await this.decryptWorkspaceMnemonic(workspace.workspaceUser.key, user),
+                },
+            };
+        }));
+    };
+    decryptPrivateKey = (privateKey, password) => {
+        const MINIMAL_ENCRYPTED_KEY_LEN = 129;
+        if (!privateKey || privateKey.length <= MINIMAL_ENCRYPTED_KEY_LEN)
+            return '';
+        else {
+            try {
+                const result = lib_1.aes.decrypt(privateKey, password);
+                return result;
+            }
+            catch {
+                throw new Error('Private key is corrupted');
+            }
+        }
+    };
 }
 exports.CryptoService = CryptoService;

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

@@ -0,0 +1,9 @@
+import { DataSource } from 'typeorm';
+export declare class DatabaseService {
+    static readonly instance: DatabaseService;
+    dataSource: DataSource;
+    initialize: () => Promise<DataSource>;
+    destroy: () => Promise<void>;
+    clear: () => Promise<void>;
+    drop: () => Promise<void>;
+}

package/dist/services/database/database.service.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = void 0;
+const typeorm_1 = require("typeorm");
+const drive_file_model_1 = require("./drive-file/drive-file.model");
+const drive_folder_model_1 = require("./drive-folder/drive-folder.model");
+const configs_1 = require("../../constants/configs");
+const config_service_1 = require("../config.service");
+class DatabaseService {
+    static instance = new DatabaseService();
+    dataSource = new typeorm_1.DataSource(config_service_1.ConfigService.instance.get('NODE_ENV', false) === 'test'
+        ? {
+            type: 'sqljs',
+            autoSave: false,
+            logging: false,
+            synchronize: true,
+            entities: [drive_file_model_1.DriveFileModel, drive_folder_model_1.DriveFolderModel],
+        }
+        : {
+            type: 'better-sqlite3',
+            database: configs_1.DRIVE_SQLITE_FILE,
+            logging: false,
+            synchronize: true,
+            entities: [drive_file_model_1.DriveFileModel, drive_folder_model_1.DriveFolderModel],
+        });
+    initialize = () => {
+        return this.dataSource.initialize();
+    };
+    destroy = () => {
+        return this.dataSource.destroy();
+    };
+    clear = () => {
+        return this.dataSource.synchronize(true);
+    };
+    drop = () => {
+        return this.dataSource.dropDatabase();
+    };
+}
+exports.DatabaseService = DatabaseService;

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

@@ -1,13 +1,10 @@
 export interface DriveFileAttributes {
-    id: number;
-    name: string;
-    type?: string;
     uuid: string;
-    fileId: string;
-    folderId: number;
+    name: string;
+    type: string | null;
+    fileId: string | null;
     folderUuid: string;
     bucket: string;
-    relativePath: string;
     createdAt: Date;
     updatedAt: Date;
     size: number;