@atomicsolutions/proton5-cli 5.0.1

package/dist/core/system/index.js

@@ -0,0 +1,48 @@
+import os from 'os';
+import * as $ from '../../shared/constants.js';
+export async function getOS() {
+    let opSys = "";
+    switch (process.platform) {
+        case 'darwin':
+            opSys = $.CST_OS_MAC;
+            break;
+        case 'win32':
+            opSys = $.CST_OS_WIN;
+            break;
+        case 'linux':
+            opSys = $.CST_OS_LINUX;
+            break;
+    }
+    return {
+        hostname: os.hostname(),
+        ip: getLocalIpAddress(),
+        macAddress: getFirstMacAddress(),
+        operatingSystem: opSys,
+        architecture: process.arch,
+        availableProcessors: os.cpus().length,
+        freeMemory: os.freemem() / 1024,
+        totalMemory: os.totalmem() / 1024
+    };
+}
+export function getLocalIpAddress() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const net of interfaces[name] || []) {
+            if (net.family === 'IPv4' && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    return null;
+}
+export function getFirstMacAddress() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const net of interfaces[name] || []) {
+            if (net.mac && net.mac !== '00:00:00:00:00:00') {
+                return net.mac;
+            }
+        }
+    }
+    return null;
+}

package/dist/daemon/index.d.ts

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

package/dist/daemon/index.js

@@ -0,0 +1,5 @@
+import { startIpcServer } from './server.js';
+console.log('Daemon iniciado');
+startIpcServer();
+// evita encerramento
+setInterval(() => { }, 1000);

package/dist/daemon/server.d.ts

@@ -0,0 +1 @@
+export declare function startIpcServer(): void;

package/dist/daemon/server.js

@@ -0,0 +1,40 @@
+console.log('Daemon starting...');
+import net from 'net';
+import fs from 'fs';
+import { SOCKET_PATH } from '../shared/socketPath.js';
+import { handleRequest } from './state.js';
+import { runner } from '../core/runner/index.js';
+export function startIpcServer() {
+    if (process.platform !== 'win32' && fs.existsSync(SOCKET_PATH)) {
+        fs.unlinkSync(SOCKET_PATH);
+    }
+    const server = net.createServer(socket => {
+        socket.on('data', async (data) => {
+            const msg = JSON.parse(data.toString());
+            if (msg.type === 'shutdown') {
+                await runner.setDisconnected();
+                socket.write(JSON.stringify({ ok: true }));
+                socket.end();
+                console.log('Daemon shutting down...');
+                server.close(() => {
+                    process.exit(0);
+                });
+                return;
+            }
+            try {
+                const req = JSON.parse(data.toString());
+                const res = await handleRequest(req);
+                socket.write(JSON.stringify({ ok: true, data: res }));
+            }
+            catch (err) {
+                socket.write(JSON.stringify({ ok: false, error: err.message }));
+            }
+        });
+    });
+    server.listen(SOCKET_PATH, () => {
+        console.log('Daemon listening');
+    });
+    server.on('error', err => {
+        console.error('Daemon server error:', err);
+    });
+}

package/dist/daemon/state.d.ts

@@ -0,0 +1,7 @@
+export declare function handleRequest(req: any): Promise<"Offline" | "Connecting" | "Idle" | "Busy" | {
+    ok: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    ok?: undefined;
+}>;

package/dist/daemon/state.js

@@ -0,0 +1,15 @@
+import { runner } from '../core/runner/index.js';
+export async function handleRequest(req) {
+    switch (req.type) {
+        case 'status':
+            return runner.getStatus();
+        case 'connect':
+            await runner.connect(req.data);
+            return { ok: true };
+        case 'disconnect':
+            await runner.setDisconnected();
+            return { ok: true };
+        default:
+            return { error: 'Comando desconhecido' };
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/ipc/client.d.ts

@@ -0,0 +1 @@
+export declare function sendToDaemon(message: any): Promise<any>;

package/dist/ipc/client.js

@@ -0,0 +1,16 @@
+import net from 'net';
+import { SOCKET_PATH } from '../shared/socketPath.js';
+import { ensureDaemonRunning } from './ensureDaemon.js';
+export async function sendToDaemon(message) {
+    await ensureDaemonRunning();
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(SOCKET_PATH, () => {
+            client.write(JSON.stringify(message));
+        });
+        client.on('data', data => {
+            resolve(JSON.parse(data.toString()));
+            client.end();
+        });
+        client.on('error', reject);
+    });
+}

package/dist/ipc/ensureDaemon.d.ts

@@ -0,0 +1 @@
+export declare function ensureDaemonRunning(): Promise<void>;

package/dist/ipc/ensureDaemon.js

@@ -0,0 +1,42 @@
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { SOCKET_PATH } from '../shared/socketPath.js';
+const isDev = process.env.NODE_ENV !== 'production';
+function tryConnect() {
+    return new Promise(resolve => {
+        const socket = net.createConnection(SOCKET_PATH);
+        socket.once('connect', () => {
+            socket.end();
+            resolve(true);
+        });
+        socket.once('error', () => {
+            resolve(false);
+        });
+    });
+}
+export async function ensureDaemonRunning() {
+    const isRunning = await tryConnect();
+    if (isRunning)
+        return;
+    // daemon não existe → iniciar
+    const daemonEntry = isDev
+        ? path.resolve(process.cwd(), 'src/daemon/index.ts')
+        : path.resolve(process.cwd(), 'dist/daemon/index.js');
+    const cmd = isDev
+        ? ['node_modules/tsx/dist/cli.mjs', daemonEntry]
+        : [daemonEntry];
+    spawn(process.execPath, cmd, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true
+    }).unref();
+    // aguarda o daemon subir
+    const timeout = Date.now() + 3000;
+    while (Date.now() < timeout) {
+        if (await tryConnect())
+            return;
+        await new Promise(r => setTimeout(r, 100));
+    }
+    throw new Error('Não foi possível iniciar o daemon');
+}

