@internxt/cli 1.3.3 → 1.4.1

package/dist/commands/{download.js → download-file.js}

@@ -12,30 +12,112 @@ const crypto_service_1 = require("../services/crypto.service");
 const download_service_1 = require("../services/network/download.service");
 const upload_service_1 = require("../services/network/upload.service");
 const sdk_manager_service_1 = require("../services/sdk-manager.service");
-const fs_1 = require("fs");
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = require("node:fs");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
 const stream_utils_1 = require("../utils/stream.utils");
 const errors_utils_1 = require("../utils/errors.utils");
-class Download extends core_1.Command {
-    static description = 'Download and decrypts a file from Internxt Drive to a directory. The file name will be the same as the file name in your Drive';
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+class DownloadFile extends core_1.Command {
+    static args = {};
+    static description = 'Download and decrypts a file from Internxt Drive to a directory. The file name will be the same as the file name in your Drive.';
+    static aliases = ['download:file'];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
-        overwrite: core_1.Flags.boolean({ description: 'Overwrite the file if it already exists', default: false }),
+        ...cli_utils_1.CLIUtils.CommonFlags,
         id: core_1.Flags.string({
+            char: 'i',
             description: 'The id of the file to download. Use <%= config.bin %> list to view your files ids',
-            required: true,
+            required: false,
         }),
         directory: core_1.Flags.string({
-            description: 'The directory to download the file to.',
-            required: true,
+            char: 'd',
+            description: 'The directory to download the file to. Leave empty for the current folder.',
+            required: false,
+            parse: cli_utils_1.CLIUtils.parseEmpty,
+        }),
+        overwrite: core_1.Flags.boolean({
+            char: 'o',
+            description: 'Overwrite the file if it already exists',
+            default: false,
         }),
     };
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(DownloadFile);
+        const nonInteractive = flags['non-interactive'];
+        const overwrite = flags['overwrite'];
+        let downloadDirectory = await this.getDirectory(flags['directory'], nonInteractive);
+        if (downloadDirectory.trim().length === 0) {
+            downloadDirectory = '.';
+        }
+        const fileUuid = await this.getFileUuid(flags['id'], nonInteractive);
+        const driveFile = await this.getFileMetadata(fileUuid);
+        const downloadPath = await this.getDownloadPath(downloadDirectory, driveFile, overwrite);
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
+        const networkFacade = await this.prepareNetwork(user);
+        const fileWriteStream = (0, node_fs_1.createWriteStream)(downloadPath);
+        const progressBar = cli_utils_1.CLIUtils.progress({
+            format: 'Downloading file [{bar}] {percentage}%',
+            linewrap: true,
+        });
+        progressBar.start(100, 0);
+        const [executeDownload, abortable] = await networkFacade.downloadToStream(user.bucket, user.mnemonic, driveFile.fileId, stream_utils_1.StreamUtils.writeStreamToWritableStream(fileWriteStream), {
+            abortController: new AbortController(),
+            progressCallback: (progress) => {
+                progressBar.update(progress);
+            },
+        });
+        process.on('SIGINT', () => {
+            abortable.abort('SIGINT received');
+            process.exit(1);
+        });
+        await executeDownload;
+        progressBar.update(100);
+        progressBar.stop();
+        const message = `File downloaded successfully to ${downloadPath}`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return { success: true, message, file: driveFile };
+    };
+    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);
-    }
+    };
+    getFileUuid = async (fileUuidFlag, nonInteractive) => {
+        const fileUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: fileUuidFlag,
+            name: DownloadFile.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the file id you want to download?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFileUuidError(),
+        }, this.log.bind(this));
+        return fileUuid;
+    };
+    getDirectory = async (directoryFlag, nonInteractive) => {
+        const directory = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: directoryFlag,
+            name: DownloadFile.flags['directory'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'Where would you like to download the file? (Enter the local folder path on your computer)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateDirectoryExists,
+            error: new command_types_1.NotValidDirectoryError(),
+            canBeEmpty: true,
+        }, this.log.bind(this));
+        return directory;
+    };
     getFileMetadata = async (uuid) => {
         cli_utils_1.CLIUtils.doing('Getting file metadata');
         const driveFile = await drive_file_service_1.DriveFileService.instance.getFileMetadata(uuid);
@@ -45,20 +127,12 @@ class Download extends core_1.Command {
         }
         return driveFile;
     };
