@atomicsolutions/proton5-cli 5.0.1

package/dist/core/proton/npm.d.ts

@@ -0,0 +1 @@
+export declare function runNpmInstall(dir: string): Promise<number>;

package/dist/core/proton/npm.js

@@ -0,0 +1,22 @@
+import os from 'os';
+import { spawn } from 'child_process';
+export async function runNpmInstall(dir) {
+    const homedir = os.homedir();
+    const repoLocalDir = String(homedir.replace(/[\\]/, '/') + '/.proton-runner-repo/' + dir).replace(/[\\]/, '/');
+    const exitCode = await executeProcess(repoLocalDir);
+    return exitCode;
+}
+function executeProcess(repoLocalDir) {
+    return new Promise(async (resolve) => {
+        try {
+            let pwCmd = ['install'];
+            const proc = spawn('npm', pwCmd, { cwd: repoLocalDir, shell: true });
+            proc.on('close', async (code) => {
+                resolve(Number(code));
+            });
+        }
+        catch (err) {
+            resolve(1);
+        }
+    });
+}

package/dist/core/proton/playwright.d.ts

@@ -0,0 +1,5 @@
+import type { IRunConfig } from '#types';
+export default class Playwright {
+    static runScript(runConfig: IRunConfig): Promise<number>;
+    private static executeProcess;
+}

package/dist/core/proton/playwright.js

@@ -0,0 +1,47 @@
+import os from 'os';
+import { spawn } from 'child_process';
+import { runner } from '../runner/index.js';
+import { uploadLogFile } from './api.js';
+import { manager } from '../manager/index.js';
+export default class Playwright {
+    static async runScript(runConfig) {
+        const homedir = os.homedir();
+        const repoLocalDir = String(homedir + '/.proton-runner-repo/' + runConfig.dir).replace('\\', '/').replace('\\', '/');
+        const exitCode = await this.executeProcess(repoLocalDir, runConfig.idDatasetRun, runConfig.reference || '');
+        return exitCode;
+    }
+    static executeProcess(repoLocalDir, idDatasetRun, _reference) {
+        const activeConnection = runner.getActiveConnection();
+        if (!activeConnection) {
+            return Promise.resolve(1);
+        }
+        return new Promise(async (resolve) => {
+            try {
+                let pwCmd = ['./run-test.ts', `--id_dataset_run=${idDatasetRun}`];
+                const proc = spawn('node', pwCmd, { cwd: repoLocalDir, shell: true });
+                if (!proc.pid) {
+                    resolve(1);
+                    return;
+                }
+                manager.addProcess(idDatasetRun, proc.pid);
+                let log = '';
+                proc.stdout.setEncoding('latin1');
+                proc.stdout.on('data', (data) => {
+                    log += data;
+                });
+                proc.on('close', async (code) => {
+                    try {
+                        await uploadLogFile(idDatasetRun, log);
+                    }
+                    catch (err) {
+                        console.log('Erro ao gerar arquivo de log');
+                    }
+                    resolve(Number(code));
+                });
+            }
+            catch (err) {
+                resolve(1);
+            }
+        });
+    }
+}

package/dist/core/proton/pyTest.d.ts

@@ -0,0 +1,5 @@
+import type { IRunConfig } from '#types';
+export default class PyTest {
+    static runScript(runConfig: IRunConfig): Promise<number>;
+    private static executeProcess;
+}

package/dist/core/proton/pyTest.js

@@ -0,0 +1,52 @@
+import os from 'os';
+import { spawn } from 'child_process';
+import { runner } from '../runner/index.js';
+import { uploadLogFile } from './api.js';
+import { manager } from '../manager/index.js';
+export default class PyTest {
+    static async runScript(runConfig) {
+        const homedir = os.homedir();
+        const repoLocalDir = String(homedir + '/.proton-runner-repo/' + runConfig.dir).replace('\\', '/').replace('\\', '/');
+        const exitCode = await this.executeProcess(repoLocalDir, runConfig.idDatasetRun, runConfig.reference || '');
+        return exitCode;
+    }
+    static executeProcess(repoLocalDir, idDatasetRun, _reference) {
+        const activeConnection = runner.getActiveConnection();
+        if (!activeConnection) {
+            return Promise.resolve(1);
+        }
+        return new Promise((resolve) => {
+            try {
+                let pyCmd = ['run', 'pytest', 'tests/test_proton_script.py::test_run_proton_execution', `--id_dataset_run=${idDatasetRun}`];
+                const proc = spawn('uv', pyCmd, { cwd: repoLocalDir, shell: true });
+                if (!proc.pid) {
+                    resolve(1);
+                    return;
+                }
+                manager.addProcess(idDatasetRun, proc.pid);
+                let log = '';
+                proc.stdout.setEncoding('latin1');
+                proc.stdout.on('data', (data) => {
+                    log += data;
+                });
+                proc.on('close', async (code) => {
+                    try {
+                        await uploadLogFile(idDatasetRun, log);
+                    }
+                    catch (err) {
+                        console.log('Erro ao gerar arquivo de log');
+                    }
+                    if (code !== null) {
+                        resolve(code);
+                    }
+                    else {
+                        resolve(1);
+                    }
+                });
+            }
+            catch (err) {
+                resolve(1);
+            }
+        });
+    }
+}