package/dist/ipc/protocol.d.ts

@@ -0,0 +1,14 @@
+export type DaemonRequest = {
+    type: 'status';
+} | {
+    type: 'connect';
+} | {
+    type: 'disconnect';
+};
+export type DaemonResponse = {
+    ok: true;
+    data?: any;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/ipc/protocol.js

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

package/dist/shared/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CST_OS_WIN = "win";
+export declare const CST_OS_LINUX = "linux";
+export declare const CST_OS_MAC = "mac";
+export declare const CST_CLIENT_VERSION = "5.0.0";

package/dist/shared/constants.js

@@ -0,0 +1,4 @@
+export const CST_OS_WIN = 'win';
+export const CST_OS_LINUX = 'linux';
+export const CST_OS_MAC = 'mac';
+export const CST_CLIENT_VERSION = '5.0.0';

package/dist/shared/socketPath.d.ts

@@ -0,0 +1 @@
+export declare const SOCKET_PATH: string;

package/dist/shared/socketPath.js

@@ -0,0 +1,5 @@
+import os from 'os';
+import path from 'path';
+export const SOCKET_PATH = process.platform === 'win32'
+    ? '\\\\.\\pipe\\proton5-daemon'
+    : path.join(os.tmpdir(), 'proton5-daemon.sock');

package/dist/shared/types.d.ts

@@ -0,0 +1,130 @@
+export interface ISettings {
+    mavenPath: string;
+    parallelRuns: number;
+}
+export interface IConnection {
+    name: string;
+    server: string;
+    email: string;
+    password: string;
+    privateMode: boolean;
+    statusNotification: boolean;
+    token: string;
+    order: number;
+}
+export type ConfigInput = {
+    name: string;
+    server: string;
+    email: string;
+    password: string;
+};
+export interface IRunConfig {
+    dir: string;
+    idDatasetRun: number;
+    reference: string | null;
+}
+export interface IProtonRunProcess {
+    idDatasetRun: number;
+    processId: number;
+}
+export interface IProtonRunPackage {
+    datasetRun: Array<IDatasetRun>;
+    system: Array<ISystem>;
+}
+export type RunnerStatus = 'Offline' | 'Connecting' | 'Idle' | 'Busy';
+export type RunnerUpdateStatus = 'checking' | 'available' | 'notAvailable';
+export interface IAppStoreData {
+    settings: ISettings;
+    config: IConnection[];
+    activeConnection: IConnection | null;
+    headerStyle: string;
+    process: IProtonRunProcess[];
+    hasUpdate: string;
+    connected: boolean;
+    runnerStatus: "Offline" | "Connecting" | "Idle" | "Busy";
+    runList: IDatasetRun[];
+    waitList: IDatasetRun[];
+    msgPanel: string;
+    alertMsg: IAlertMsg | null;
+}
+export interface IAlertMsg {
+    type: 'info' | 'warning' | 'error' | 'success';
+    msg: string;
+}
+export interface IDatasetRun {
+    id: number;
+    idDataset: number;
+    idCycle: number;
+    idScheduleRun: number;
+    idRunner: number;
+    idUser: number;
+    idStatus: number;
+    idPriority: number;
+    device: string | null;
+    app: string | null;
+    executionDate: string;
+    idErrorStrategy: number | null;
+    externalId: string | null;
+    status: string;
+    system: ISystem[];
+    isRunning: boolean;
+    isComplete: boolean;
+    isUploadingResults: boolean;
+    dataset: {
+        id: number;
+        idCategory: number;
+        idAutomation: number;
+        datasetVersion: number;
+        description: string;
+        automation: {
+            id: number;
+            name: string;
+            idBusinessProcess: number;
+            mobile: boolean;
+            reference: string;
+            description: string;
+            private: boolean;
+            createdBy: number;
+            createdAt: string;
+        };
+    };
+}
+export interface ISystem {
+    id: number;
+    idGitRepository: number;
+    name: string;
+    gitRepository: IRepoData;
+}
+export interface IRepoData {
+    id: number;
+    platform: string;
+    owner: string;
+    repository: string;
+    defaultBranch: string;
+    remoteAuthorization: string;
+    description: string | null;
+    repoId: string;
+    bddRepo: boolean;
+    branches: string[];
+    headerHash?: string;
+}
+export type TSocketData = {
+    server: string;
+    email: string;
+    password: string;
+    privateMode: boolean;
+    statusNotification: boolean;
+};
+export type TSocketAuthorization = {
+    authorized: boolean;
+    token?: string;
+    msg: string;
+};
+export type TUpdateRunData = {
+    idDatasetRun: number;
+    status: string;
+};
+export interface InitiateProcessOptions {
+    cwd: string;
+    args: string[];
+}

package/dist/shared/types.js

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