@atomicsolutions/proton5-cli 5.0.1

package/dist/commands/config/add.js

@@ -0,0 +1,122 @@
+import { Command, Flags } from '@oclif/core';
+import { getStoreValue, setStoreValue } from '../../core/store/index.js';
+import { Buffer } from 'buffer';
+import inquirer from 'inquirer';
+import ora from 'ora';
+export default class ConfigAdd extends Command {
+    static description = 'Add a new Proton server connection';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        name: Flags.string({
+            description: 'Nome da configuração',
+            required: false
+        }),
+        server: Flags.string({
+            description: 'Endereço do servidor',
+            required: false
+        }),
+        email: Flags.string({
+            description: 'E-mail de acesso',
+            required: false
+        }),
+        password: Flags.string({
+            description: 'Senha de acesso',
+            required: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(ConfigAdd);
+        const input = {
+            name: flags.name,
+            server: flags.server,
+            email: flags.email,
+            password: flags.password
+        };
+        const missing = this.getMissingFields(input);
+        if (missing.length > 0) {
+            const answers = await inquirer.prompt(missing.map((field) => this.questionFor(field)));
+            Object.assign(input, answers);
+        }
+        const spinner = ora('Creating new connection').start();
+        try {
+            const configList = getStoreValue('config');
+            const newConfig = {
+                name: input.name,
+                server: input.server,
+                email: input.email,
+                password: Buffer.from(input.password).toString('base64'),
+                privateMode: false,
+                statusNotification: false,
+                token: '',
+                order: configList.length > 0 ? Math.max(...configList.map(c => c.order)) + 1 : 1,
+            };
+            setStoreValue('config', [...configList, newConfig]);
+            spinner.succeed('Connection added successfully');
+        }
+        catch (err) {
+            spinner.fail('Failed to create connection');
+        }
+        // this.log('Follow the instructions to create a new Proton Connection.');
+        // const answers = await inquirer.prompt([
+        //   {
+        //     type: 'input',
+        //     name: 'name',
+        //     message: 'Digite o nome da configuração:',
+        //     validate: (v) => v ? true : 'Nome é obrigatório',
+        //   },
+        //   {
+        //     type: 'input',
+        //     name: 'server',
+        //     message: 'Digite o endereço do servidor:',
+        //     validate: (v) => v ? true : 'Servidor é obrigatório',
+        //   },
+        //   {
+        //     type: 'input',
+        //     name: 'email',
+        //     message: 'Digite seu e-mail:',
+        //   },
+        //   {
+        //     type: 'password',
+        //     name: 'password',
+        //     message: 'Digite a senha de acesso:',
+        //     mask: '*',
+        //   },
+        // ]);
+    }
+    getMissingFields(input) {
+        return ['name', 'server', 'email', 'password']
+            .filter((key) => !input[key]);
+    }
+    questionFor(field) {
+        const questions = {
+            name: {
+                type: 'input',
+                name: 'name',
+                message: 'Digite o nome da configuração:',
+                validate: (v) => v ? true : 'Nome é obrigatório',
+            },
+            server: {
+                type: 'input',
+                name: 'server',
+                message: 'Digite o endereço do servidor:',
+                validate: (v) => v ? true : 'Servidor é obrigatório',
+            },
+            email: {
+                type: 'input',
+                name: 'email',
+                message: 'Digite seu e-mail:',
+                validate: (v) => v ? true : 'E-mail é obrigatório',
+            },
+            password: {
+                type: 'password',
+                name: 'password',
+                message: 'Digite a senha de acesso:',
+                mask: '*',
+                validate: (v) => v ? true : 'Senha é obrigatória',
+            },
+        };
+        return questions[field];
+    }
+}

package/dist/commands/config/edit.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class ConfigEdit extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        server: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        email: 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>;
+    };
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/edit.js