-    getUser = async () => {
-        const { mnemonic } = await auth_service_1.AuthService.instance.getAuthDetails();
-        const user = await auth_service_1.AuthService.instance.getUser();
-        return {
-            ...user,
-            mnemonic,
-        };
-    };
     getDownloadPath = async (downloadDirectory, driveFile, overwrite) => {
-        const filename = path_1.default.format({
+        const filename = node_path_1.default.format({
             name: driveFile.name,
             ext: `.${driveFile.type}`,
         });
-        const downloadPath = path_1.default.join(downloadDirectory, filename);
+        const downloadPath = node_path_1.default.join(downloadDirectory, filename);
         await promises_1.default.access(downloadDirectory, promises_1.default.constants.W_OK);
         try {
             const stat = await promises_1.default.stat(downloadPath);
@@ -83,37 +157,5 @@ class Download extends core_1.Command {
         cli_utils_1.CLIUtils.done();
         return networkFacade;
     };
-    async run() {
-        const { flags } = await this.parse(Download);
-        const { directory: downloadDirectory, id: fileUuid, overwrite } = flags;
-        const directoryStat = await promises_1.default.stat(downloadDirectory);
-        if (!directoryStat.isDirectory()) {
-            throw new Error('The directory provided is not a directory');
-        }
-        const driveFile = await this.getFileMetadata(fileUuid);
-        const downloadPath = await this.getDownloadPath(downloadDirectory, driveFile, overwrite);
-        const user = await this.getUser();
-        const networkFacade = await this.prepareNetwork(user);
-        const fileWriteStream = (0, fs_1.createWriteStream)(downloadPath);
-        const progressBar = core_1.ux.progress({
-            format: 'Downloading file [{bar}] {percentage}%',
-            linewrap: true,
-        });
-        progressBar.start(100, 0);
-        const [executeDownload, abortable] = await networkFacade.downloadToStream(user.bucket, user.mnemonic, driveFile.fileId, stream_utils_1.StreamUtils.writeStreamToWritableStream(fileWriteStream), {
-            abortController: new AbortController(),
-            progressCallback: (progress) => {
-                progressBar.update(progress);
-            },
-        });
-        process.on('SIGINT', () => {
-            abortable.abort('SIGINT received');
-            process.exit(1);
-        });
-        await executeDownload;
-        progressBar.update(100);
-        progressBar.stop();
-        cli_utils_1.CLIUtils.success(`File downloaded successfully to ${downloadPath}`);
-    }
 }
-exports.default = Download;
+exports.default = DownloadFile;

package/dist/commands/list.d.ts

@@ -2,21 +2,21 @@ import { Command } from '@oclif/core';
 export default class List extends Command {
     static readonly args: {};
     static readonly description = "Lists the content of a folder id.";
+    static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {
-        columns: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-        csv: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        filter: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-        'no-header': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        'no-truncate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-        sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-    getFolderUuid: (folderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    getFolderUuidInteractively: () => Promise<string>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        list: {
+            folders: import("@internxt/sdk/dist/drive/storage/types").FetchPaginatedFolder[];
+            files: import("@internxt/sdk/dist/drive/storage/types").FetchPaginatedFile[];
+        };
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getFolderUuid;
 }

package/dist/commands/list.js

@@ -11,18 +11,24 @@ const errors_utils_1 = require("../utils/errors.utils");
 class List extends core_1.Command {
     static args = {};
     static description = 'Lists the content of a folder id.';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         ...cli_utils_1.CLIUtils.CommonFlags,
         id: core_1.Flags.string({
-            char: 'f',
+            char: 'i',
             description: 'The folder id to list. Leave empty for the root folder.',
             required: false,
             parse: cli_utils_1.CLIUtils.parseEmpty,
         }),
-        ...core_1.ux.table.flags(),
+        extended: core_1.Flags.boolean({
+            char: 'e',
+            description: 'Displays additional information in the list.',
+            required: false,
+        }),
     };
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const { flags } = await this.parse(List);
         const nonInteractive = flags['non-interactive'];
         const userCredentials = await config_service_1.ConfigService.instance.readUser();
@@ -30,95 +36,61 @@ class List extends core_1.Command {
             throw new command_types_1.MissingCredentialsError();
         let folderUuid = await this.getFolderUuid(flags['id'], nonInteractive);
         if (folderUuid.trim().length === 0) {
-            folderUuid = userCredentials.root_folder_uuid;
+            folderUuid = userCredentials.user.rootFolderId;
         }
         const { folders, files } = await drive_folder_service_1.DriveFolderService.instance.getFolderContent(folderUuid);
         const allItems = [
             ...folders.map((folder) => {
                 return {
-                    isFolder: true,
-                    plainName: folder.plainName,
-                    uuid: folder.uuid,
-                    type: '',
-                    size: BigInt(0),
-                    updatedAt: folder.updatedAt,
+                    type: 'folder',
+                    name: folder.plainName,
+                    id: folder.uuid,
+                    size: '-',
+                    modified: format_utils_1.FormatUtils.formatDate(folder.updatedAt),
                 };
             }),
             ...files.map((file) => {
                 return {
-                    isFolder: false,
-                    plainName: file.plainName,
-                    uuid: file.uuid,
-                    type: file.type,
-                    size: file.size,
-                    updatedAt: file.updatedAt,
+                    type: 'file',
+                    name: file.type && file.type.length > 0 ? `${file.plainName}.${file.type}` : file.plainName,
+                    id: file.uuid,
+                    size: format_utils_1.FormatUtils.humanFileSize(Number(file.size)),
+                    modified: format_utils_1.FormatUtils.formatDate(file.updatedAt),
                 };
             }),
         ];
-        core_1.ux.table(allItems, {
-            type: {
-                header: 'Type',
-                get: (row) => (row.isFolder ? 'folder' : 'file'),
-            },
-            name: {
-                header: 'Name',
-                get: (row) => (row.isFolder ? row.plainName : `${row.plainName}.${row.type}`),
-            },
-            updatedAt: {
-                header: 'Modified',
-                get: (row) => {
-                    if (flags.output) {
-                        return row.updatedAt;
-                    }
-                    else {
-                        return format_utils_1.FormatUtils.formatDate(row.updatedAt);
-                    }
-                },
-                extended: true,
-            },
-            size: {
-                header: 'Size',
-                get: (row) => {
-                    if (flags.output) {
-                        return row.isFolder ? '0' : row.size;
-                    }
-                    else {
-                        return row.isFolder ? '' : format_utils_1.FormatUtils.humanFileSize(Number(row.size));
-                    }
-                },
-                extended: true,
-            },
-            uuid: {
-                header: 'ID',
-                get: (row) => row.uuid,
-            },
-        }, {
-            printLine: this.log.bind(this),
-            ...flags,
-        });
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+        const headers = [
+            { value: 'type', alias: 'Type' },
+            { value: 'name', alias: 'Name' },
+            { value: 'id', alias: 'Id' },
+        ];
+        if (flags.extended) {
+            headers.push({ value: 'modified', alias: 'Modified' }, { value: 'size', alias: 'Size' });
+        }
+        cli_utils_1.CLIUtils.table(this.log.bind(this), headers, allItems);
+        return { success: true, list: { folders, files } };
+    };
+    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);
-    }
+    };
     getFolderUuid = async (folderUuidFlag, nonInteractive) => {
-        let folderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+        const folderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: folderUuidFlag,
             name: List.flags['id'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the folder id you want to list? (leave empty for the root folder)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
             error: new command_types_1.NotValidFolderUuidError(),
             canBeEmpty: true,
-        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
-        if (!folderUuid) {
-            folderUuid = (await this.getFolderUuidInteractively()).trim();
-        }
+        }, this.log.bind(this));
         return folderUuid;
     };
