@internxt/cli 0.1.4

package/dist/commands/upload.js

@@ -0,0 +1,93 @@
+"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 = __importDefault(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 drive_folder_service_1 = require("../services/drive/drive-folder.service");
+class Upload extends core_1.Command {
+    static description = 'Upload a file to Internxt Drive';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static enableJsonFlag = true;
+    static flags = {
+        file: core_1.Flags.string({ description: 'The path to read the file in your system', required: true }),
+        id: core_1.Flags.string({ description: 'The folder id to upload the file to', required: false }),
+    };
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    async run() {
+        const { flags } = await this.parse(Upload);
+        const folderUuid = flags.id;
+        let folderId;
+        const stat = await promises_1.default.stat(flags.file);
+        if (!stat.size) {
+            throw new Error('File is empty, cannot upload empty files as is not allowed.');
+        }
+        if (!folderUuid || folderUuid.trim().length === 0) {
+            cli_utils_1.CLIUtils.warning('No folder id provided, uploading to root folder');
+        }
+        else {
+            folderId = (await drive_folder_service_1.DriveFolderService.instance.getFolderMetaByUuid(folderUuid)).id;
+        }
+        cli_utils_1.CLIUtils.doing('Preparing Network');
+        const { mnemonic } = await auth_service_1.AuthService.instance.getAuthDetails();
+        const user = await auth_service_1.AuthService.instance.getUser();
+        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)(flags.file);
+        const progressBar = core_1.ux.progress({
+            format: 'Uploading file [{bar}] {percentage}%',
+            linewrap: true,
+        });
+        progressBar.start(1, 0);
+        const [uploadPromise, abortable] = await networkFacade.uploadFromStream(user.bucket, mnemonic, stat.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(flags.file);
+        const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
+            name: fileInfo.name,
+            type: fileInfo.ext.replaceAll('.', ''),
+            size: stat.size,
+            folderId: folderId ?? user.root_folder_id,
+            fileId: uploadResult.fileId,
+            bucket: user.bucket,
+        });
+        const uploadTime = timer.stop();
+        this.log('\n');
+        cli_utils_1.CLIUtils.success(`File uploaded in ${uploadTime}ms, view it at ${config_service_1.ConfigService.instance.get('DRIVE_URL')}/file/${createdDriveFile.uuid}`);
+        return {
+            fileId: uploadResult.fileId,
+            uuid: createdDriveFile.uuid,
+        };
+    }
+}
+exports.default = Upload;

