@internxt/cli 1.6.2 → 1.6.3

package/dist/commands/upload-file.js

@@ -6,7 +6,6 @@ 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 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"));
@@ -16,6 +15,8 @@ const validation_service_1 = require("../services/validation.service");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const stream_utils_1 = require("../utils/stream.utils");
 const thumbnail_utils_1 = require("../utils/thumbnail.utils");
+const thumbnail_service_1 = require("../services/thumbnail.service");
+const auth_service_1 = require("../services/auth.service");
 class UploadFile extends core_1.Command {
     static args = {};
     static description = 'Upload a file to Internxt Drive';
@@ -39,23 +40,29 @@ class UploadFile extends core_1.Command {
     run = async () => {
         const { flags } = await this.parse(UploadFile);
         const nonInteractive = flags['non-interactive'];
-        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
+        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);
         const fileInfo = node_path_1.default.parse(filePath);
         const fileType = fileInfo.ext.replaceAll('.', '');
-        const destinationFolderUuid = (await cli_utils_1.CLIUtils.getDestinationFolderUuid({
+        const reporter = this.log.bind(this);
+        const destinationFolderUuidFromFlag = await cli_utils_1.CLIUtils.getDestinationFolderUuid({
             destinationFolderUuidFlag: flags['destination'],
             destinationFlagName: UploadFile.flags['destination'].name,
             nonInteractive,
-            reporter: this.log.bind(this),
-        })) ?? user.rootFolderId;
+            reporter,
+        });
+        const destinationFolderUuid = await cli_utils_1.CLIUtils.fallbackToRootFolderIdIfEmpty(destinationFolderUuidFromFlag);
         const timings = {
             networkUpload: 0,
             driveUpload: 0,
             thumbnailUpload: 0,
         };
-        const networkFacade = cli_utils_1.CLIUtils.prepareNetwork({ loginUserDetails: user, jsonFlag: flags['json'] });
+        cli_utils_1.CLIUtils.doing('Preparing Network', flags['json']);
+        const { networkFacade, bucket } = await cli_utils_1.CLIUtils.prepareNetwork(userCredentials.user);
+        cli_utils_1.CLIUtils.done(flags['json']);
         const networkUploadTimer = cli_utils_1.CLIUtils.timer();
         const progressBar = cli_utils_1.CLIUtils.progress({
             format: 'Uploading file [{bar}] {percentage}%',
@@ -64,7 +71,7 @@ class UploadFile extends core_1.Command {
         progressBar?.start(100, 0);
         let fileId;
         let bufferStream;
-        const isThumbnailable = (0, thumbnail_utils_1.isFileThumbnailable)(fileType);
+        const isThumbnailable = thumbnail_utils_1.ThumbnailUtils.isFileThumbnailable(fileType);
         const fileSize = stats.size ?? 0;
         if (fileSize > 0) {
             const readStream = (0, node_fs_1.createReadStream)(filePath);
@@ -77,7 +84,7 @@ class UploadFile extends core_1.Command {
                 progressBar?.update(progress * 100 * 0.99);
             };
             fileId = await new Promise((resolve, reject) => {
-                const state = networkFacade.uploadFile(fileStream, fileSize, user.bucket, (err, res) => {
+                const state = networkFacade.uploadFile(fileStream, fileSize, bucket, (err, res) => {
                     if (err) {
                         return reject(err);
                     }
@@ -96,8 +103,8 @@ class UploadFile extends core_1.Command {
             type: fileType,
             size: fileSize,
             folderUuid: destinationFolderUuid,
-            fileId: fileId,
-            bucket: user.bucket,
+            fileId,
+            bucket,
             encryptVersion: types_1.EncryptionVersion.Aes03,
             creationTime: stats.birthtime?.toISOString(),
             modificationTime: stats.mtime?.toISOString(),
@@ -105,12 +112,13 @@ class UploadFile extends core_1.Command {
         timings.driveUpload = driveUploadTimer.stop();
         const thumbnailTimer = cli_utils_1.CLIUtils.timer();
         if (fileSize > 0 && isThumbnailable && bufferStream) {
-            void (0, thumbnail_utils_1.tryUploadThumbnail)({
+            await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
                 bufferStream,
                 fileType,
-                userBucket: user.bucket,
+                bucket,
                 fileUuid: createdDriveFile.uuid,
                 networkFacade,
+                size: fileSize,
             });
         }
         timings.thumbnailUpload = thumbnailTimer.stop();
@@ -118,15 +126,18 @@ class UploadFile extends core_1.Command {
         progressBar?.stop();
         const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
         const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(stats.size, timings.networkUpload);
-        this.log('\n');
-        this.log(`[PUT] Timing breakdown:\n
-      Network upload: ${cli_utils_1.CLIUtils.formatDuration(timings.networkUpload)} (${throughputMBps.toFixed(2)} MB/s)\n
-      Drive upload: ${cli_utils_1.CLIUtils.formatDuration(timings.driveUpload)}\n
-      Thumbnail: ${cli_utils_1.CLIUtils.formatDuration(timings.thumbnailUpload)}\n`);
-        this.log('\n');
+        if (flags['debug']) {
+            cli_utils_1.CLIUtils.log(reporter, '[PUT] Timing breakdown:\n' +
+                `Network upload: ${cli_utils_1.CLIUtils.formatDuration(timings.networkUpload)} (${throughputMBps.toFixed(2)} MB/s)\n` +
+                `Drive upload: ${cli_utils_1.CLIUtils.formatDuration(timings.driveUpload)}\n` +
+                `Thumbnail: ${cli_utils_1.CLIUtils.formatDuration(timings.thumbnailUpload)}\n`);
+        }
+        const workspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        const workspaceId = workspace?.workspaceData.workspace.id;
         const message = `File uploaded successfully in ${cli_utils_1.CLIUtils.formatDuration(totalTime)}, view it at ` +
-            `${config_service_1.ConfigService.instance.get('DRIVE_WEB_URL')}/file/${createdDriveFile.uuid}`;
-        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+            `${config_service_1.ConfigService.instance.get('DRIVE_WEB_URL')}/file/${createdDriveFile.uuid}` +
+            `${workspaceId ? `?workspaceid=${workspaceId}` : ''}`;
+        cli_utils_1.CLIUtils.success(reporter, message);
         return {
             success: true,
             message,
@@ -158,7 +169,7 @@ class UploadFile extends core_1.Command {
             },
         }, {
             validate: validation_service_1.ValidationService.instance.validateFileExists,
-            error: new command_types_1.NotValidDirectoryError(),
+            error: new command_types_1.NotValidFileError(),
         }, this.log.bind(this));
         return filePath;
     };

package/dist/commands/upload-folder.d.ts

@@ -8,6 +8,7 @@ export default class UploadFolder extends Command {
         folder: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         destination: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly enableJsonFlag = true;
     run: () => Promise<void>;

package/dist/commands/upload-folder.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const cli_utils_1 = require("../utils/cli.utils");
-const auth_service_1 = require("../services/auth.service");
 const validation_service_1 = require("../services/validation.service");
 const config_service_1 = require("../services/config.service");
 const upload_facade_service_1 = require("../services/network/upload/upload-facade.service");
@@ -28,15 +27,19 @@ class UploadFolder extends core_1.Command {
     };
     static enableJsonFlag = true;
     run = async () => {
-        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         const { flags } = await this.parse(UploadFolder);
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
         const localPath = await this.getFolderPath(flags['folder'], flags['non-interactive']);
-        const destinationFolderUuid = (await cli_utils_1.CLIUtils.getDestinationFolderUuid({
+        const reporter = this.log.bind(this);
+        const destinationFolderUuidFromFlag = await cli_utils_1.CLIUtils.getDestinationFolderUuid({
             destinationFolderUuidFlag: flags['destination'],
             destinationFlagName: UploadFolder.flags['destination'].name,
             nonInteractive: flags['non-interactive'],
-            reporter: this.log.bind(this),
-        })) ?? user.rootFolderId;
+            reporter,
+        });
+        const destinationFolderUuid = await cli_utils_1.CLIUtils.fallbackToRootFolderIdIfEmpty(destinationFolderUuidFromFlag);
         const progressBar = cli_utils_1.CLIUtils.progress({
             format: 'Uploading folder [{bar}] {percentage}%',
             linewrap: true,
@@ -45,11 +48,13 @@ class UploadFolder extends core_1.Command {
         const data = await upload_facade_service_1.UploadFacade.instance.uploadFolder({
             localPath,
             destinationFolderUuid,
-            loginUserDetails: user,
+            loginUserDetails: userCredentials.user,
             jsonFlag: flags['json'],
             onProgress: (progress) => {
                 progressBar?.update(progress.percentage);
             },
+            debugMode: flags['debug'],
+            reporter,
         });
         progressBar?.update(100);
         progressBar?.stop();

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

@@ -11,12 +11,30 @@ export default class WebDAVConfig extends Command {
         http: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         timeout: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         createFullPath: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        customAuth: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        username: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        password: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        deleteFilesPermanently: 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;
-        config: import("../types/command.types").WebdavConfig;
+        config: {
+            password: undefined;
+            host: string;
+            port: string;
+            protocol: "http" | "https";
+            timeoutMinutes: number;
+            createFullPath: boolean;
+            customAuth: boolean;
+            username: string;
+            deleteFilesPermanently: boolean;
+        };
     }>;
     catch: (error: Error) => Promise<never>;
+    private getUsername;
+    private getPassword;
 }

package/dist/commands/webdav-config.js

@@ -11,6 +11,7 @@ class WebDAVConfig extends core_1.Command {
     static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
         host: core_1.Flags.string({
             char: 'l',
             description: 'The listening host for the WebDAV server.',
@@ -45,10 +46,36 @@ class WebDAVConfig extends core_1.Command {
             required: false,
             allowNo: true,
         }),
+        customAuth: core_1.Flags.boolean({
+            char: 'a',
+            description: 'Configures the WebDAV server to use custom authentication.',
+            required: false,
+            default: undefined,
+            allowNo: true,
+        }),
+        username: core_1.Flags.string({
+            char: 'u',
+            description: 'Configures the WebDAV server to use this username for custom authentication.',
+            required: false,
+        }),
+        password: core_1.Flags.string({
+            char: 'w',
+            description: 'Configures the WebDAV server to use this password for custom authentication.',
+            required: false,
+        }),
+        deleteFilesPermanently: core_1.Flags.boolean({
+            char: 'd',
+            description: 'Configures the WebDAV server to delete files permanently instead of trashing them.',
+            required: false,
+            default: undefined,
+            allowNo: true,
+        }),
     };
     static enableJsonFlag = true;
     run = async () => {
-        const { flags: { host, port, http, https, timeout, createFullPath }, } = await this.parse(WebDAVConfig);
+        const { flags } = await this.parse(WebDAVConfig);
+        const { host, port, https, http, timeout, createFullPath, customAuth, username, password, deleteFilesPermanently } = flags;
+        const nonInteractive = flags['non-interactive'];
         const webdavConfig = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (host) {
             webdavConfig['host'] = host;
@@ -73,10 +100,29 @@ class WebDAVConfig extends core_1.Command {
         if (createFullPath !== undefined) {
             webdavConfig['createFullPath'] = createFullPath;
         }
+        if (customAuth !== undefined) {
+            webdavConfig['customAuth'] = customAuth;
+        }
+        if (username) {
+            webdavConfig['username'] = await this.getUsername(username, nonInteractive);
+        }
+        if (password) {
+            webdavConfig['password'] = await this.getPassword(password, nonInteractive);
+        }
+        if (webdavConfig['customAuth'] && (!webdavConfig['username'] || !webdavConfig['password'])) {
+            throw new command_types_1.MissingCredentialsWhenUsingAuthError();
+        }
+        if (deleteFilesPermanently !== undefined) {
+            webdavConfig['deleteFilesPermanently'] = deleteFilesPermanently;
+        }
         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)}`;
+        const printWebdavConfig = {
+            ...webdavConfig,
+            password: undefined,
+        };
+        const message = 'On the next start, the WebDAV server will use the next config: ' + JSON.stringify(printWebdavConfig);
         cli_utils_1.CLIUtils.success(this.log.bind(this), message);
-        return { success: true, message, config: webdavConfig };
+        return { success: true, message, config: printWebdavConfig };
     };
     catch = async (error) => {
         const { flags } = await this.parse(WebDAVConfig);
@@ -88,5 +134,37 @@ class WebDAVConfig extends core_1.Command {
         });
         this.exit(1);
     };
+    getUsername = async (usernameFlag, nonInteractive) => {
+        const username = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: usernameFlag,
+            name: WebDAVConfig.flags['username'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the custom auth username?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateStringIsNotEmpty,
+            error: new command_types_1.EmptyCustomAuthUsernameError(),
+        }, this.log.bind(this));
+        return username;
+    };
+    getPassword = async (passwordFlag, nonInteractive) => {
+        const password = await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: passwordFlag,
+            name: WebDAVConfig.flags['password'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the custom auth password?',
+                options: { type: 'password' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateStringIsNotEmpty,
+            error: new command_types_1.EmptyCustomAuthPasswordError(),
+        }, this.log.bind(this));
+        return password;
+    };
 }
 exports.default = WebDAVConfig;

package/dist/commands/webdav.d.ts

@@ -3,7 +3,7 @@ export default class Webdav extends Command {
     static readonly args: {
         action: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
-    static readonly description = "Enable, disable, restart or get the status of the Internxt CLI WebDav server";
+    static readonly description = "Start, stop, restart or get the status of the Internxt CLI WebDAV server";
     static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {};

package/dist/commands/webdav.js

@@ -5,18 +5,19 @@ 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 auth_service_1 = require("../services/auth.service");
+const webdav_server_1 = require("../webdav/webdav-server");
 class Webdav extends core_1.Command {
     static args = {
         action: core_1.Args.string({
             required: true,
-            options: ['enable', 'disable', 'restart', 'status'],
+            options: ['enable', 'start', 'disable', 'stop', 'restart', 'status'],
         }),
     };
-    static description = 'Enable, disable, restart or get the status of the Internxt CLI WebDav server';
+    static description = 'Start, stop, 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',
+        '<%= config.bin %> <%= command.id %> enable | start',
+        '<%= config.bin %> <%= command.id %> disable | stop',
         '<%= config.bin %> <%= command.id %> restart',
         '<%= config.bin %> <%= command.id %> status',
     ];
@@ -27,23 +28,27 @@ class Webdav extends core_1.Command {
         let message = '';
         let success = true;
         await pm2_utils_1.PM2Utils.connect();
+        const configs = await config_service_1.ConfigService.instance.readWebdavConfig();
         switch (args.action) {
+            case 'start':
             case 'enable': {
                 await auth_service_1.AuthService.instance.getAuthDetails();
+                webdav_server_1.WebDavServer.checkwebDAVCredentials(configs);
                 message = await this.enableWebDav(flags['json']);
                 break;
             }
+            case 'stop':
             case 'disable': {
                 message = await this.disableWebDav(flags['json']);
                 break;
             }
             case 'restart': {
                 await auth_service_1.AuthService.instance.getAuthDetails();
+                webdav_server_1.WebDavServer.checkwebDAVCredentials(configs);
                 message = await this.restartWebDav(flags['json']);
                 break;
             }
             case 'status': {
-                await auth_service_1.AuthService.instance.getAuthDetails();
                 message = await this.webDAVStatus();
                 break;
             }

package/dist/commands/whoami.js

@@ -30,7 +30,8 @@ class Whoami extends core_1.Command {
             else {
                 if (validCreds.refreshRequired) {
                     try {
-                        await auth_service_1.AuthService.instance.refreshUserToken(userCredentials.token, userCredentials.user.mnemonic);
+                        const refreshedCreds = await auth_service_1.AuthService.instance.refreshUserToken(userCredentials.token, userCredentials.user.mnemonic, userCredentials.user.keys.ecc.privateKey);
+                        await config_service_1.ConfigService.instance.saveUser(refreshedCreds);
                     }
                     catch {
                     }

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

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+export default class WorkspacesList extends Command {
+    static readonly args: {};
+    static readonly description = "Get the list of workspaces.";
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        extended: 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;
+        list: {
+            workspaces: import("@internxt/sdk/dist/workspaces").WorkspaceData[];
+        };
+    }>;
+    catch: (error: Error) => Promise<never>;
+}

package/dist/commands/workspaces-list.js

@@ -0,0 +1,67 @@
+"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 command_types_1 = require("../types/command.types");
+const workspace_service_1 = require("../services/drive/workspace.service");
+const format_utils_1 = require("../utils/format.utils");
+class WorkspacesList extends core_1.Command {
+    static args = {};
+    static description = 'Get the list of workspaces.';
+    static aliases = ['workspaces:list'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        extended: core_1.Flags.boolean({
+            char: 'e',
+            description: 'Displays additional information in the list.',
+            required: false,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { flags } = await this.parse(WorkspacesList);
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const workspaces = await workspace_service_1.WorkspaceService.instance.getAvailableWorkspaces(userCredentials.user);
+        const allItems = workspaces.map((workspaceData) => {
+            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 {
+                name: workspaceData.workspace.name,
+                id: workspaceData.workspace.id,
+                usedSpace,
+                availableSpace,
+                owner: workspaceData.workspace.ownerId,
+                address: workspaceData.workspace.address,
+                created: format_utils_1.FormatUtils.formatDate(workspaceData.workspace.createdAt),
+            };
+        });
+        const headers = [
+            { value: 'name', alias: 'Name' },
+            { value: 'id', alias: 'Workspace ID' },
+            { value: 'usedSpace', alias: 'Used space' },
+            { value: 'availableSpace', alias: 'Available space' },
+        ];
+        if (flags.extended) {
+            headers.push({ value: 'owner', alias: 'Owner ID' }, { value: 'address', alias: 'Address' }, { value: 'created', alias: 'Created at' });
+        }
+        cli_utils_1.CLIUtils.table(this.log.bind(this), headers, allItems);
+        return { success: true, list: { workspaces } };
+    };
+    catch = async (error) => {
+        const { flags } = await this.parse(WorkspacesList);
+        cli_utils_1.CLIUtils.catchError({
+            error,
+            command: this.id,
+            logReporter: this.log.bind(this),
+            jsonFlag: flags['json'],
+        });
+        this.exit(1);
+    };
+}
+exports.default = WorkspacesList;

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

@@ -0,0 +1,23 @@
+import { Command } from '@oclif/core';
+import { LogReporter } from '../utils/cli.utils';
+import { LoginCredentials } from '../types/command.types';
+export default class WorkspacesUnset extends Command {
+    static readonly args: {};
+    static readonly description: string;
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        '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;
+    }>;
+    catch: (error: Error) => Promise<never>;
+    static readonly unsetWorkspace: (userCredentials: LoginCredentials, reporter: LogReporter) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/commands/workspaces-unset.js

@@ -0,0 +1,45 @@
+"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 command_types_1 = require("../types/command.types");
+const sdk_manager_service_1 = require("../services/sdk-manager.service");
+const database_service_1 = require("../services/database/database.service");
+class WorkspacesUnset extends core_1.Command {
+    static args = {};
+    static description = 'Unset the active workspace context for the current user session. ' +
+        'Once a workspace is unset, WebDAV and all of the subsequent CLI commands ' +
+        'will operate within the personal drive space until it is changed or set again.';
+    static aliases = ['workspaces:unset'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        await this.parse(WorkspacesUnset);
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        return WorkspacesUnset.unsetWorkspace(userCredentials, this.log.bind(this));
+    };
+    catch = async (error) => {
+        const { flags } = await this.parse(WorkspacesUnset);
+        cli_utils_1.CLIUtils.catchError({
+            error,
+            command: this.id,
+            logReporter: this.log.bind(this),
+            jsonFlag: flags['json'],
+        });
+        this.exit(1);
+    };
+    static unsetWorkspace = async (userCredentials, reporter) => {
+        sdk_manager_service_1.SdkManager.init({ token: userCredentials.token });
+        await config_service_1.ConfigService.instance.saveUser({ ...userCredentials, workspace: undefined });
+        void database_service_1.DatabaseService.instance.clear();
+        cli_utils_1.CLIUtils.success(reporter, 'Personal drive space selected successfully.');
+        return { success: true, message: 'Personal drive space selected successfully.' };
+    };
+}
+exports.default = WorkspacesUnset;

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;
+}