@internxt/cli 1.3.3 → 1.4.2

package/dist/types/command.types.d.ts

@@ -3,10 +3,8 @@ export interface LoginCredentials {
     user: UserSettings;
     token: string;
     newToken: string;
-    mnemonic: string;
-}
-export interface CLICredentials extends LoginCredentials {
-    root_folder_uuid: string;
+    lastLoggedInAt: string;
+    lastTokenRefreshAt: string;
 }
 export interface WebdavConfig {
     port: string;
@@ -27,32 +25,43 @@ export declare class NotValidFolderUuidError extends Error {
 export declare class NotValidFileUuidError extends Error {
     constructor();
 }
-export declare class NotValidItemUuidError extends Error {
+export declare class NoRootFolderIdFoundError extends Error {
     constructor();
 }
-export declare class ItemNotFoundError extends Error {
+export declare class MissingCredentialsError extends Error {
     constructor();
 }
-export declare class NoRootFolderIdFoundError extends Error {
+export declare class ExpiredCredentialsError extends Error {
     constructor();
 }
-export declare class MissingCredentialsError extends Error {
+export declare class InvalidCredentialsError extends Error {
     constructor();
 }
-export declare class NotValidYesOrNoError extends Error {
+export declare class EmptyFileNameError extends Error {
     constructor();
 }
-export declare class EmptyItemNameError extends Error {
+export declare class EmptyFolderNameError extends Error {
     constructor();
 }
 export declare class NotValidPortError extends Error {
     constructor();
 }
-export type PaginatedItem = {
-    plainName: string;
-    uuid: string;
-    isFolder: boolean;
+export declare class NotValidDirectoryError extends Error {
+    constructor();
+}
+export declare class NotValidFileError extends Error {
+    constructor();
+}
+export interface PaginatedItem {
+    name: string;
     type: string;
-    size: bigint;
-    updatedAt: Date;
-};
+    id: string;
+    size: string;
+    modified: string;
+}
+export interface PromptOptions {
+    type: 'input' | 'password' | 'mask' | 'confirm';
+    confirm?: {
+        default: boolean;
+    };
+}

package/dist/types/command.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotValidPortError = exports.EmptyItemNameError = exports.NotValidYesOrNoError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.ItemNotFoundError = exports.NotValidItemUuidError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
+exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyFolderNameError = exports.EmptyFileNameError = exports.InvalidCredentialsError = exports.ExpiredCredentialsError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
 class NotValidEmailError extends Error {
     constructor() {
         super('Email is not valid');
@@ -36,20 +36,6 @@ class NotValidFileUuidError extends Error {
     }
 }
 exports.NotValidFileUuidError = NotValidFileUuidError;
-class NotValidItemUuidError extends Error {
-    constructor() {
-        super('Item UUID is not valid (it must be a valid v4 UUID)');
-        Object.setPrototypeOf(this, NotValidItemUuidError.prototype);
-    }
-}
-exports.NotValidItemUuidError = NotValidItemUuidError;
-class ItemNotFoundError extends Error {
-    constructor() {
-        super('Item not found');
-        Object.setPrototypeOf(this, ItemNotFoundError.prototype);
-    }
-}
-exports.ItemNotFoundError = ItemNotFoundError;
 class NoRootFolderIdFoundError extends Error {
     constructor() {
         super('No root folder id found on your account');
@@ -59,25 +45,39 @@ class NoRootFolderIdFoundError extends Error {
 exports.NoRootFolderIdFoundError = NoRootFolderIdFoundError;
 class MissingCredentialsError extends Error {
     constructor() {
-        super('Missing credentials, login first');
+        super('Missing credentials, please login first');
         Object.setPrototypeOf(this, MissingCredentialsError.prototype);
     }
 }
 exports.MissingCredentialsError = MissingCredentialsError;
-class NotValidYesOrNoError extends Error {
+class ExpiredCredentialsError extends Error {
     constructor() {
-        super('Only yes or not -> ["yes", "no", "y", "n"] options are valid');
-        Object.setPrototypeOf(this, NotValidYesOrNoError.prototype);
+        super('The session has expired, please login again');
+        Object.setPrototypeOf(this, ExpiredCredentialsError.prototype);
     }
 }
-exports.NotValidYesOrNoError = NotValidYesOrNoError;
-class EmptyItemNameError extends Error {
+exports.ExpiredCredentialsError = ExpiredCredentialsError;
+class InvalidCredentialsError extends Error {
     constructor() {
-        super('Item name can not be empty');
-        Object.setPrototypeOf(this, EmptyPasswordError.prototype);
+        super('Corrupted credentials, please login again');
+        Object.setPrototypeOf(this, InvalidCredentialsError.prototype);
+    }
+}
+exports.InvalidCredentialsError = InvalidCredentialsError;
+class EmptyFileNameError extends Error {
+    constructor() {
+        super('File name can not be empty');
+        Object.setPrototypeOf(this, EmptyFileNameError.prototype);
     }
 }
-exports.EmptyItemNameError = EmptyItemNameError;
+exports.EmptyFileNameError = EmptyFileNameError;
+class EmptyFolderNameError extends Error {
+    constructor() {
+        super('Folder name can not be empty');
+        Object.setPrototypeOf(this, EmptyFolderNameError.prototype);
+    }
+}
+exports.EmptyFolderNameError = EmptyFolderNameError;
 class NotValidPortError extends Error {
     constructor() {
         super('Port should be a number between 1 and 65535');
@@ -85,3 +85,17 @@ class NotValidPortError extends Error {
     }
 }
 exports.NotValidPortError = NotValidPortError;
+class NotValidDirectoryError extends Error {
+    constructor() {
+        super('The specified path is not a valid directory');
+        Object.setPrototypeOf(this, NotValidDirectoryError.prototype);
+    }
+}
+exports.NotValidDirectoryError = NotValidDirectoryError;
+class NotValidFileError extends Error {
+    constructor() {
+        super('The specified path is not a valid file.');
+        Object.setPrototypeOf(this, NotValidFileError.prototype);
+    }
+}
+exports.NotValidFileError = NotValidFileError;

package/dist/types/network.types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export interface NetworkCredentials {
     user: string;
     pass: string;

package/dist/types/webdav.types.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" />
 import { Request, Response } from 'express';
-import { ParsedPath } from 'path';
+import { ParsedPath } from 'node:path';
 export declare abstract class WebDavMethodHandler {
     abstract handle(request: Request, response: Response): Promise<void>;
 }

package/dist/utils/cli.utils.d.ts

@@ -1,32 +1,41 @@
-import { ux } from '@oclif/core';
+import cliProgress from 'cli-progress';
+import { Header } from 'tty-table';
+import { PromptOptions } from '../types/command.types';
 export declare class CLIUtils {
-    static clearPreviousLine(): void;
-    static warning(message: string): void;
-    static error(message: string): void;
-    static doing(message: string): void;
-    static success(message: string): void;
-    static done(): void;
+    static readonly clearPreviousLine: () => void;
+    static readonly warning: (reporter: (message: string) => void, message: string) => void;
+    static readonly error: (reporter: (message: string) => void, message: string) => void;
+    static readonly doing: (message: string) => void;
+    static readonly success: (reporter: (message: string) => void, message: string) => void;
+    static readonly log: (reporter: (message: string) => void, message: string) => void;
+    static readonly done: () => void;
+    static readonly progress: (opts: cliProgress.Options) => cliProgress.SingleBar;
+    static readonly table: (reporter: (message: string) => void, header: Header[], rows: object[]) => void;
+    static readonly generateTableHeaderFromType: <T extends object>() => Header[];
     static readonly CommonFlags: {
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     static readonly getValueFromFlag: (flag: {
         value?: string;
         name: string;
+    }, command: {
+        nonInteractive: boolean;
+        maxAttempts?: number;
+        prompt: {
+            message: string;
+            options: PromptOptions;
+        };
+    }, validation: {
+        validate: (value: string) => Promise<boolean> | boolean;
         error: Error;
         canBeEmpty?: boolean;
-    }, nonInteractive: boolean, validate: (value: string) => boolean) => string | undefined;
-    static readonly promptWithAttempts: (prompt: {
-        message: string;
-        options?: ux.IPromptOptions;
-        error: Error;
-    }, maxAttempts: number, validate: (value: string) => boolean) => Promise<string>;
-    static timer(): {
+    }, reporter: (message: string) => void) => Promise<string>;
+    private static readonly promptWithAttempts;
+    static readonly timer: () => {
         stop: () => number;
     };
-    static readonly prompt: (prompt: {
-        message: string;
-        options?: ux.IPromptOptions;
-        error?: Error;
-    }, validate?: ((value: string) => boolean) | undefined) => Promise<string>;
     static readonly parseEmpty: (input: string) => Promise<string>;
 }
+export declare class NoFlagProvidedError extends Error {
+    constructor(flag: string);
+}

package/dist/utils/cli.utils.js

@@ -1,80 +1,109 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLIUtils = void 0;
+exports.NoFlagProvidedError = exports.CLIUtils = void 0;
 const core_1 = require("@oclif/core");
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const tty_table_1 = __importDefault(require("tty-table"));
+const inquirer_utils_1 = require("./inquirer.utils");
 class CLIUtils {
-    static clearPreviousLine() {
+    static clearPreviousLine = () => {
         process.stdout.write('\x1b[1A');
         process.stdout.clearLine(0);
-    }
-    static warning(message) {
-        core_1.ux.log(core_1.ux.colorize('#a67805', `⚠ Warning: ${message}`));
-    }
-    static error(message) {
-        core_1.ux.log(core_1.ux.colorize('red', `⚠ Error: ${message}`));
-    }
-    static doing(message) {
+    };
+    static warning = (reporter, message) => {
+        reporter(core_1.ux.colorize('#a67805', `⚠ Warning: ${message}`));
+    };
+    static error = (reporter, message) => {
+        reporter(core_1.ux.colorize('red', `⚠ Error: ${message}`));
+    };
+    static doing = (message) => {
         core_1.ux.action.start(message, undefined, {});
-    }
-    static success(message) {
-        core_1.ux.log(core_1.ux.colorize('green', `✓ ${message}`));
-    }
-    static done() {
+    };
+    static success = (reporter, message) => {
+        reporter(core_1.ux.colorize('green', `✓ ${message}`));
+    };
+    static log = (reporter, message) => {
+        reporter(`${message}`);
+    };
+    static done = () => {
         core_1.ux.action.stop(core_1.ux.colorize('green', 'done ✓'));
-    }
+    };
+    static progress = (opts) => {
+        return new cli_progress_1.default.SingleBar({ noTTYOutput: Boolean(!process.stdin.isTTY), ...opts }, cli_progress_1.default.Presets.shades_classic);
+    };
+    static table = (reporter, header, rows) => {
+        const table = (0, tty_table_1.default)(header, rows);
+        reporter(table.render());
+    };
+    static generateTableHeaderFromType = () => {
+        return Object.keys({}).map((key) => ({
+            value: key,
+            alias: key.charAt(0).toUpperCase() + key.slice(1),
+        }));
+    };
     static CommonFlags = {
         'non-interactive': core_1.Flags.boolean({
-            char: 'n',
+            char: 'x',
             env: 'INXT_NONINTERACTIVE',
             helpGroup: 'helper',
-            description: 'Blocks the cli from being interactive. If passed, the cli will not request data through the console and will throw errors directly',
+            description: 'Prevents the CLI from being interactive. When enabled, the CLI will not request input through the console and will throw errors directly.',
             required: false,
         }),
     };
-    static getValueFromFlag = (flag, nonInteractive, validate) => {
-        if (flag.canBeEmpty) {
-            if (!flag.value || flag.value.trim().length === 0) {
+    static getValueFromFlag = async (flag, command, validation, reporter) => {
+        if (flag.value) {
+            if (validation.canBeEmpty && flag.value.trim().length === 0) {
                 return '';
             }
-        }
-        if (flag.value) {
-            const isValid = validate(flag.value);
+            const isValid = await validation.validate(flag.value);
             if (isValid) {
                 return flag.value;
             }
-            else if (nonInteractive) {
-                throw flag.error;
+            else if (command.nonInteractive) {
+                throw validation.error;
             }
             else {
-                CLIUtils.error(flag.error.message);
+                CLIUtils.error(reporter, validation.error.message);
             }
         }
-        else if (nonInteractive) {
+        if (command.nonInteractive) {
             throw new NoFlagProvidedError(flag.name);
         }
+        else {
+            const maxAttempts = command.maxAttempts ?? 3;
+            return await CLIUtils.promptWithAttempts(command.prompt, maxAttempts, validation, reporter);
+        }
     };
-    static promptWithAttempts = async (prompt, maxAttempts, validate) => {
+    static promptWithAttempts = async (prompt, maxAttempts, validation, reporter) => {
         let isValid = false;
         let currentAttempts = 0;
         let promptValue = '';
         do {
-            promptValue = await core_1.ux.prompt(prompt.message, prompt.options);
-            isValid = validate(promptValue);
+            promptValue = await inquirer_utils_1.InquirerUtils.prompt(prompt.message, prompt.options);
+            if (validation.canBeEmpty) {
+                if (!promptValue || promptValue.trim().length === 0) {
+                    return '';
+                }
+            }
+            isValid = await validation.validate(promptValue);
             if (!isValid) {
                 currentAttempts++;
                 if (currentAttempts < maxAttempts) {
-                    CLIUtils.warning(prompt.error.message + ', please type it again');
+                    CLIUtils.warning(reporter, validation.error.message + ', please type it again');
                 }
             }
         } while (!isValid && currentAttempts < maxAttempts);
         if (!isValid) {
-            throw prompt.error;
+            throw validation.error;
         }
         else {
             return promptValue;
         }
     };
-    static timer() {
+    static timer = () => {
         const start = new Date();
         return {
             stop: () => {
@@ -83,16 +112,6 @@ class CLIUtils {
                 return time;
             },
         };
-    }
-    static prompt = async (prompt, validate) => {
-        const promptValue = await core_1.ux.prompt(prompt.message, prompt.options);
-        if (validate) {
-            const isValid = validate(promptValue);
-            if (!isValid) {
-                throw prompt.error;
-            }
-        }
-        return promptValue;
     };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);
 }
@@ -103,3 +122,4 @@ class NoFlagProvidedError extends Error {
         Object.setPrototypeOf(this, NoFlagProvidedError.prototype);
     }
 }
+exports.NoFlagProvidedError = NoFlagProvidedError;

package/dist/utils/errors.utils.d.ts

@@ -1,5 +1,5 @@
 export declare class ErrorUtils {
-    static report(error: unknown, props?: Record<string, unknown>): void;
+    static report(reporter: (error: string) => void, error: unknown, props?: Record<string, unknown>): void;
 }
 export declare class ConflictError extends Error {
     statusCode: number;

package/dist/utils/errors.utils.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotImplementedError = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
 class ErrorUtils {
-    static report(error, props = {}) {
+    static report(reporter, error, props = {}) {
         if (error instanceof Error) {
-            console.error(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
+            reporter(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
         }
         else {
-            console.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
+            reporter(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
         }
     }
 }

package/dist/utils/hash.utils.d.ts

@@ -1,8 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Hash } from 'crypto';
-import { Transform, TransformCallback, TransformOptions } from 'stream';
+import { Hash } from 'node:crypto';
+import { Transform, TransformCallback, TransformOptions } from 'node:stream';
 export declare class HashStream extends Transform {
     hasher: Hash;
     finalHash: Buffer;
@@ -10,6 +7,6 @@ export declare class HashStream extends Transform {
     _transform(chunk: Buffer, enc: BufferEncoding, cb: TransformCallback): void;
     _flush(cb: (err: Error | null) => void): Hash;
     reset(): void;
-    readHash(): Buffer;
-    getHash(): Buffer;
+    readHash(): Buffer<ArrayBufferLike>;
+    getHash(): Buffer<ArrayBufferLike>;
 }

package/dist/utils/hash.utils.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HashStream = void 0;
-const crypto_1 = require("crypto");
-const stream_1 = require("stream");
-class HashStream extends stream_1.Transform {
+const node_crypto_1 = require("node:crypto");
+const node_stream_1 = require("node:stream");
+class HashStream extends node_stream_1.Transform {
     hasher;
     finalHash;
     constructor(opts) {
         super(opts);
-        this.hasher = (0, crypto_1.createHash)('sha256');
+        this.hasher = (0, node_crypto_1.createHash)('sha256');
         this.finalHash = Buffer.alloc(0);
     }
     _transform(chunk, enc, cb) {
@@ -19,7 +19,7 @@ class HashStream extends stream_1.Transform {
         return this.hasher.end(cb);
     }
     reset() {
-        this.hasher = (0, crypto_1.createHash)('sha256');
+        this.hasher = (0, node_crypto_1.createHash)('sha256');
     }
     readHash() {
         if (!this.finalHash.length) {
@@ -31,7 +31,7 @@ class HashStream extends stream_1.Transform {
         if (!this.finalHash.length) {
             this.readHash();
         }
-        return (0, crypto_1.createHash)('ripemd160').update(this.finalHash).digest();
+        return (0, node_crypto_1.createHash)('ripemd160').update(this.finalHash).digest();
     }
 }
 exports.HashStream = HashStream;

package/dist/utils/inquirer.utils.d.ts

@@ -0,0 +1,4 @@
+import { PromptOptions } from '../types/command.types';
+export declare class InquirerUtils {
+    static prompt(message: string, options: PromptOptions): Promise<string>;
+}

package/dist/utils/inquirer.utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InquirerUtils = void 0;
+const prompts_1 = require("@inquirer/prompts");
+class InquirerUtils {
+    static async prompt(message, options) {
+        switch (options.type) {
+            case 'password': {
+                return (0, prompts_1.password)({ message, mask: false });
+            }
+            case 'mask': {
+                return (0, prompts_1.password)({ message, mask: true });
+            }
+            case 'confirm': {
+                const confirmation = await (0, prompts_1.confirm)({ message, default: options.confirm?.default || false });
+                return confirmation ? 'y' : 'n';
+            }
+            case 'input': {
+                return (0, prompts_1.input)({ message });
+            }
+        }
+    }
+}
+exports.InquirerUtils = InquirerUtils;

package/dist/utils/network.utils.d.ts

@@ -10,7 +10,7 @@ export declare class NetworkUtils {
         privateKey: string;
     };
     static generateNewSelfsignedCerts(): SelfsignedCert;
-    static getWebdavSSLCerts(): SelfsignedCert;
-    static saveWebdavSSLCerts(pems: selfsigned.GenerateResult): void;
+    static getWebdavSSLCerts(): Promise<SelfsignedCert>;
+    static saveWebdavSSLCerts(pems: selfsigned.GenerateResult): Promise<void>;
     static generateSelfSignedSSLCerts(): selfsigned.GenerateResult;
 }

package/dist/utils/network.utils.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NetworkUtils = void 0;
 const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const selfsigned_1 = __importDefault(require("selfsigned"));
 const config_service_1 = require("../services/config.service");
@@ -28,14 +28,16 @@ class NetworkUtils {
             key: newCerts.private,
         };
     }
-    static getWebdavSSLCerts() {
-        if (!(0, node_fs_1.existsSync)(this.WEBDAV_SSL_CERTS_PATH.cert) || !(0, node_fs_1.existsSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey)) {
+    static async getWebdavSSLCerts() {
+        const existCert = !!(await (0, promises_1.stat)(this.WEBDAV_SSL_CERTS_PATH.cert).catch(() => false));
+        const existKey = !!(await (0, promises_1.stat)(this.WEBDAV_SSL_CERTS_PATH.privateKey).catch(() => false));
+        if (!existCert || !existKey) {
             return this.generateNewSelfsignedCerts();
         }
         else {
             let selfsignedCert = {
-                cert: (0, node_fs_1.readFileSync)(this.WEBDAV_SSL_CERTS_PATH.cert),
-                key: (0, node_fs_1.readFileSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey),
+                cert: await (0, promises_1.readFile)(this.WEBDAV_SSL_CERTS_PATH.cert),
+                key: await (0, promises_1.readFile)(this.WEBDAV_SSL_CERTS_PATH.privateKey),
             };
             const { validTo } = new node_crypto_1.X509Certificate(selfsignedCert.cert);
             const dateToday = new Date();
@@ -50,9 +52,9 @@ class NetworkUtils {
             return selfsignedCert;
         }
     }
-    static saveWebdavSSLCerts(pems) {
-        (0, node_fs_1.writeFileSync)(this.WEBDAV_SSL_CERTS_PATH.cert, pems.cert, 'utf8');
-        (0, node_fs_1.writeFileSync)(this.WEBDAV_SSL_CERTS_PATH.privateKey, pems.private, 'utf8');
+    static async saveWebdavSSLCerts(pems) {
+        await (0, promises_1.writeFile)(this.WEBDAV_SSL_CERTS_PATH.cert, pems.cert, 'utf8');
+        await (0, promises_1.writeFile)(this.WEBDAV_SSL_CERTS_PATH.privateKey, pems.private, 'utf8');
     }
     static generateSelfSignedSSLCerts() {
         const attrs = [{ name: 'commonName', value: config_service_1.ConfigService.WEBDAV_LOCAL_URL }];

package/dist/utils/pm2.utils.d.ts

@@ -1,7 +1,11 @@
-export type WebDavProcessStatus = 'online' | 'unknown' | 'errored';
+import pm2 from 'pm2';
+export type WebDavProcessStatus = 'online' | 'stopping' | 'stopped' | 'launching' | 'errored' | 'one-launch-status' | 'offline' | 'unknown';
 export declare class PM2Utils {
     private static WEBDAV_APP_NAME;
     static connect(): Promise<void>;
+    static disconnect(): void;
+    static clean(): Promise<void>;
+    static list(): Promise<pm2.ProcessDescription[]>;
     static killWebDavServer(): Promise<void>;
     static webdavServerStatus(): Promise<{
         status: WebDavProcessStatus;

package/dist/utils/pm2.utils.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PM2Utils = void 0;
-const path_1 = __importDefault(require("path"));
+const node_path_1 = __importDefault(require("node:path"));
 const pm2_1 = __importDefault(require("pm2"));
 class PM2Utils {
     static WEBDAV_APP_NAME = 'Internxt CLI WebDav';
@@ -20,6 +20,36 @@ class PM2Utils {
             });
         });
     }
+    static disconnect() {
+        pm2_1.default.disconnect();
+    }
+    static async clean() {
+        const list = await this.list();
+        if (list.length === 0) {
+            return new Promise((resolve, reject) => {
+                pm2_1.default.killDaemon((err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+    }
+    static list() {
+        return new Promise((resolve, reject) => {
+            pm2_1.default.list((err, processes) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(processes);
+                }
+            });
+        });
+    }
     static killWebDavServer() {
         return new Promise((resolve) => {
             pm2_1.default.delete(this.WEBDAV_APP_NAME, () => {
@@ -34,7 +64,9 @@ class PM2Utils {
                     reject(err);
                 }
                 else if (processDescription.length === 0) {
-                    reject(new Error('WebDav server is not running'));
+                    resolve({
+                        status: 'offline',
+                    });
                 }
                 else {
                     const process = processDescription[0];
@@ -49,7 +81,7 @@ class PM2Utils {
         return new Promise((resolve, reject) => {
             pm2_1.default.start({
                 wait_ready: true,
-                script: path_1.default.join(__dirname, '../webdav/index.js'),
+                script: node_path_1.default.join(__dirname, '../webdav/index.js'),
                 name: this.WEBDAV_APP_NAME,
             }, (err) => {
                 if (err) {