@@ -0,0 +1,63 @@
+import { Command, Flags, Args } from '@oclif/core';
+import { getStoreValue, setStoreValue } from '../../core/store/index.js';
+import { Buffer } from 'buffer';
+import ora from 'ora';
+export default class ConfigEdit extends Command {
+    static description = 'Edit an existing Proton server connection';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        name: Flags.string({
+            description: 'Nome da configuração',
+            required: false
+        }),
+        server: Flags.string({
+            description: 'Endereço do servidor',
+            required: false
+        }),
+        email: Flags.string({
+            description: 'E-mail de acesso',
+            required: false
+        }),
+        password: Flags.string({
+            description: 'Senha de acesso',
+            required: false
+        })
+    };
+    static args = {
+        name: Args.string()
+    };
+    async run() {
+        const { flags, args } = await this.parse(ConfigEdit);
+        const input = {
+            name: flags.name,
+            server: flags.server,
+            email: flags.email,
+            password: flags.password
+        };
+        const spinner = ora('Editing existing connection').start();
+        try {
+            const configList = getStoreValue('config');
+            const index = configList.findIndex(c => c.name === args.name);
+            if (index === -1) {
+                spinner.fail(`Connection ${args.name} not found`);
+                return;
+            }
+            const editConfig = configList.splice(index, 1)[0];
+            if (input.name)
+                editConfig.name = input.name;
+            if (input.server)
+                editConfig.server = input.server;
+            if (input.email)
+                editConfig.email = input.email;
+            if (input.password)
+                editConfig.password = Buffer.from(input.password).toString('base64');
+            setStoreValue('config', [...configList, editConfig].sort((a, b) => a.order - b.order));
+            spinner.succeed('Connection edited successfully');
+        }
+        catch (err) {
+            spinner.fail('Failed to edit connection');
+        }
+    }
+}

package/dist/commands/config/list.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class ConfigList extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/config/list.js

@@ -0,0 +1,31 @@
+import { Command } from '@oclif/core';
+import { getStoreValue } from '../../core/store/index.js';
+import Table from 'cli-table3';
+import clc from 'cli-color';
+export default class ConfigList extends Command {
+    static description = 'Display a list of configured connections';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(ConfigList);
+        const configList = getStoreValue('config');
+        if (configList.length > 0) {
+            const table = new Table({
+                head: [
+                    clc.blue('order'),
+                    clc.blue('name'),
+                    clc.blue('server'),
+                    clc.blue('username'),
+                ]
+            });
+            for (const connection of configList) {
+                table.push([String(connection.order), connection.name, connection.server, connection.email]);
+            }
+            this.log(table.toString());
+        }
+        else {
+            this.log('No connections found.');
+        }
+    }
+}

package/dist/commands/config/remove.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ConfigRemove extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/remove.js

@@ -0,0 +1,35 @@
+import { Command, Args } from '@oclif/core';
+import { getStoreValue, setStoreValue } from '../../core/store/index.js';
+import ora from 'ora';
+export default class ConfigRemove extends Command {
+    static description = 'Remove an existing Proton server connection';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        name: Args.string()
+    };
+    async run() {
+        const { args } = await this.parse(ConfigRemove);
+        const spinner = ora('Removing existing connection').start();
+        try {
+            const configList = getStoreValue('config');
+            const index = configList.findIndex(c => c.name === args.name);
+            if (index === -1) {
+                spinner.fail(`Connection ${args.name} not found`);
+                return;
+            }
+            const activeConnection = getStoreValue('activeConnection');
+            if (activeConnection && activeConnection.name === args.name) {
+                spinner.fail(`Cannot remove active connection ${args.name}\nPlease disconnect before removing this one.`);
+                return;
+            }
+            configList.splice(index, 1);
+            setStoreValue('config', configList);
+            spinner.succeed(`Connection ${args.name} removed successfully`);
+        }
+        catch (err) {
+            spinner.fail(`Failed to remove connection ${args.name}`);
+        }
+    }
+}

package/dist/commands/connect.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Connect extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/connect.js

