@internxt/cli 1.3.3 → 1.4.2

package/dist/commands/upload-file.js

@@ -0,0 +1,140 @@
+"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 promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const network_facade_service_1 = require("../services/network/network-facade.service");
+const sdk_manager_service_1 = require("../services/sdk-manager.service");
+const auth_service_1 = require("../services/auth.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const config_service_1 = require("../services/config.service");
+const node_path_1 = __importDefault(require("node:path"));
+const drive_file_service_1 = require("../services/drive/drive-file.service");
+const upload_service_1 = require("../services/network/upload.service");
+const crypto_service_1 = require("../services/crypto.service");
+const download_service_1 = require("../services/network/download.service");
+const errors_utils_1 = require("../utils/errors.utils");
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
+class UploadFile extends core_1.Command {
+    static args = {};
+    static description = 'Upload a file to Internxt Drive';
+    static aliases = ['upload:file'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        file: core_1.Flags.string({
+            char: 'f',
+            description: 'The path to the file on your system.',
+            required: false,
+        }),
+        destination: core_1.Flags.string({
+            char: 'i',
+            description: 'The folder id where the file is going to be uploaded to. Leave empty for the root folder.',
+            required: false,
+            parse: cli_utils_1.CLIUtils.parseEmpty,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(UploadFile);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const filePath = await this.getFilePath(flags['file'], nonInteractive);
+        const stats = await (0, promises_1.stat)(filePath);
+        if (!stats.size) {
+            throw new Error('The file is empty. Uploading empty files is not allowed.');
+        }
+        let destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
+        if (destinationFolderUuid.trim().length === 0) {
+            destinationFolderUuid = userCredentials.user.rootFolderId;
+        }
+        cli_utils_1.CLIUtils.doing('Preparing Network');
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
+        const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
+            user: user.bridgeUser,
+            pass: user.userId,
+        });
+        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, upload_service_1.UploadService.instance, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
+        cli_utils_1.CLIUtils.done();
+        const timer = cli_utils_1.CLIUtils.timer();
+        const fileStream = (0, node_fs_1.createReadStream)(filePath);
+        const progressBar = cli_utils_1.CLIUtils.progress({
+            format: 'Uploading file [{bar}] {percentage}%',
+            linewrap: true,
+        });
+        progressBar.start(1, 0);
+        const [uploadPromise, abortable] = await networkFacade.uploadFromStream(user.bucket, user.mnemonic, stats.size, fileStream, {
+            progressCallback: (progress) => {
+                progressBar.update(progress);
+            },
+        });
+        process.on('SIGINT', () => {
+            abortable.abort('SIGINT received');
+            process.exit(1);
+        });
+        const uploadResult = await uploadPromise;
+        progressBar.stop();
+        const fileInfo = node_path_1.default.parse(filePath);
+        const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
+            plain_name: fileInfo.name,
+            type: fileInfo.ext.replaceAll('.', ''),
+            size: stats.size,
+            folder_id: destinationFolderUuid,
+            id: uploadResult.fileId,
+            bucket: user.bucket,
+            encrypt_version: types_1.EncryptionVersion.Aes03,
+            name: '',
+        });
+        const uploadTime = timer.stop();
+        this.log('\n');
+        const message = `File uploaded in ${uploadTime}ms, view it at ${config_service_1.ConfigService.instance.get('DRIVE_URL')}/file/${createdDriveFile.uuid}`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, file: createdDriveFile };
+    };
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        this.exit(1);
+    };
+    getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
+        const destinationFolderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: destinationFolderUuidFlag,
+            name: UploadFile.flags['destination'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the destination folder id? (leave empty for the root folder)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, this.log.bind(this));
+        return destinationFolderUuid;
+    };
+    getFilePath = async (fileFlag, nonInteractive) => {
+        const filePath = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: fileFlag,
+            name: UploadFile.flags['file'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the path to the file on your computer?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateFileExists,
+            error: new command_types_1.NotValidDirectoryError(),
+        }, this.log.bind(this));
+        return filePath;
+    };
+}
+exports.default = UploadFile;

package/dist/commands/webdav-config.d.ts

