vh-dev-helper 0.0.0-stage → 1.0.0

package/dist/src/dashboards/collectors/project/project.collector.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectInfo = getProjectInfo;
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+async function getProjectInfo() {
+    let gitBranch = "unknown";
+    let tsVersion = "not found";
+    try {
+        gitBranch = (0, child_process_1.execSync)("git branch --show-current").toString().trim();
+    }
+    catch { }
+    try {
+        tsVersion = (0, child_process_1.execSync)("tsc -v").toString().trim();
+    }
+    catch { }
+    return {
+        nodeVersion: process.version,
+        tsVersion,
+        platform: os_1.default.platform(),
+        hostname: os_1.default.hostname(),
+        pid: process.pid,
+        cwd: process.cwd(),
+        gitBranch,
+    };
+}

package/dist/src/dashboards/project/backend/server/dashboard.bootstrap.d.ts

@@ -0,0 +1,6 @@
+type BootstrapOptions = {
+    command: string;
+    args: string[];
+};
+export declare function dashboardBootstrap({ command, args }: BootstrapOptions): Promise<void>;
+export {};

package/dist/src/dashboards/project/backend/server/dashboard.bootstrap.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardBootstrap = dashboardBootstrap;
+const open_1 = __importDefault(require("open"));
+const dashboard_server_1 = require("./dashboard.server");
+const websocket_server_1 = require("./websocket.server");
+const process_wrapper_1 = require("../wrapper/process.wrapper");
+const metrics_service_1 = require("../services/metrics.service");
+async function dashboardBootstrap({ command, args }) {
+    try {
+        console.log("\n🚀 Starting Project Dashboard\n");
+        /*
+         * start http server
+         */
+        const server = await dashboard_server_1.dashboardServer.start();
+        /*
+         * attach websocket
+         */
+        websocket_server_1.websocketServer.attach(server);
+        /*
+         * start wrapped project
+         */
+        await process_wrapper_1.processWrapper.start({
+            command,
+            args,
+        });
+        /*
+         * start metrics collection
+         */
+        metrics_service_1.metricsService.start();
+        /*
+         * open browser
+         */
+        await (0, open_1.default)("http://localhost:5173");
+        console.log("✅ Dashboard Ready\n");
+    }
+    catch (error) {
+        console.log("❌ Failed to start dashboard");
+        console.error(error);
+        process.exit(1);
+    }
+}

package/dist/src/dashboards/project/backend/server/dashboard.server.d.ts

@@ -0,0 +1,6 @@
+import http from "http";
+declare class DashboardServer {
+    start(): Promise<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;
+}
+export declare const dashboardServer: DashboardServer;
+export {};

package/dist/src/dashboards/project/backend/server/dashboard.server.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardServer = void 0;
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+class DashboardServer {
+    async start() {
+        const app = (0, express_1.default)();
+        app.get("/health", (_req, res) => {
+            res.send("dashboard alive");
+        });
+        const server = http_1.default.createServer(app);
+        await new Promise((resolve) => {
+            server.listen(4545, () => {
+                console.log("Dashboard API : http://localhost:4545");
+                resolve(true);
+            });
+        });
+        return server;
+    }
+}
+exports.dashboardServer = new DashboardServer();

package/dist/src/dashboards/project/backend/server/websocket.server.d.ts

@@ -0,0 +1,8 @@
+import { Server } from "http";
+declare class WebsocketServer {
+    private wss?;
+    attach(server: Server): void;
+    emit(event: string, payload: unknown): void;
+}
+export declare const websocketServer: WebsocketServer;
+export {};

package/dist/src/dashboards/project/backend/server/websocket.server.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.websocketServer = void 0;
+const ws_1 = require("ws");
+class WebsocketServer {
+    wss;
+    attach(server) {
+        this.wss = new ws_1.WebSocketServer({
+            server,
+        });
+        this.wss.on("connection", () => {
+            console.log("Dashboard connected");
+        });
+    }
+    emit(event, payload) {
+        if (!this.wss) {
+            return;
+        }
+        const message = JSON.stringify({
+            event,
+            payload,
+        });
+        this.wss.clients.forEach((client) => {
+            client.send(message);
+        });
+    }
+}
+exports.websocketServer = new WebsocketServer();

package/dist/src/dashboards/project/backend/services/git.service.d.ts

@@ -0,0 +1,9 @@
+declare class GitDashboardService {
+    getInfo(): Promise<{
+        branch: string;
+        changesCount: number;
+        changes: string[];
+    }>;
+}
+export declare const gitDashboardService: GitDashboardService;
+export {};