@@ -0,0 +1,41 @@
+import { Command, Args } from '@oclif/core';
+import { getStoreValue } from '../core/store/index.js';
+import ora from 'ora';
+import { sendToDaemon } from '../ipc/client.js';
+export default class Connect extends Command {
+    static description = 'Connect to a Proton server using a saved configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        name: Args.string()
+    };
+    async run() {
+        const { args } = await this.parse(Connect);
+        const spinner = ora('Connecting to server...').start();
+        const runnerStatus = getStoreValue('runnerStatus');
+        if (runnerStatus !== 'Offline') {
+            const activeConnection = getStoreValue('activeConnection');
+            spinner.fail(`Already connected to server ${activeConnection.name}. Please disconnect first.`);
+            return;
+        }
+        try {
+            if (!args.name) {
+                spinner.fail('Please provide a connection name');
+                return;
+            }
+            const configList = getStoreValue('config');
+            const index = configList.findIndex(c => c.name === args.name);
+            if (index === -1) {
+                spinner.fail(`Connection ${args.name} not found`);
+                return;
+            }
+            await sendToDaemon({ type: 'connect', data: configList[index] });
+            spinner.succeed(`Connected to ${args.name} successfully`);
+        }
+        catch (err) {
+            console.log(err);
+            spinner.fail(`Failed to connect to ${args.name}`);
+        }
+    }
+}

package/dist/commands/disconnect.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Disconnect extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/disconnect.js

@@ -0,0 +1,30 @@
+import { Command, Args } from '@oclif/core';
+import ora from 'ora';
+import { sendToDaemon } from '../ipc/client.js';
+import { getStoreValue } from '../core/store/index.js';
+export default class Disconnect extends Command {
+    static description = 'Disconnect from a Proton server';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        name: Args.string()
+    };
+    async run() {
+        const { args } = await this.parse(Disconnect);
+        const spinner = ora('Disconnecting from server...').start();
+        const runnerStatus = getStoreValue('runnerStatus');
+        if (runnerStatus === 'Offline') {
+            spinner.warn(`Already disconnected from server. Please connect first.`);
+            return;
+        }
+        try {
+            await sendToDaemon({ type: 'shutdown' });
+            spinner.succeed(`Runner is disconnected`);
+        }
+        catch (err) {
+            console.log(err);
+            spinner.fail(`Failed to disconnect from ${args.name}`);
+        }
+    }
+}

package/dist/commands/runner/list-run.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class RunnerListRun extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/runner/list-run.js

@@ -0,0 +1,71 @@
+import { Command } from '@oclif/core';
+import { getStoreValue } from '../../core/store/index.js';
+import Table from 'cli-table3';
+import clc from 'cli-color';
+export default class RunnerListRun extends Command {
+    static description = 'Retrieve the list of runs executed by the Proton runner';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const {} = await this.parse(RunnerListRun);
+        const runList = getStoreValue('runList');
+        if (runList.length > 0) {
+            const table = new Table({
+                head: [
+                    clc.blue('#id'),
+                    clc.blue('automation'),
+                    clc.blue('version'),
+                    clc.blue('status'),
+                ]
+            });
+            console.log(runList[0].status.length);
+            console.log(getStatus(runList[0].status).length);
+            for (const run of runList) {
+                table.push([String(run.id), run.dataset.automation.name, String(run.dataset.datasetVersion), getStatus(run.status).trim()]);
+            }
+            this.log("🏁 Running List:");
+            this.log(table.toString());
+        }
+        else {
+            this.log('🏁 No active runs found.');
+        }
+        const waitList = getStoreValue('waitList');
+        if (waitList.length > 0) {
+            const table = new Table({
+                head: [
+                    clc.blue('#id'),
+                    clc.blue('automation'),
+                    clc.blue('version'),
+                    clc.blue('status'),
+                ]
+            });
+            for (const run of waitList) {
+                table.push([String(run.id), run.dataset.automation.name, String(run.dataset.datasetVersion), getStatus(run.status)]);
+            }
+            this.log("🚧 Waiting List:");
+            this.log(table.toString());
+        }
+        else {
+            this.log('🚧 No runs on the waiting list.');
+        }
+    }
+}
+function getStatus(status) {
+    switch (status) {
+        case 'Loading':
+            return '⌛' + clc.blue(status);
+        case 'Running':
+            return '🔄 ' + clc.blue(status);
+        case 'Waiting':
+            return '🕒 ' + clc.yellow(status);
+        case 'Stopped':
+            return '⛔ ' + clc.red(status);
+        case 'Failed':
+            return '❌ ' + clc.red(status);
+        case 'Passed':
+            return '✅ ' + clc.green(status);
+        default:
+            return status;
+    }
+}