package/dist/core/proton/vbs.d.ts

@@ -0,0 +1,5 @@
+import type { IRunConfig } from '#types';
+export default class VBScript {
+    static runScript(runConfig: IRunConfig): Promise<number>;
+    private static executeProcess;
+}

package/dist/core/proton/vbs.js

@@ -0,0 +1,46 @@
+import os from 'os';
+import { spawn } from 'child_process';
+import { runner } from '../runner/index.js';
+import { uploadLogFile } from './api.js';
+import { manager } from '../manager/index.js';
+export default class VBScript {
+    static async runScript(runConfig) {
+        const homedir = os.homedir();
+        const repoLocalDir = String(homedir + '/.proton-runner-repo/' + runConfig.dir).replace('\\', '/').replace('\\', '/');
+        const exitCode = await this.executeProcess(repoLocalDir, runConfig.idDatasetRun, runConfig.reference || '');
+        return exitCode;
+    }
+    static executeProcess(repoLocalDir, idDatasetRun, _reference) {
+        const activeConnection = runner.getActiveConnection();
+        if (!activeConnection) {
+            return Promise.resolve(1);
+        }
+        return new Promise((resolve) => {
+            try {
+                const proc = spawn('wscript', ["SAP_Runner.vbs", String(idDatasetRun), `"${repoLocalDir}"`], { cwd: repoLocalDir, shell: true });
+                if (!proc.pid) {
+                    resolve(1);
+                    return;
+                }
+                manager.addProcess(idDatasetRun, proc.pid);
+                let log = '';
+                proc.stdout.setEncoding('latin1');
+                proc.stdout.on('data', (data) => {
+                    log += data;
+                });
+                proc.on('close', async (code) => {
+                    try {
+                        await uploadLogFile(idDatasetRun, log);
+                    }
+                    catch (err) {
+                        console.log('Erro ao gerar arquivo de log');
+                    }
+                    resolve(code);
+                });
+            }
+            catch (err) {
+                resolve(1);
+            }
+        });
+    }
+}

package/dist/core/runner/index.d.ts

@@ -0,0 +1,16 @@
+import type { IAlertMsg, IConnection, RunnerStatus } from "#types";
+export declare class Runner {
+    connect(connection: IConnection): Promise<void>;
+    setConnectionError(msg: string): Promise<void>;
+    getActiveConnection(): IConnection | null;
+    getMavenPath(): string;
+    setConnected(token: string): Promise<void>;
+    isConnected(): boolean;
+    setDisconnected(): Promise<void>;
+    getStatus(): RunnerStatus;
+    setStatus(runnerStatus: RunnerStatus): Promise<void>;
+    setAlertMsg(alertMsg: IAlertMsg | null): void;
+    setMsgPanel(msg: string): void;
+    clearMsgPanel(): void;
+}
+export declare const runner: Runner;

package/dist/core/runner/index.js