-    getFolderUuidInteractively = () => {
-        return cli_utils_1.CLIUtils.prompt({
-            message: 'What is the folder id you want to list? (leave empty for the root folder)',
-            options: { required: false },
-        });
-    };
 }
 exports.default = List;

package/dist/commands/login.d.ts

@@ -2,6 +2,7 @@ import { Command } from '@oclif/core';
 export default class Login extends Command {
     static readonly args: {};
     static readonly description = "Logs into an Internxt account. If the account is two-factor protected, then an extra code will be required.";
+    static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {
         email: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
@@ -9,13 +10,14 @@ export default class Login extends Command {
         twofactor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-    getEmail: (emailFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    getPassword: (passwordFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    getTwoFactorCode: (twoFactorFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
-    private static readonly MAX_ATTEMPTS;
-    getEmailInteractively: () => Promise<string>;
-    getPasswordInteractively: () => Promise<string>;
-    getTwoFactorCodeInteractively: () => Promise<string>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        login: import("../types/command.types").LoginCredentials;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    private getEmail;
+    private getPassword;
+    private getTwoFactorCode;
 }

package/dist/commands/login.js

@@ -7,13 +7,12 @@ const config_service_1 = require("../services/config.service");
 const validation_service_1 = require("../services/validation.service");
 const cli_utils_1 = require("../utils/cli.utils");
 const errors_utils_1 = require("../utils/errors.utils");
-const drive_folder_service_1 = require("../services/drive/drive-folder.service");
 const sdk_manager_service_1 = require("../services/sdk-manager.service");
 const drive_database_manager_service_1 = require("../services/database/drive-database-manager.service");
-const analytics_service_1 = require("../services/analytics.service");
 class Login extends core_1.Command {
     static args = {};
     static description = 'Logs into an Internxt account. If the account is two-factor protected, then an extra code will be required.';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         ...cli_utils_1.CLIUtils.CommonFlags,
@@ -40,7 +39,8 @@ class Login extends core_1.Command {
             helpValue: '123456',
         }),
     };
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const { flags } = await this.parse(Login);
         const nonInteractive = flags['non-interactive'];
         const email = await this.getEmail(flags['email'], nonInteractive);
@@ -55,72 +55,69 @@ class Login extends core_1.Command {
             token: loginCredentials.token,
             newToken: loginCredentials.newToken,
         });
-        const rootMeta = await drive_folder_service_1.DriveFolderService.instance.getFolderMetaById(loginCredentials.user.root_folder_id);
-        await config_service_1.ConfigService.instance.saveUser(Object.assign(loginCredentials, { root_folder_uuid: rootMeta.uuid }));
+        await config_service_1.ConfigService.instance.saveUser(loginCredentials);
         await drive_database_manager_service_1.DriveDatabaseManager.init();
         await drive_database_manager_service_1.DriveDatabaseManager.clean();
-        analytics_service_1.AnalyticsService.instance.track('CLILogin', { app: 'internxt-cli', userId: loginCredentials.user.uuid });
-        cli_utils_1.CLIUtils.success(`Succesfully logged in to: ${loginCredentials.user.email} `);
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+        const message = `Succesfully logged in to: ${loginCredentials.user.email}`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+        return {
+            success: true,
+            message,
+            login: loginCredentials,
+        };
+    };
+    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);
-    }
+    };
     getEmail = async (emailFlag, nonInteractive) => {
-        let email = cli_utils_1.CLIUtils.getValueFromFlag({
+        const email = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: emailFlag,
             name: Login.flags['email'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is your email?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateEmail,
             error: new command_types_1.NotValidEmailError(),
-        }, nonInteractive, validation_service_1.ValidationService.instance.validateEmail);
-        if (!email) {
-            email = await this.getEmailInteractively();
-        }
+        }, this.log.bind(this));
         return email;
     };
     getPassword = async (passwordFlag, nonInteractive) => {
-        let password = cli_utils_1.CLIUtils.getValueFromFlag({
+        const password = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: passwordFlag,
             name: Login.flags['password'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is your password?',
+                options: { type: 'password' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateStringIsNotEmpty,
             error: new command_types_1.EmptyPasswordError(),
-        }, nonInteractive, (password) => password.trim().length > 0);
-        if (!password) {
-            password = await this.getPasswordInteractively();
-        }
+        }, this.log.bind(this));
         return password;
     };
     getTwoFactorCode = async (twoFactorFlag, nonInteractive) => {
-        let twoFactor = cli_utils_1.CLIUtils.getValueFromFlag({
+        const twoFactor = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: twoFactorFlag,
             name: Login.flags['twofactor'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is your two-factor token?',
+                options: { type: 'mask' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validate2FA,
             error: new command_types_1.NotValidTwoFactorCodeError(),
-        }, nonInteractive, validation_service_1.ValidationService.instance.validate2FA);
-        if (!twoFactor) {
-            twoFactor = await this.getTwoFactorCodeInteractively();
-        }
+        }, this.log.bind(this));
         return twoFactor;
     };