package/dist/commands/runner/status.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class RunnerStatus extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/runner/status.js

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+import { getStoreValue } from '../../core/store/index.js';
+import ora from 'ora';
+export default class RunnerStatus extends Command {
+    static description = 'Retrieve the status of the Proton runner';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const {} = await this.parse(RunnerStatus);
+        const spinner = ora("Retrieving runner status...").start();
+        try {
+            const status = getStoreValue('runnerStatus');
+            if (!status) {
+                spinner.fail('No runner status found');
+                return;
+            }
+            spinner.succeed(`Runner status: ${status}`);
+        }
+        catch (err) {
+            spinner.fail('Failed to retrieve runner status');
+        }
+    }
+}

package/dist/commands/runner/stop-run.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class RunnerStopRun extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/runner/stop-run.js

@@ -0,0 +1,34 @@
+import { Command, Args } from '@oclif/core';
+import { getStoreValue } from '../../core/store/index.js';
+import { manager } from '../../core/manager/index.js';
+import ora from 'ora';
+export default class RunnerStopRun extends Command {
+    static description = 'Stop selected run';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        id: Args.string()
+    };
+    async run() {
+        const { args } = await this.parse(RunnerStopRun);
+        if (!args.id) {
+            this.log('Please provide a run ID');
+            return;
+        }
+        const spinner = ora("Stopping run...").start();
+        try {
+            const runList = getStoreValue('runList');
+            const index = runList.findIndex(r => r.id === Number(args.id));
+            if (index === -1) {
+                spinner.fail(`Run #${args.id} not found`);
+                return;
+            }
+            await manager.stopRun(runList[index].id);
+            spinner.succeed(`Run #${args.id} stopped successfully`);
+        }
+        catch (err) {
+            spinner.fail(`Failed to stop run #${args.id}`);
+        }
+    }
+}

package/dist/commands/settings/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class SettingsDisplay extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/settings/index.js

@@ -0,0 +1,25 @@
+import { Command } from '@oclif/core';
+import { getStoreValue } from '../../core/store/index.js';
+import ora from 'ora';
+export default class SettingsDisplay extends Command {
+    static description = 'Retrieve the settings of the Proton runner';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>'
+    ];
+    async run() {
+        const {} = await this.parse(SettingsDisplay);
+        const spinner = ora('Retrieving settings...').start();
+        try {
+            const settings = getStoreValue('settings');
+            if (!settings) {
+                spinner.fail('No settings found');
+                return;
+            }
+            spinner.succeed(`Maven Path: ${settings.mavenPath ? settings.mavenPath : 'Not set'}`);
+            spinner.succeed(`Parallel Runs: ${settings.parallelRuns}`);
+        }
+        catch (err) {
+            spinner.fail('Failed to retrieve settings');
+        }
+    }
+}

package/dist/commands/settings/set.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class SettingsSet extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        mavenPath: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        parallelRuns: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/settings/set.js

@@ -0,0 +1,39 @@
+import { Command, Flags } from '@oclif/core';
+import { getStoreValue, setStoreValue } from '../../core/store/index.js';
+import ora from 'ora';
+export default class SettingsSet extends Command {
+    static description = 'Set Proton server settings';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        mavenPath: Flags.string({
+            description: 'Caminho do Maven (ex: C:\\maven\\bin\\mvn.cmd)',
+            required: false
+        }),
+        parallelRuns: Flags.string({
+            description: 'Número de execuções paralelas',
+            required: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(SettingsSet);
+        const input = {
+            mavenPath: flags.mavenPath,
+            parallelRuns: Number(flags.parallelRuns)
+        };
+        const spinner = ora('Updating settings...').start();
+        try {
+            const settings = getStoreValue('settings');
+            const newSettings = {
+                mavenPath: input.mavenPath || settings.mavenPath,
+                parallelRuns: input.parallelRuns || settings.parallelRuns,
+            };
+            setStoreValue('settings', newSettings);
+            spinner.succeed('Settings updated successfully');
+        }
+        catch (err) {
+            spinner.fail('Failed to update settings');
+        }
+    }
+}

package/dist/commands/settings/unset.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class SettingsUnset extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        mavenPath: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        parallelRuns: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}