@@ -0,0 +1,76 @@
+import { connectToServer } from "../socket/index.js";
+import { getStoreValue, setStoreValue } from '../store/index.js';
+import { DateTime } from "luxon";
+import i18n from 'i18next';
+import { manager } from "../manager/index.js";
+import path from "path";
+import { updateRunnerStatus } from "../proton/api.js";
+export class Runner {
+    async connect(connection) {
+        setStoreValue("activeConnection", connection);
+        connectToServer(connection);
+    }
+    async setConnectionError(msg) {
+        await this.setStatus("Offline");
+        setStoreValue("connected", false);
+        setStoreValue("activeConnection", null);
+        setStoreValue("alertMsg", { type: 'error', msg });
+        setTimeout(() => {
+            setStoreValue("alertMsg", null);
+        }, 3000);
+    }
+    getActiveConnection() {
+        return getStoreValue("activeConnection");
+    }
+    getMavenPath() {
+        const settings = getStoreValue("settings");
+        return path.join(settings.mavenPath, 'bin', 'mvn.cmd');
+    }
+    async setConnected(token) {
+        const activeConnection = getStoreValue("activeConnection");
+        setStoreValue("activeConnection", { ...activeConnection, token });
+        this.setMsgPanel(`✅ **${i18n.t("msgPanel.runnerConnected")}**`);
+        setStoreValue("connected", true);
+        await this.setStatus("Idle");
+    }
+    isConnected() {
+        return getStoreValue("connected");
+    }
+    async setDisconnected() {
+        const runList = getStoreValue("runList") || [];
+        runList.forEach(async (run) => {
+            await manager.stopRun(run.id);
+        });
+        setStoreValue("connected", false);
+        await this.setStatus("Offline");
+        setStoreValue("activeConnection", null);
+        this.clearMsgPanel();
+        manager.clearRunList();
+        manager.clearWaitList();
+    }
+    getStatus() {
+        return getStoreValue("runnerStatus");
+    }
+    async setStatus(runnerStatus) {
+        setStoreValue("runnerStatus", runnerStatus);
+        await updateRunnerStatus(runnerStatus);
+        if (runnerStatus === "Offline") {
+            setStoreValue("connected", false);
+            setStoreValue("activeConnection", null);
+        }
+        else {
+            setStoreValue("connected", true);
+        }
+    }
+    setAlertMsg(alertMsg) {
+        setStoreValue("alertMsg", alertMsg);
+    }
+    setMsgPanel(msg) {
+        const currentMsg = getStoreValue("msgPanel") || "";
+        setStoreValue("msgPanel", currentMsg + DateTime.now().toFormat("dd-MM-yyyy HH:mm:ss") + ": " + msg + "\n");
+    }
+    clearMsgPanel() {
+        setStoreValue("msgPanel", "");
+    }
+}
+export const runner = new Runner();

package/dist/core/services/api.d.ts

@@ -0,0 +1,2 @@
+declare let api: import("axios").AxiosInstance;
+export default api;

package/dist/core/services/api.js

@@ -0,0 +1,20 @@
+import axios from 'axios';
+const defaultOptions = {
+    headers: {
+        'Content-Type': 'application/json',
+        platform: 'client'
+    }
+};
+// Criar instância
+let api = axios.create(defaultOptions);
+api.interceptors.response.use((response) => {
+    return response;
+}, function (error) {
+    if (error.response) {
+        return Promise.resolve(error.response);
+    }
+    else {
+        return Promise.resolve({ ...error, status: 500 });
+    }
+});
+export default api;

package/dist/core/socket/index.d.ts

@@ -0,0 +1,2 @@
+import type { IConnection } from '#types';
+export declare function connectToServer(config: IConnection): void;

package/dist/core/socket/index.js