package/dist/src/dashboards/project/backend/services/git.service.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitDashboardService = void 0;
+const exec_1 = require("../../../../core/shell/exec");
+class GitDashboardService {
+    async getInfo() {
+        const branch = (await (0, exec_1.exec)("git branch --show-current", true)).trim();
+        const changes = (await (0, exec_1.exec)("git status --short", true))
+            .split("\n")
+            .filter(Boolean);
+        return {
+            branch,
+            changesCount: changes.length,
+            changes,
+        };
+    }
+}
+exports.gitDashboardService = new GitDashboardService();

package/dist/src/dashboards/project/backend/services/metrics.service.d.ts

@@ -0,0 +1,7 @@
+declare class MetricsService {
+    private timer?;
+    start(): void;
+    stop(): void;
+}
+export declare const metricsService: MetricsService;
+export {};

package/dist/src/dashboards/project/backend/services/metrics.service.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metricsService = void 0;
+const pidusage_1 = __importDefault(require("pidusage"));
+const websocket_server_1 = require("../server/websocket.server");
+const process_wrapper_1 = require("../wrapper/process.wrapper");
+const project_service_1 = require("./project.service");
+const git_service_1 = require("./git.service");
+const system_service_1 = require("./system.service");
+class MetricsService {
+    timer;
+    start() {
+        this.timer = setInterval(async () => {
+            try {
+                const pid = process_wrapper_1.processWrapper.getPid();
+                if (!pid) {
+                    return;
+                }
+                const stats = await (0, pidusage_1.default)(pid);
+                const project = project_service_1.projectService.getInfo();
+                const git = await git_service_1.gitDashboardService.getInfo();
+                const memory = system_service_1.systemService.getMemory();
+                const cpu = system_service_1.systemService.getCpuUsage();
+                const machine = system_service_1.systemService.getMachine();
+                websocket_server_1.websocketServer.emit("dashboard:update", {
+                    runtime: {
+                        pid,
+                        cpu: cpu,
+                        memory: memory,
+                        elapsed: stats.elapsed,
+                        uptime: process.uptime(),
+                    },
+                    project,
+                    git,
+                    system: {
+                        cpu,
+                        memory,
+                        machine,
+                    },
+                });
+            }
+            catch (error) {
+                console.log(error);
+            }
+        }, 1000);
+    }
+    stop() {
+        clearInterval(this.timer);
+    }
+}
+exports.metricsService = new MetricsService();

package/dist/src/dashboards/project/backend/services/project.service.d.ts

@@ -0,0 +1,10 @@
+declare class ProjectService {
+    getInfo(): {
+        name: any;
+        version: any;
+        scripts: any;
+        cwd: string;
+    };
+}
+export declare const projectService: ProjectService;
+export {};

package/dist/src/dashboards/project/backend/services/project.service.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectService = void 0;
+const fs_1 = __importDefault(require("fs"));
+class ProjectService {
+    getInfo() {
+        const pkg = JSON.parse(fs_1.default.readFileSync("package.json", "utf8"));
+        return {
+            name: pkg.name,
+            version: pkg.version,
+            scripts: pkg.scripts,
+            cwd: process.cwd(),
+        };
+    }
+}
+exports.projectService = new ProjectService();

package/dist/src/dashboards/project/backend/services/system.service.d.ts

@@ -0,0 +1,15 @@
+declare class SystemService {
+    private previous;
+    getCpuUsage(): number;
+    getMemory(): {
+        usedMB: number;
+        totalMB: number;
+    };
+    getMachine(): {
+        arch: NodeJS.Architecture;
+        cpu: string;
+        platform: NodeJS.Platform;
+    };
+}
+export declare const systemService: SystemService;
+export {};

package/dist/src/dashboards/project/backend/services/system.service.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemService = void 0;
+const os_1 = __importDefault(require("os"));
+class SystemService {
+    previous = os_1.default.cpus();
+    getCpuUsage() {
+        const current = os_1.default.cpus();
+        let idleDiff = 0;
+        let totalDiff = 0;
+        current.forEach((cpu, index) => {
+            const prev = this.previous[index];
+            const prevTotal = Object.values(prev.times).reduce((a, b) => a + b, 0);
+            const currTotal = Object.values(cpu.times).reduce((a, b) => a + b, 0);
+            idleDiff += cpu.times.idle - prev.times.idle;
+            totalDiff += currTotal - prevTotal;
+        });
+        this.previous = current;
+        const usage = 100 - (idleDiff / totalDiff) * 100;
+        return Number(usage.toFixed(1));
+    }
+    getMemory() {
+        const total = os_1.default.totalmem();
+        const free = os_1.default.freemem();
+        const result = {
+            usedMB: Math.round((total - free) / 1024 / 1024),
+            totalMB: Math.round(total / 1024 / 1024),
+        };
+        return result;
+    }
+    getMachine() {
+        return {
+            arch: os_1.default.arch(),
+            cpu: os_1.default.cpus()[0]?.model,
+            platform: os_1.default.platform(),
+        };
+    }
+}
+exports.systemService = new SystemService();