@@ -1,17 +1,19 @@
 import { Command } from '@oclif/core';
 export default class WebDAVConfig extends Command {
+    static readonly args: {};
     static readonly description = "Edit the configuration of the Internxt CLI WebDav server as the port or the protocol.";
-    static readonly args: {
-        action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
-    };
+    static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {
         port: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        https: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        http: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-    private static readonly MAX_ATTEMPTS;
-    getWebDAVPort: (webdavPortFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    getNewWebDAVPortInteractively: () => Promise<string>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        config: import("../types/command.types").WebdavConfig;
+    }>;
+    catch: (error: Error) => Promise<never>;
 }

package/dist/commands/webdav-config.js

@@ -7,85 +7,59 @@ const errors_utils_1 = require("../utils/errors.utils");
 const command_types_1 = require("../types/command.types");
 const validation_service_1 = require("../services/validation.service");
 class WebDAVConfig extends core_1.Command {
+    static args = {};
     static description = 'Edit the configuration of the Internxt CLI WebDav server as the port or the protocol.';
-    static args = {
-        action: core_1.Args.string({
-            required: true,
-            options: ['set-http', 'set-https', 'change-port'],
-        }),
-    };
-    static examples = [
-        '<%= config.bin %> <%= command.id %> set-http',
-        '<%= config.bin %> <%= command.id %> set-https',
-        '<%= config.bin %> <%= command.id %> change-port',
-    ];
+    static aliases = [];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
-        ...cli_utils_1.CLIUtils.CommonFlags,
         port: core_1.Flags.string({
             char: 'p',
-            description: 'The new port that the WebDAV server is going to be have.',
+            description: 'The new port for the WebDAV server.',
+            required: false,
+        }),
+        https: core_1.Flags.boolean({
+            char: 's',
+            description: 'Configures the WebDAV server to use HTTPS with self-signed certificates.',
+            required: false,
+            exclusive: ['http'],
+        }),
+        http: core_1.Flags.boolean({
+            char: 'h',
+            description: 'Configures the WebDAV server to use insecure plain HTTP.',
             required: false,
+            exclusive: ['https'],
         }),
     };
-    async run() {
-        const { args, flags } = await this.parse(WebDAVConfig);
-        const nonInteractive = flags['non-interactive'];
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(WebDAVConfig);
         const webdavConfig = await config_service_1.ConfigService.instance.readWebdavConfig();
-        if (args.action !== 'change-port' && flags['port']) {
-            cli_utils_1.CLIUtils.warning('The port flag will be ignored; it can only be used with the "change-port" action.');
-        }
-        switch (args.action) {
-            case 'set-http': {
-                await config_service_1.ConfigService.instance.saveWebdavConfig({
-                    ...webdavConfig,
-                    protocol: 'http',
-                });
-                cli_utils_1.CLIUtils.success('On the next start, the WebDAV server will use HTTP.');
-                break;
-            }
-            case 'set-https': {
-                await config_service_1.ConfigService.instance.saveWebdavConfig({
-                    ...webdavConfig,
-                    protocol: 'https',
-                });
-                cli_utils_1.CLIUtils.success('On the next start, the WebDAV server will use HTTPS.');
-                break;
+        const port = flags['port'];
+        if (port) {
+            if (validation_service_1.ValidationService.instance.validateTCPIntegerPort(port)) {
+                webdavConfig['port'] = port;
             }
-            case 'change-port': {
-                const newPort = await this.getWebDAVPort(flags['port'], nonInteractive);
-                await config_service_1.ConfigService.instance.saveWebdavConfig({
-                    ...webdavConfig,
-                    port: newPort,
-                });
-                cli_utils_1.CLIUtils.success('For the next start, the Webdav server will be served at the new port: ' + newPort);
-                break;
+            else {
+                throw new command_types_1.NotValidPortError();
             }
         }
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
-        this.exit(1);
-    }
-    static MAX_ATTEMPTS = 3;
-    getWebDAVPort = async (webdavPortFlag, nonInteractive) => {
-        let port = cli_utils_1.CLIUtils.getValueFromFlag({
-            value: webdavPortFlag,
-            name: WebDAVConfig.flags['port'].name,
-            error: new command_types_1.NotValidPortError(),
-            canBeEmpty: true,
-        }, nonInteractive, (port) => validation_service_1.ValidationService.instance.validateTCPIntegerPort(port));
-        if (!port) {
-            port = (await this.getNewWebDAVPortInteractively()).trim();
+        const http = flags['http'];
+        if (http) {
+            webdavConfig['protocol'] = 'http';
         }
-        return port;
+        const https = flags['https'];
+        if (https) {
+            webdavConfig['protocol'] = 'https';
+        }
+        await config_service_1.ConfigService.instance.saveWebdavConfig(webdavConfig);
+        const message = `On the next start, the WebDAV server will use the next config: ${JSON.stringify(webdavConfig)}`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, config: webdavConfig };
     };
-    getNewWebDAVPortInteractively = () => {
-        return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is the new WebDAV server port?',
-            options: { required: false },
-            error: new command_types_1.NotValidPortError(),
-        }, WebDAVConfig.MAX_ATTEMPTS, (port) => validation_service_1.ValidationService.instance.validateTCPIntegerPort(port));
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        this.exit(1);
     };
 }
 exports.default = WebDAVConfig;

package/dist/commands/webdav.d.ts

@@ -1,14 +1,21 @@
 import { Command } from '@oclif/core';
 export default class Webdav extends Command {
-    static readonly description = "Enable, disable, restart or get the status of the Internxt CLI WebDav server";
-    static examples: string[];
-    static flags: {};
-    static args: {
+    static readonly args: {
         action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
-    enableWebDav(): Promise<void>;
-    disableWebDav(): Promise<void>;
-    restartWebDav(): Promise<void>;
-    webDAVStatus(): Promise<void>;
-    run(): Promise<void>;
+    static readonly description = "Enable, disable, restart or get the status of the Internxt CLI WebDav server";
+    static readonly aliases: never[];
+    static readonly examples: string[];
+    static readonly flags: {};
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        action: string;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private enableWebDav;
+    private disableWebDav;
+    private restartWebDav;
+    private webDAVStatus;
 }

package/dist/commands/webdav.js

@@ -4,11 +4,17 @@ const core_1 = require("@oclif/core");
 const pm2_utils_1 = require("../utils/pm2.utils");
 const cli_utils_1 = require("../utils/cli.utils");
 const config_service_1 = require("../services/config.service");
-const analytics_service_1 = require("../services/analytics.service");
-const auth_service_1 = require("../services/auth.service");
 const drive_database_manager_service_1 = require("../services/database/drive-database-manager.service");
+const errors_utils_1 = require("../utils/errors.utils");
 class Webdav extends core_1.Command {
+    static args = {
+        action: core_1.Args.string({
+            required: true,
+            options: ['enable', 'disable', 'restart', 'status'],
+        }),
+    };
     static description = 'Enable, disable, restart or get the status of the Internxt CLI WebDav server';
+    static aliases = [];
     static examples = [
         '<%= config.bin %> <%= command.id %> enable',
         '<%= config.bin %> <%= command.id %> disable',
@@ -16,91 +22,101 @@ class Webdav extends core_1.Command {
         '<%= config.bin %> <%= command.id %> status',
     ];
     static flags = {};
-    static args = {
-        action: core_1.Args.string({
-            required: true,
-            options: ['enable', 'disable', 'restart', 'status'],
-        }),
+    static enableJsonFlag = true;
+    run = async () => {
+        const { args } = await this.parse(Webdav);
+        let message = '';
+        let success = true;
+        await pm2_utils_1.PM2Utils.connect();
+        switch (args.action) {
+            case 'enable': {
+                message = await this.enableWebDav();
+                break;
+            }
+            case 'disable': {
+                message = await this.disableWebDav();
+                break;
+            }
+            case 'restart': {
+                message = await this.restartWebDav();
+                break;
+            }
+            case 'status': {
+                message = await this.webDAVStatus();
+                break;
+            }
+            default: {
+                success = false;
+                message = `Expected one of this command actions: ${Webdav.args.action.options}`;
+                break;
+            }
+        }
+        pm2_utils_1.PM2Utils.disconnect();
+        return { success, message, action: args.action };
     };
-    async enableWebDav() {
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        if (error instanceof Error) {
+            cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        }
+        else {
+            cli_utils_1.CLIUtils.error(this.log.bind(this), JSON.stringify(error));
+        }
+        this.exit(1);
+    };
+    enableWebDav = async () => {
         cli_utils_1.CLIUtils.doing('Starting Internxt WebDav server...');
         await drive_database_manager_service_1.DriveDatabaseManager.clean();
-        await pm2_utils_1.PM2Utils.connect();
         await pm2_utils_1.PM2Utils.killWebDavServer();
         await pm2_utils_1.PM2Utils.startWebDavServer();
         cli_utils_1.CLIUtils.done();
         const { status } = await pm2_utils_1.PM2Utils.webdavServerStatus();
         const webdavConfigs = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (status === 'online') {
-            core_1.ux.log(`\nWebDav server status: ${core_1.ux.colorize('green', 'online')}\n`);
-            cli_utils_1.CLIUtils.success(`Internxt WebDav server started successfully at ${webdavConfigs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${webdavConfigs.port}`);
-            core_1.ux.log(`\n[If the above URL is not working, the WebDAV server can be accessed directly via your localhost IP at: ${webdavConfigs.protocol}://127.0.0.1:${webdavConfigs.port} ]\n`);
-            const authDetails = await auth_service_1.AuthService.instance.getAuthDetails();
-            await analytics_service_1.AnalyticsService.instance.track('WebDAVEnabled', { app: 'internxt-cli', userId: authDetails.user.uuid });
+            const message = `Internxt WebDav server started successfully at ${webdavConfigs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${webdavConfigs.port}`;
+            cli_utils_1.CLIUtils.log(this.log.bind(this), `\nWebDav server status: ${core_1.ux.colorize('green', 'online')}\n`);
+            cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+            cli_utils_1.CLIUtils.log(this.log.bind(this), `\n[If the above URL is not working, the WebDAV server can be accessed directly via your localhost IP at: ${webdavConfigs.protocol}://127.0.0.1:${webdavConfigs.port} ]\n`);
+            return message;
         }
         else {
-            core_1.ux.log(`WebDav server status: ${core_1.ux.colorize('red', status)}`);
+            const message = `WebDav server status: ${core_1.ux.colorize('red', status)}`;
+            cli_utils_1.CLIUtils.log(this.log.bind(this), message);
+            return message;
         }
-    }
-    async disableWebDav() {
+    };
+    disableWebDav = async () => {
         cli_utils_1.CLIUtils.doing('Stopping Internxt WebDav server...');
-        await pm2_utils_1.PM2Utils.connect();
         await pm2_utils_1.PM2Utils.killWebDavServer();
         cli_utils_1.CLIUtils.done();
-        cli_utils_1.CLIUtils.success('Internxt WebDav server stopped successfully');
-    }
-    async restartWebDav() {
+        const message = 'Internxt WebDav server stopped successfully';
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return message;
+    };
+    restartWebDav = async () => {
         cli_utils_1.CLIUtils.doing('Restarting Internxt WebDav server...');
         await drive_database_manager_service_1.DriveDatabaseManager.clean();
-        await pm2_utils_1.PM2Utils.connect();
         const { status } = await pm2_utils_1.PM2Utils.webdavServerStatus();
         if (status === 'online') {
             await pm2_utils_1.PM2Utils.killWebDavServer();
             await pm2_utils_1.PM2Utils.startWebDavServer();
             cli_utils_1.CLIUtils.done();
-            cli_utils_1.CLIUtils.success('Internxt WebDav server restarted successfully');
+            const message = 'Internxt WebDav server restarted successfully';
+            cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+            return message;
         }
         else {
             cli_utils_1.CLIUtils.done();
-            cli_utils_1.CLIUtils.error('Internxt WebDav server is not running, cannot restart');
+            const message = 'Internxt WebDav server is not running, it wont be restarted';
+            cli_utils_1.CLIUtils.warning(this.log.bind(this), message);
+            return message;
         }
-    }
-    async webDAVStatus() {
-        await pm2_utils_1.PM2Utils.connect();
+    };
+    webDAVStatus = async () => {
         const { status } = await pm2_utils_1.PM2Utils.webdavServerStatus();
-        this.log(`Internxt WebDAV server status: ${status}`);
-    }
-    async run() {
-        const { args } = await this.parse(Webdav);
-        try {
-            switch (args.action) {
-                case 'enable': {
-                    await this.enableWebDav();
-                    break;
-                }
-                case 'disable': {
-                    await this.disableWebDav();
-                    break;
-                }
-                case 'restart': {
-                    await this.restartWebDav();
-                    break;
-                }
-                case 'status': {
-                    await this.webDAVStatus();
-                    break;
-                }
-            }
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                cli_utils_1.CLIUtils.error(error.message);
-            }
-            else {
-                cli_utils_1.CLIUtils.error(JSON.stringify(error));
-            }
-        }
-        this.exit(0);
-    }
+        const message = `Internxt WebDAV server status: ${status}`;
+        cli_utils_1.CLIUtils.log(this.log.bind(this), message);
+        return message;
+    };
 }
 exports.default = Webdav;

package/dist/commands/whoami.d.ts

@@ -1,9 +1,21 @@
 import { Command } from '@oclif/core';
+import { LoginCredentials } from '../types/command.types';
 export default class Whoami extends Command {
     static readonly args: {};
     static readonly description = "Display the current user logged into the Internxt CLI.";
+    static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {};
-    catch(error: Error): Promise<void>;
-    run(): Promise<void>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        login?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        login: LoginCredentials;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private checkUserAndTokens;
 }

package/dist/commands/whoami.js

@@ -1,27 +1,56 @@
 "use strict";
 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 errors_utils_1 = require("../utils/errors.utils");
+const config_service_1 = require("../services/config.service");
+const validation_service_1 = require("../services/validation.service");
+const drive_database_manager_service_1 = require("../services/database/drive-database-manager.service");
 class Whoami extends core_1.Command {
     static args = {};
     static description = 'Display the current user logged into the Internxt CLI.';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {};
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
-        this.exit(1);
-    }
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const userCredentials = await config_service_1.ConfigService.instance.readUser();
-        if (userCredentials?.user?.email) {
-            cli_utils_1.CLIUtils.success(`You are logged in with: ${userCredentials.user.email}`);
+        if (!userCredentials) {
+            const message = 'You are not logged in.';
+            cli_utils_1.CLIUtils.error(this.log.bind(this), message);
+            return { success: false, message };
         }
         else {
-            cli_utils_1.CLIUtils.error('You are not logged in');
+            const validCreds = this.checkUserAndTokens(userCredentials);
+            if (!validCreds) {
+                const message = 'Your session has expired. You have been logged out. Please log in again.';
+                await config_service_1.ConfigService.instance.clearUser();
+                await drive_database_manager_service_1.DriveDatabaseManager.clean();
+                cli_utils_1.CLIUtils.error(this.log.bind(this), message);
+                return { success: false, message };
+            }
+            else {
+                const message = `You are logged in as: ${userCredentials.user.email}.`;
+                cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+                return { success: true, message, login: userCredentials };
+            }
+        }
+    };
+    catch = async (error) => {
+        errors_utils_1.ErrorUtils.report(this.error.bind(this), error, { command: this.id });
+        cli_utils_1.CLIUtils.error(this.log.bind(this), error.message);
+        this.exit(1);
+    };
+    checkUserAndTokens = (loginCreds) => {
+        if (!(loginCreds?.newToken && loginCreds?.token && loginCreds?.user?.mnemonic)) {
+            return false;
         }
-    }
+        const oldTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.token);
+        const newTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.newToken);
+        const goodMnemonic = validation_service_1.ValidationService.instance.validateMnemonic(loginCreds.user.mnemonic);
+        const goodToken = oldTokenDetails.isValid && !oldTokenDetails.expiration.expired;
+        const goodNewToken = newTokenDetails.isValid && !newTokenDetails.expiration.expired;
+        return goodToken && goodNewToken && goodMnemonic;
+    };
 }
 exports.default = Whoami;