@@ -0,0 +1,99 @@
+import { io } from 'socket.io-client';
+import { getOS } from '../system/index.js';
+import * as $ from '../../shared/constants.js';
+import { runner } from '../runner/index.js';
+import { manager } from '../manager/index.js';
+import { setStoreValue } from '../store/index.js';
+let socket = null;
+export function connectToServer(config) {
+    if (socket)
+        return;
+    socket = io(`${config.server}/proton-runner`, {
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 1000,
+        reconnectionDelayMax: 5000,
+    });
+    socket.on('connect', async () => {
+        const machineParams = await getOS();
+        const connectionData = {
+            email: config.email,
+            password: config.password,
+            ip: machineParams.ip,
+            macAddress: machineParams.macAddress,
+            hostname: machineParams.hostname,
+            version: $.CST_CLIENT_VERSION,
+            operatingSystem: machineParams.operatingSystem,
+            architecture: machineParams.architecture,
+            availableProcessors: machineParams.availableProcessors,
+            freeMemory: machineParams.freeMemory,
+            totalMemory: machineParams.totalMemory,
+            privateMode: config.privateMode,
+            statusNotification: config.statusNotification
+        };
+        if (socket) {
+            socket.emit('authenticate', connectionData);
+        }
+    });
+    socket.on('authorized', async (data) => {
+        try {
+            if (data.authorized && data.token) {
+                setStoreValue("activeConnection", { ...config, token: data.token });
+                await runner.setConnected(data.token);
+            }
+            else {
+                await runner.setConnectionError(data.msg);
+            }
+        }
+        catch (err) {
+            console.error('[socket] Error handling authorized event:', err);
+        }
+    });
+    socket.on('connect_error', (err) => {
+        // Não desconectar manualmente aqui — o socket.io gerencia a reconexão automaticamente.
+        // Chamar socket.disconnect() cancelaria o reconnection: true.
+        console.log('[socket] connect_error:', err.message);
+    });
+    socket.on('submitRun', async (data, callback) => {
+        const newRun = [];
+        if (data.datasetRun) {
+            data.datasetRun.forEach((datasetRun) => {
+                newRun.push({
+                    ...datasetRun,
+                    status: 'Waiting',
+                    system: data.system,
+                    isRunning: false,
+                    isComplete: false,
+                    isUploadingResults: false
+                });
+            });
+        }
+        manager.addToWaitList(newRun);
+        callback('ack');
+    });
+    socket.on('updateRunStatus', async (data) => {
+        manager.updateRun(data.idDatasetRun, { status: data.status });
+    });
+    socket.on("error", (error) => {
+        console.log('[socket] error:', error);
+    });
+    socket.on('disconnect', reason => {
+        console.log('[socket] disconnected:', reason);
+        // Se o servidor fechou a conexão ativamente, reconectar manualmente,
+        // pois o socket.io não tenta reconectar automaticamente nesse caso.
+        if (reason === 'io server disconnect') {
+            socket?.connect();
+        }
+    });
+    socket.on('reconnect', attempt => {
+        console.log('[socket] reconnected after', attempt, 'attempt(s)');
+    });
+    socket.on('reconnect_error', (err) => {
+        console.log('[socket] reconnect_error:', err.message);
+    });
+    socket.on('reconnect_failed', () => {
+        console.log('[socket] reconnect_failed — giving up');
+        runner.setConnectionError('serverConnectionError').catch(console.error);
+        socket = null;
+    });
+}

package/dist/core/store/index.d.ts

@@ -0,0 +1,14 @@
+import Conf from 'conf';
+import type { IAppStoreData, IConnection } from '#types';
+export declare const store: Conf<IAppStoreData>;
+/**
+ * Read a value from the store using dot-path
+ * Ex: get("settings.mavenPath")
+ */
+export declare function getStoreValue<K extends keyof IAppStoreData>(key: K): IAppStoreData[K];
+/**
+ * Write a value to the store
+ * Ex: setStoreValue("settings.mavenPath", "/usr/bin/mvn")
+ */
+export declare function setStoreValue(key: string, value: any): void;
+export declare function addConfigItem(newConfig: IConnection): Promise<void>;

package/dist/core/store/index.js