package/dist/src/dashboards/project/backend/wrapper/process.wrapper.d.ts

@@ -0,0 +1,13 @@
+import { ChildProcess } from "child_process";
+declare class ProcessWrapper {
+    private child?;
+    start({ command, args, }: {
+        command: string;
+        args: string[];
+    }): Promise<void>;
+    getPid(): number | undefined;
+    getProcess(): ChildProcess | undefined;
+    stop(): void;
+}
+export declare const processWrapper: ProcessWrapper;
+export {};

package/dist/src/dashboards/project/backend/wrapper/process.wrapper.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processWrapper = void 0;
+const child_process_1 = require("child_process");
+const websocket_server_1 = require("../server/websocket.server");
+class ProcessWrapper {
+    child;
+    async start({ command, args, }) {
+        console.log("tick");
+        this.child = (0, child_process_1.spawn)(command, args, {
+            shell: true,
+            stdio: "pipe",
+            env: {
+                ...process.env,
+                VH_ENABLED: "true",
+            },
+        });
+        websocket_server_1.websocketServer.emit("process", {
+            pid: this.child.pid,
+            command,
+            args,
+        });
+        this.child.stdout?.on("data", (data) => {
+            websocket_server_1.websocketServer.emit("stdout", {
+                message: data.toString(),
+                timestamp: Date.now(),
+            });
+        });
+        this.child.stderr?.on("data", (data) => {
+            websocket_server_1.websocketServer.emit("stderr", {
+                message: data.toString(),
+                timestamp: Date.now(),
+            });
+        });
+        this.child.on("close", (code) => {
+            websocket_server_1.websocketServer.emit("process_exit", {
+                code,
+            });
+        });
+        this.child.on("error", (error) => {
+            websocket_server_1.websocketServer.emit("process_error", {
+                error: error.message,
+            });
+        });
+    }
+    getPid() {
+        return this.child?.pid;
+    }
+    getProcess() {
+        return this.child;
+    }
+    stop() {
+        this.child?.kill("SIGTERM");
+    }
+}
+exports.processWrapper = new ProcessWrapper();

package/dist/src/services/git/git.service.d.ts

@@ -0,0 +1,37 @@
+declare class GitService {
+    deleteBranch(branch: string, remote?: boolean): Promise<void>;
+    cherryPickLines(ref: string, file: string, range?: string): Promise<void>;
+    cherryPickInteractive(ref: string, file: string): Promise<void>;
+    cherryPickCommit(ref: string): Promise<void>;
+    cherryPickFile(ref: string, file: string): Promise<void>;
+    cherryPickFolder(ref: string, folder: string): Promise<void>;
+    init(): Promise<void>;
+    fetch(): Promise<void>;
+    merge(branch: string): Promise<void>;
+    sync(): Promise<void>;
+    cleanup(): Promise<void>;
+    graph(): Promise<void>;
+    undo({ hard, mixed, commit, index, }: {
+        hard?: boolean;
+        mixed?: boolean;
+        commit?: string;
+        index?: number;
+    }): Promise<void>;
+    addAll(): Promise<void>;
+    commit(message: string): Promise<void>;
+    status(): Promise<void>;
+    checkout(branch: string): Promise<void>;
+    checkoutBranch(branch: string): Promise<void>;
+    branches(): Promise<void>;
+    restore(file?: string): Promise<void>;
+    pushUpstream(): Promise<void>;
+    pushOrigin(branch?: string): Promise<void>;
+    pullOrigin(branch?: string): Promise<void>;
+    pushWithPull(branch?: string): Promise<void>;
+    pull(branch?: string): Promise<void>;
+    resolveRef(ref: string): Promise<string>;
+    final(message?: string): Promise<void>;
+    untrack(target: string): Promise<void>;
+}
+export declare const gitService: GitService;
+export {};