-    static MAX_ATTEMPTS = 3;
-    getEmailInteractively = () => {
-        return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is your email?',
-            options: { required: true },
-            error: new command_types_1.NotValidEmailError(),
-        }, Login.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateEmail);
-    };
-    getPasswordInteractively = () => {
-        return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is your password?',
-            options: { type: 'hide', required: true },
-            error: new command_types_1.EmptyPasswordError(),
-        }, Login.MAX_ATTEMPTS, (password) => password.trim().length > 0);
-    };
-    getTwoFactorCodeInteractively = () => {
-        return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is your two-factor token?',
-            options: { type: 'mask', required: true },
-            error: new command_types_1.NotValidTwoFactorCodeError(),
-        }, Login.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validate2FA);
-    };
 }
 exports.default = Login;

package/dist/commands/logout.d.ts

@@ -2,8 +2,13 @@ import { Command } from '@oclif/core';
 export default class Logout extends Command {
     static readonly args: {};
     static readonly description = "Logs out the current internxt user that is logged into the Internxt CLI.";
+    static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {};
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    catch: (error: Error) => Promise<never>;
 }

package/dist/commands/logout.js

@@ -8,23 +8,29 @@ const drive_database_manager_service_1 = require("../services/database/drive-dat
 class Logout extends core_1.Command {
     static args = {};
     static description = 'Logs out the current internxt user that is logged into the Internxt CLI.';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {};
-    async run() {
+    static enableJsonFlag = true;
+    run = async () => {
         const user = await config_service_1.ConfigService.instance.readUser();
         if (user) {
             await config_service_1.ConfigService.instance.clearUser();
             await drive_database_manager_service_1.DriveDatabaseManager.clean();
-            cli_utils_1.CLIUtils.success('User logged out correctly');
+            const message = 'User logged out successfully.';
+            cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+            return { success: true, message };
         }
         else {
-            cli_utils_1.CLIUtils.error('You are not logged in');
+            const message = 'No user is currently logged in.';
+            cli_utils_1.CLIUtils.error(this.log.bind(this), message);
+            return { success: false, message };
         }
-    }
-    async catch(error) {
-        errors_utils_1.ErrorUtils.report(error, { command: this.id });
-        cli_utils_1.CLIUtils.error(error.message);
+    };
+    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 = Logout;

package/dist/commands/logs.d.ts

@@ -1,6 +1,15 @@
 import { Command } from '@oclif/core';
 export default class Logs extends Command {
+    static readonly args: {};
     static readonly description = "Displays the Internxt CLI logs directory path";
-    static examples: string[];
-    run(): Promise<void>;
+    static readonly aliases: never[];
+    static readonly examples: string[];
+    static readonly flags: {};
+    static readonly enableJsonFlag = true;
+    run: () => Promise<{
+        success: boolean;
+        message: string;
+        path: string;
+    }>;
+    catch: (error: Error) => Promise<never>;
 }

package/dist/commands/logs.js

@@ -2,11 +2,24 @@
 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");
 class Logs extends core_1.Command {
+    static args = {};
     static description = 'Displays the Internxt CLI logs directory path';
+    static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
-    async run() {
-        this.log(`Internxt CLI logs are at ${config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR}`);
-    }
+    static flags = {};
+    static enableJsonFlag = true;
+    run = async () => {
+        const message = `Internxt CLI logs are located at ${config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR}`;
+        cli_utils_1.CLIUtils.log(this.log.bind(this), message);
+        return { success: true, message, path: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR };
+    };
+    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 = Logs;