package/dist/commands/webdav.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class Webdav extends Command {
+    static readonly description = "Enable or disable the Internxt CLI WebDav server";
+    static examples: string[];
+    static flags: {};
+    static args: {
+        action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    enableWebDav(): Promise<void>;
+    disableWebDav(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/webdav.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+class Webdav extends core_1.Command {
+    static description = 'Enable or disable the Internxt CLI WebDav server';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {};
+    static args = {
+        action: core_1.Args.string({
+            required: true,
+            options: ['enable', 'disable'],
+        }),
+    };
+    async enableWebDav() {
+        cli_utils_1.CLIUtils.doing('Starting Internxt WebDav server...');
+        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();
+        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 on https://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${process.env.WEBDAV_SERVER_PORT}`);
+        }
+        else {
+            core_1.ux.log(`WebDav server status: ${core_1.ux.colorize('red', status)}`);
+        }
+    }
+    async disableWebDav() {
+        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 run() {
+        const { args } = await this.parse(Webdav);
+        try {
+            switch (args.action) {
+                case 'enable': {
+                    await this.enableWebDav();
+                    break;
+                }
+                case 'disable': {
+                    await this.disableWebDav();
+                    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);
+    }
+}
+exports.default = Webdav;

package/dist/commands/whoami.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Whoami extends Command {
+    static readonly args: {};
+    static readonly description = "Display the current user logged into the Internxt CLI.";
+    static readonly examples: string[];
+    static readonly flags: {};
+    catch(error: Error): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/whoami.js

@@ -0,0 +1,27 @@
+"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");
+class Whoami extends core_1.Command {
+    static args = {};
+    static description = 'Display the current user logged into the Internxt CLI.';
+    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() {
+        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}`);
+        }
+        else {
+            cli_utils_1.CLIUtils.error('You are not logged in');
+        }
+    }
+}
+exports.default = Whoami;

package/dist/database/migrations/20240402164914-create-files.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/database/migrations/20240402164914-create-files.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = {
+    async up(queryInterface, Sequelize) {
+        await queryInterface.createTable('files', {
+            id: {
+                allowNull: false,
+                autoIncrement: true,
+                primaryKey: true,
+                type: Sequelize.INTEGER,
+            },
+            name: {
+                type: Sequelize.STRING,
+            },
+            type: {
+                type: Sequelize.STRING(24),
+                allowNull: true,
+            },
+            uuid: {
+                type: Sequelize.UUIDV4,
+                unique: true,
+            },
+            file_id: {
+                type: Sequelize.STRING(24),
+            },
+            folder_id: {
+                type: Sequelize.INTEGER,
+            },
+            bucket: {
+                type: Sequelize.STRING(24),
+            },
+            relative_path: {
+                type: Sequelize.TEXT,
+            },
+            size: {
+                type: Sequelize.BIGINT,
+            },
+            status: {
+                type: Sequelize.ENUM,
+                values: ['EXISTS', 'TRASHED', 'DELETED'],
+                defaultValue: 'EXISTS',
+                allowNull: false,
+            },
+            created_at: {
+                type: Sequelize.DATE,
+            },
+            updated_at: {
+                type: Sequelize.DATE,
+            },
+        });
+    },
+    async down(queryInterface) {
+        await queryInterface.dropTable('files');
+    },
+};

package/dist/database/migrations/20240402165418-create-folders.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/database/migrations/20240402165418-create-folders.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = {
+    async up(queryInterface, Sequelize) {
+        await queryInterface.createTable('folders', {
+            id: {
+                allowNull: false,
+                autoIncrement: true,
+                primaryKey: true,
+                type: Sequelize.INTEGER,
+            },
+            name: {
+                type: Sequelize.STRING,
+            },
+            uuid: {
+                type: Sequelize.UUIDV4,
+                unique: true,
+            },
+            relative_path: {
+                type: Sequelize.TEXT,
+            },
+            parent_id: {
+                type: Sequelize.INTEGER,
+                allowNull: true,
+            },
+            created_at: {
+                type: Sequelize.DATE,
+            },
+            updated_at: {
+                type: Sequelize.DATE,
+            },
+        });
+    },
+    async down(queryInterface) {
+        await queryInterface.dropTable('folders');
+    },
+};

package/dist/hooks/prerun/auth_check.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'prerun'>;
+export default hook;

package/dist/hooks/prerun/auth_check.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const whoami_1 = __importDefault(require("../../commands/whoami"));
+const login_1 = __importDefault(require("../../commands/login"));
+const logout_1 = __importDefault(require("../../commands/logout"));
+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 CommandsToSkip = [whoami_1.default, login_1.default, logout_1.default];
+const hook = async function (opts) {
+    if (!CommandsToSkip.map((command) => command.name).includes(opts.Command.name)) {
+        cli_utils_1.CLIUtils.doing('Checking credentials');
+        try {
+            const { token, newToken } = await auth_service_1.AuthService.instance.getAuthDetails();
+            sdk_manager_service_1.SdkManager.init({
+                token,
+                newToken,
+            });
+        }
+        catch (error) {
+            cli_utils_1.CLIUtils.error(new command_types_1.MissingCredentialsError().message);
+            opts.context.exit(1);
+        }
+        cli_utils_1.CLIUtils.done();
+        cli_utils_1.CLIUtils.clearPreviousLine();
+    }
+};
+exports.default = hook;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

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

@@ -0,0 +1,14 @@
+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;
+    }>;
+}

package/dist/services/auth.service.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const sdk_manager_service_1 = require("./sdk-manager.service");
+const keys_service_1 = require("./keys.service");
+const crypto_service_1 = require("./crypto.service");
+const config_service_1 = require("./config.service");
+const validation_service_1 = require("./validation.service");
+class AuthService {
+    static instance = new AuthService();
+    doLogin = async (email, password, twoFactorCode) => {
+        const authClient = sdk_manager_service_1.SdkManager.instance.getAuth();
+        const loginDetails = {
+            email: email.toLowerCase(),
+            password: password,
+            tfaCode: twoFactorCode,
+        };
+        const data = await authClient.login(loginDetails, crypto_service_1.CryptoService.cryptoProvider);
+        const { user, token, newToken } = data;
+        const { privateKey, publicKey } = user;
+        const plainPrivateKeyInBase64 = privateKey
+            ? Buffer.from(keys_service_1.KeysService.instance.decryptPrivateKey(privateKey, password)).toString('base64')
+            : '';
+        if (privateKey) {
+            await keys_service_1.KeysService.instance.assertPrivateKeyIsValid(privateKey, password);
+            await keys_service_1.KeysService.instance.assertValidateKeys(Buffer.from(plainPrivateKeyInBase64, 'base64').toString(), Buffer.from(publicKey, 'base64').toString());
+        }
+        const clearMnemonic = crypto_service_1.CryptoService.instance.decryptTextWithKey(user.mnemonic, password);
+        const clearUser = {
+            ...user,
+            mnemonic: clearMnemonic,
+            privateKey: plainPrivateKeyInBase64,
+        };
+        return {
+            user: clearUser,
+            token: token,
+            newToken: newToken,
+            mnemonic: clearMnemonic,
+        };
+    };
+    is2FANeeded = async (email) => {
+        const authClient = sdk_manager_service_1.SdkManager.instance.getAuth();
+        const securityDetails = await authClient.securityDetails(email).catch((error) => {
+            throw new Error(error.message ?? 'Login error');
+        });
+        return securityDetails.tfaEnabled;
+    };
+    getUser = async () => {
+        const usersClient = sdk_manager_service_1.SdkManager.instance.getUsers();
+        const { user } = await usersClient.refreshUser();
+        return user;
+    };
+    getAuthDetails = async () => {
+        const loginCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!loginCredentials) {
+            throw new Error('Credentials not found, please login first');
+        }
+        const { token, newToken, mnemonic } = loginCredentials;
+        if (!token) {
+            throw new Error('Auth token not found, please login again');
+        }
+        if (!newToken) {
+            throw new Error('New Auth token not found, please login again');
+        }
+        if (!mnemonic) {
+            throw new Error('Mnemonic not found, please login again');
+        }
+        if (!validation_service_1.ValidationService.instance.validateMnemonic(mnemonic)) {
+            throw new Error('Mnemonic is not valid, please login again');
+        }
+        return {
+            token,
+            newToken,
+            mnemonic,
+            user: loginCredentials.user,
+        };
+    };
+}
+exports.AuthService = AuthService;

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

@@ -0,0 +1,19 @@
+import { ConfigKeys } from '../types/config.types';
+import { CLICredentials } 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_LOCAL_URL = "webdav.local.internxt.com";
+    static readonly instance: ConfigService;
+    get: (key: keyof ConfigKeys) => string;
+    saveUser: (loginCredentials: CLICredentials) => Promise<void>;
+    clearUser: () => Promise<void>;
+    readUser: () => Promise<CLICredentials | undefined>;
+    ensureInternxtCliDataDirExists: () => Promise<void>;
+    ensureWebdavCertsDirExists: () => Promise<void>;
+    ensureInternxtLogsDirExists: () => Promise<void>;
+}

package/dist/services/config.service.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const promises_1 = __importDefault(require("fs/promises"));
+const crypto_service_1 = require("./crypto.service");
+class ConfigService {
+    static INTERNXT_CLI_DATA_DIR = path_1.default.join(os_1.default.homedir(), '.internxt-cli');
+    static INTERNXT_CLI_LOGS_DIR = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'logs');
+    static INTERNXT_TMP_DIR = os_1.default.tmpdir();
+    static CREDENTIALS_FILE = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, '.inxtcli');
+    static DRIVE_SQLITE_FILE = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
+    static WEBDAV_SSL_CERTS_DIR = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'certs');
+    static WEBDAV_LOCAL_URL = 'webdav.local.internxt.com';
+    static instance = new ConfigService();
+    get = (key) => {
+        const value = process.env[key];
+        if (!value)
+            throw new Error(`Config key ${key} was not found in process.env`);
+        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');
+    };
+    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');
+    };
+    readUser = async () => {
+        try {
+            const encryptedCredentials = await promises_1.default.readFile(ConfigService.CREDENTIALS_FILE, 'utf8');
+            const credentialsString = crypto_service_1.CryptoService.instance.decryptText(encryptedCredentials);
+            const loginCredentials = JSON.parse(credentialsString, (key, value) => {
+                if (typeof value === 'string' && key === 'createdAt') {
+                    return new Date(value);
+                }
+                return value;
+            });
+            return loginCredentials;
+        }
+        catch {
+            return;
+        }
+    };
+    ensureInternxtCliDataDirExists = async () => {
+        try {
+            await promises_1.default.access(ConfigService.INTERNXT_CLI_DATA_DIR);
+        }
+        catch {
+            await promises_1.default.mkdir(ConfigService.INTERNXT_CLI_DATA_DIR);
+        }
+    };
+    ensureWebdavCertsDirExists = async () => {
+        try {
+            await promises_1.default.access(ConfigService.WEBDAV_SSL_CERTS_DIR);
+        }
+        catch {
+            await promises_1.default.mkdir(ConfigService.WEBDAV_SSL_CERTS_DIR);
+        }
+    };
+    ensureInternxtLogsDirExists = async () => {
+        try {
+            await promises_1.default.access(ConfigService.INTERNXT_CLI_LOGS_DIR);
+        }
+        catch {
+            await promises_1.default.mkdir(ConfigService.INTERNXT_CLI_LOGS_DIR);
+        }
+    };
+}
+exports.ConfigService = ConfigService;

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

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { CryptoProvider } from '@internxt/sdk';
+import { Transform } from 'stream';
+export declare class CryptoService {
+    static readonly instance: CryptoService;
+    static readonly cryptoProvider: CryptoProvider;
+    passToHash: (passObject: {
+        password: string;
+        salt?: string | null;
+    }) => {
+        salt: string;
+        hash: string;
+    };
+    encryptText: (textToEncrypt: string) => string;
+    decryptText: (encryptedText: string) => string;
+    encryptTextWithKey: (textToEncrypt: string, secret: string) => string;
+    decryptTextWithKey: (encryptedText: string, secret: string) => string;
+    decryptStream(inputSlices: ReadableStream<Uint8Array>[], key: Buffer, iv: Buffer): Promise<ReadableStream<any>>;
+    getEncryptionTransform(key: Buffer, iv: Buffer): Promise<Transform>;
+    private getKeyAndIvFrom;
+}