@@ -0,0 +1,212 @@
+import Conf from 'conf';
+const schema = {
+    settings: {
+        type: "object",
+        properties: {
+            mavenPath: { type: "string" },
+            parallelRuns: { type: "number" }
+        }
+    },
+    config: {
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                server: { type: "string" },
+                email: { type: "string" },
+                password: { type: "string" },
+                privateMode: { type: "boolean" },
+                statusNotification: { type: "boolean" },
+                token: { type: "string" },
+                order: { type: "number" }
+            }
+        }
+    },
+    activeConnection: {
+        type: ["object", "null"],
+        properties: {
+            name: { type: "string" },
+            server: { type: "string" },
+            email: { type: "string" },
+            password: { type: "string" },
+            privateMode: { type: "boolean" },
+            statusNotification: { type: "boolean" },
+            token: { type: "string" },
+            order: { type: "number" }
+        }
+    },
+    headerStyle: { type: "string" },
+    process: {
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                idDatasetRun: { type: "number" },
+                processId: { type: "number" }
+            }
+        }
+    },
+    hasUpdate: { type: "string" },
+    connected: { type: "boolean" },
+    runnerStatus: { type: "string" },
+    runList: {
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                id: { type: "number" },
+                idDataset: { type: "number" },
+                idCycle: { type: "number" },
+                idScheduleRun: { type: "number" },
+                idRunner: { type: "number" },
+                idUser: { type: "number" },
+                idStatus: { type: "number" },
+                idPriority: { type: "number" },
+                device: { type: ["string", "null"] },
+                app: { type: ["string", "null"] },
+                executionDate: { type: "string" },
+                idErrorStrategy: { type: ["number", "null"] },
+                externalId: { type: ["string", "null"] },
+                status: { type: "string" },
+                system: { type: "array" },
+                isRunning: { type: "boolean" },
+                isComplete: { type: "boolean" },
+                isUploadingResults: { type: "boolean" },
+                dataset: {
+                    type: "object",
+                    properties: {
+                        id: { type: "number" },
+                        idCategory: { type: "number" },
+                        idAutomation: { type: "number" },
+                        datasetVersion: { type: "number" },
+                        description: { type: ["string", "null"] },
+                        automation: {
+                            type: "object",
+                            properties: {
+                                id: { type: "number" },
+                                name: { type: "string" },
+                                idBusinessProcess: { type: "number" },
+                                mobile: { type: "boolean" },
+                                reference: { type: ["string", "null"] },
+                                description: { type: ["string", "null"] },
+                                private: { type: "boolean" },
+                                createdBy: { type: "number" },
+                                createdAt: { type: "string" }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    waitList: {
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                id: { type: "number" },
+                idDataset: { type: "number" },
+                idCycle: { type: "number" },
+                idScheduleRun: { type: "number" },
+                idRunner: { type: "number" },
+                idUser: { type: "number" },
+                idStatus: { type: "number" },
+                idPriority: { type: "number" },
+                device: { type: ["string", "null"] },
+                app: { type: ["string", "null"] },
+                executionDate: { type: "string" },
+                idErrorStrategy: { type: ["number", "null"] },
+                externalId: { type: ["string", "null"] },
+                status: { type: "string" },
+                system: { type: "array" },
+                isRunning: { type: "boolean" },
+                isComplete: { type: "boolean" },
+                isUploadingResults: { type: "boolean" },
+                dataset: {
+                    type: "object",
+                    properties: {
+                        id: { type: "number" },
+                        idCategory: { type: "number" },
+                        idAutomation: { type: "number" },
+                        datasetVersion: { type: "number" },
+                        description: { type: ["string", "null"] },
+                        automation: {
+                            type: "object",
+                            properties: {
+                                id: { type: "number" },
+                                name: { type: "string" },
+                                idBusinessProcess: { type: "number" },
+                                mobile: { type: "boolean" },
+                                reference: { type: ["string", "null"] },
+                                description: { type: ["string", "null"] },
+                                private: { type: "boolean" },
+                                createdBy: { type: "number" },
+                                createdAt: { type: "string" }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    msgPanel: { type: "string" },
+    alertMsg: {
+        type: ["object", "null"],
+        properties: {
+            type: { type: "string" },
+            msg: { type: "string" }
+        }
+    }
+};
+export const store = new Conf({
+    projectName: 'proton-runner',
+    projectSuffix: 'store',
+    schema,
+    defaults: {
+        connected: false,
+        runnerStatus: 'Offline',
+        msgPanel: '',
+        alertMsg: null,
+        headerStyle: 'light',
+        hasUpdate: '',
+        activeConnection: null,
+        config: [],
+        process: [],
+        runList: [],
+        waitList: [],
+        settings: {
+            mavenPath: '',
+            parallelRuns: 1
+        }
+    }
+});
+export function getStoreValue(key) {
+    return store.get(key);
+}
+/**
+ * Write a value to the store
+ * Ex: setStoreValue("settings.mavenPath", "/usr/bin/mvn")
+ */
+export function setStoreValue(key, value) {
+    store.set(key, value);
+}
+// export function subscribeStoreChanges(win: BrowserWindow) {
+//   const s = getStoreInstance();
+//   s.onDidAnyChange((newStore: any, oldStore: any) => {
+//     if (!newStore || !oldStore) return;
+//     Object.keys(newStore).forEach((key) => {
+//       if (newStore[key] !== oldStore[key]) {
+//         win.webContents.send("store:changed", {
+//           key,
+//           newValue: newStore[key],
+//           oldValue: oldStore[key]
+//         });
+//       }
+//     });
+//   });
+// }
+export async function addConfigItem(newConfig) {
+    const list = getStoreValue("config");
+    setStoreValue("config", [...list, newConfig]);
+}

package/dist/core/system/index.d.ts

@@ -0,0 +1,12 @@
+export declare function getOS(): Promise<{
+    hostname: string;
+    ip: string | null;
+    macAddress: string | null;
+    operatingSystem: string;
+    architecture: NodeJS.Architecture;
+    availableProcessors: number;
+    freeMemory: number;
+    totalMemory: number;
+}>;
+export declare function getLocalIpAddress(): string | null;
+export declare function getFirstMacAddress(): string | null;