package/dist/hooks/prerun/auth_check.js

@@ -10,7 +10,6 @@ const logs_1 = __importDefault(require("../../commands/logs"));
 const cli_utils_1 = require("../../utils/cli.utils");
 const sdk_manager_service_1 = require("../../services/sdk-manager.service");
 const auth_service_1 = require("../../services/auth.service");
-const command_types_1 = require("../../types/command.types");
 const webdav_1 = __importDefault(require("../../commands/webdav"));
 const webdav_config_1 = __importDefault(require("../../commands/webdav-config"));
 const CommandsToSkip = [whoami_1.default, login_1.default, logout_1.default, logs_1.default, webdav_1.default, webdav_config_1.default];
@@ -23,13 +22,16 @@ const hook = async function (opts) {
                 token,
                 newToken,
             });
+            cli_utils_1.CLIUtils.done();
+            cli_utils_1.CLIUtils.clearPreviousLine();
         }
         catch (error) {
-            cli_utils_1.CLIUtils.error(new command_types_1.MissingCredentialsError().message);
+            const err = error;
+            cli_utils_1.CLIUtils.done();
+            cli_utils_1.CLIUtils.clearPreviousLine();
+            cli_utils_1.CLIUtils.error(this.log.bind(this), err.message);
             opts.context.exit(1);
         }
-        cli_utils_1.CLIUtils.done();
-        cli_utils_1.CLIUtils.clearPreviousLine();
     }
 };
 exports.default = hook;

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

@@ -1,14 +1,8 @@
 import { LoginCredentials } from '../types/command.types';
-import { UserSettings } from '@internxt/sdk/dist/shared/types/userSettings';
 export declare class AuthService {
     static readonly instance: AuthService;
     doLogin: (email: string, password: string, twoFactorCode?: string) => Promise<LoginCredentials>;
     is2FANeeded: (email: string) => Promise<boolean>;
-    getUser: () => Promise<UserSettings>;
-    getAuthDetails: () => Promise<{
-        token: string;
-        newToken: string;
-        mnemonic: string;
-        user: UserSettings;
-    }>;
+    getAuthDetails: () => Promise<LoginCredentials>;
+    refreshUserTokens: (oldCreds: LoginCredentials) => Promise<LoginCredentials>;
 }