Add VS Code extension for dev-process-manager

.changeset/rich-chairs-leave.md

@@ -0,0 +1,5 @@
+---
+"@comet/dev-process-manager": minor
+---
+
+Refactor status output (as json) in preparation for vscode extension

.gitignore

@@ -1,2 +1,3 @@
 node_modules
 /lib
+/vscode-extension/out

package.json

@@ -11,15 +11,15 @@
         "lib/**/*"
     ],
     "scripts": {
-        "prepare": "husky",
+        "build": "tsc",
+        "build-and-publish": "npm run build && npx changeset publish",
         "lint": "run-p lint:eslint lint:tsc",
         "lint:eslint": "eslint src/",
         "lint:tsc": "tsc",
-        "build": "tsc",
+        "prepare": "husky",
         "start": "tsc --watch",
         "test": "vitest run",
-        "test:watch": "vitest",
-        "build-and-publish": "npm run build && npx changeset publish"
+        "test:watch": "vitest"
     },
     "repository": {
         "type": "git",

src/commands/connect.ts

@@ -20,9 +20,11 @@ export async function connect(): Promise<Socket> {
         client.on("connect", () => {
             resolve(client);
         });
-        client.on("data", (data) => {
-            //TODO handle stderr/stdin and also write on stderr
-            process.stdout.write(data);
-        });
+    });
+}
+
+export function pipeToStdout(client: Socket): void {
+    client.on("data", (data) => {
+        process.stdout.write(data);
     });
 }

src/commands/logs.command.ts

@@ -1,9 +1,10 @@
 import { type LogsCommandOptions } from "../daemon-command/logs.daemon-command.js";
-import { connect } from "./connect.js";
+import { connect, pipeToStdout } from "./connect.js";
 import { validConfigOrExit } from "./validate-config.js";
 
 export const logs = async (options: LogsCommandOptions): Promise<void> => {
     await validConfigOrExit();
     const client = await connect();
+    pipeToStdout(client);
     client.write(`logs ${JSON.stringify(options)}`);
 };

src/commands/restart.command.ts

@@ -1,9 +1,10 @@
 import { type RestartCommandOptions } from "../daemon-command/restart.daemon-command.js";
-import { connect } from "./connect.js";
+import { connect, pipeToStdout } from "./connect.js";
 import { validConfigOrExit } from "./validate-config.js";
 
 export const restart = async (options: RestartCommandOptions): Promise<void> => {
     await validConfigOrExit();
     const client = await connect();
+    pipeToStdout(client);
     client.write(`restart ${JSON.stringify(options)}`);
 };

src/commands/shutdown.command.ts

@@ -1,8 +1,9 @@
-import { connect } from "./connect.js";
+import { connect, pipeToStdout } from "./connect.js";
 import { validConfigOrExit } from "./validate-config.js";
 
 export const shutdown = async (): Promise<void> => {
     await validConfigOrExit();
     const client = await connect();
+    pipeToStdout(client);
     client.write("shutdown");
 };

src/commands/start-daemon.command.ts

@@ -1,7 +1,8 @@
 import colors from "colors";
-import { existsSync, watchFile } from "fs";
+import { existsSync, readFileSync, watchFile } from "fs";
 import { createServer, type Server } from "net";
-import { dirname } from "path";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
 
 import { logsDaemonCommand } from "../daemon-command/logs.daemon-command.js";
 import { restartDaemonCommand } from "../daemon-command/restart.daemon-command.js";
@@ -86,6 +87,11 @@ export const startDaemon = async (): Promise<void> => {
                 statusDaemonCommand(daemon, s, names);
             } else if (cmd == "shutdown") {
                 shutdownDaemonCommand(daemon, s);
+            } else if (cmd == "version") {
+                const __dirname = dirname(fileURLToPath(import.meta.url));
+                const { version } = JSON.parse(readFileSync(resolve(__dirname, "../../package.json"), "utf-8"));
+                s.write(`${JSON.stringify({ version })}\n`);
+                s.end();
             } else {
                 s.write(`unknown command ${cmd}`);
                 s.end();

src/commands/start.command.ts

@@ -1,9 +1,10 @@
 import { type StartCommandOptions } from "../daemon-command/start.daemon-command.js";
-import { connect } from "./connect.js";
+import { connect, pipeToStdout } from "./connect.js";
 import { validConfigOrExit } from "./validate-config.js";
 
 export const start = async (options: StartCommandOptions): Promise<void> => {
     await validConfigOrExit();
     const client = await connect();
+    pipeToStdout(client);
     client.write(`start ${JSON.stringify(options)}`);
 };

src/commands/status.command.ts

@@ -1,9 +1,67 @@
-import { type StatusCommandOptions } from "../daemon-command/status.daemon-command.js";
+import CLITable from "cli-table3";
+import colors from "colors";
+import { create as createLogUpdate } from "log-update";
+
+import { type ScriptStatus } from "../daemon-command/script.js";
+import { type ScriptStatusEntry, type StatusCommandOptions } from "../daemon-command/status.daemon-command.js";
 import { connect } from "./connect.js";
 import { validConfigOrExit } from "./validate-config.js";
 
+const statusTexts: { [status in ScriptStatus]: string } = {
+    started: colors.green("Running"),
+    stopping: colors.red("Stopping"),
+    stopped: "Stopped",
+    waiting: colors.yellow("Waiting"),
+    backoff: colors.red("Backoff"),
+};
+
+function renderTable(entries: ScriptStatusEntry[]): string {
+    const table = new CLITable({
+        head: [
+            colors.blue.bold("ID"),
+            colors.blue.bold("Script"),
+            colors.blue.bold("Status"),
+            colors.blue.bold("CPU"),
+            colors.blue.bold("Mem"),
+            colors.bold.blue("PID"),
+            colors.bold.blue("Restarts"),
+        ],
+        style: { compact: true },
+    });
+    for (const entry of entries) {
+        table.push([entry.id, entry.name, statusTexts[entry.status], entry.cpu, entry.memory, entry.pid?.toString(), entry.restarts]);
+    }
+    return table.toString();
+}
+
 export const status = async (options: StatusCommandOptions): Promise<void> => {
     await validConfigOrExit();
     const client = await connect();
+
+    const logUpdate = options.interval ? createLogUpdate(process.stdout) : undefined;
+    let buffer = "";
+
+    client.on("data", (data: Buffer) => {
+        buffer += data.toString();
+        let newlineIndex: number;
+        while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.substring(0, newlineIndex);
+            buffer = buffer.substring(newlineIndex + 1);
+
+            const parsed = JSON.parse(line);
+            if (parsed.error) {
+                console.log(parsed.error);
+                return;
+            }
+
+            const output = renderTable(parsed as ScriptStatusEntry[]);
+            if (logUpdate) {
+                logUpdate(output);
+            } else {
+                console.log(output);
+            }
+        }
+    });
+
     client.write(`status ${JSON.stringify(options)}`);
 };

src/commands/stop.command.ts

@@ -1,9 +1,10 @@
 import { type StopCommandOptions } from "../daemon-command/stop.daemon-command.js";
-import { connect } from "./connect.js";
+import { connect, pipeToStdout } from "./connect.js";
 import { validConfigOrExit } from "./validate-config.js";
 
 export const stop = async (options: StopCommandOptions): Promise<void> => {
     await validConfigOrExit();
     const client = await connect();
+    pipeToStdout(client);
     client.write(`stop ${JSON.stringify(options)}`);
 };

src/daemon-command/status.daemon-command.ts

@@ -1,6 +1,3 @@
-import CLITable from "cli-table3";
-import colors from "colors";
-import { create as createLogUpdate } from "log-update";
 import { type Socket } from "net";
 import pidtree from "pidtree";
 import pidusage from "pidusage";
@@ -14,13 +11,15 @@ export interface StatusCommandOptions extends ScriptsMatchingPatternOptions {
     interval: number | undefined;
 }
 
-const statusTexts: { [status in ScriptStatus]: string } = {
-    started: colors.green("Started"),
-    stopping: colors.red("Stopping"),
-    stopped: "Stopped",
-    waiting: colors.yellow("Waiting"),
-    backoff: colors.red("Backoff"),
-};
+export interface ScriptStatusEntry {
+    id: number;
+    name: string;
+    status: ScriptStatus;
+    cpu: string;
+    memory: string;
+    pid: number | undefined;
+    restarts: number;
+}
 
 async function pidusageRecursive(pid: number): Promise<{ cpu: number; memory: number }> {
     const pids = await pidtree(pid, { root: true });
@@ -35,63 +34,47 @@ async function pidusageRecursive(pid: number): Promise<{ cpu: number; memory: nu
     );
 }
 
+async function getScriptEntries(daemon: Daemon, patterns: string[]): Promise<ScriptStatusEntry[]> {
+    const scriptsToProcess = scriptsMatchingPattern(daemon, { patterns });
+    const entries: ScriptStatusEntry[] = [];
+    for (const script of scriptsToProcess) {
+        const pid = script.process?.pid;
+        let cpu = "";
+        let memory = "";
+        if (pid && script.status == "started") {
+            try {
+                const stats = await pidusageRecursive(pid);
+                cpu = `${Math.round(stats.cpu)}%`;
+                memory = prettyBytes(stats.memory);
+            } catch {
+                //
+            }
+        }
+        entries.push({
+            id: script.id,
+            name: script.name,
+            status: script.status,
+            cpu,
+            memory,
+            pid,
+            restarts: script.restartCount,
+        });
+    }
+    return entries;
+}
+
 export async function statusDaemonCommand(daemon: Daemon, socket: Socket, options: StatusCommandOptions): Promise<void> {
     const scriptsToProcess = scriptsMatchingPattern(daemon, { patterns: options.patterns });
     if (!scriptsToProcess.length) {
-        socket.write("No matching scripts found in dev-pm config\n");
+        socket.write(`${JSON.stringify({ error: "No matching scripts found in dev-pm config" })}\n`);
         socket.end();
         return;
     }
 
-    //log-update reads rows/columns from terminal, but in our case it's a socket that doesn't contain those
-    //inject a high enough number so will refresh more rows and don't wrap too early
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    socket.rows = 1000;
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    socket.columns = 200;
-
-    const logUpdate = createLogUpdate(socket);
-
     do {
-        const table = new CLITable({
-            head: [
-                colors.blue.bold("ID"),
-                colors.blue.bold("Script"),
-                colors.blue.bold("Status"),
-                colors.blue.bold("CPU"),
-                colors.blue.bold("Mem"),
-                colors.bold.blue("PID"),
-                colors.bold.blue("Restarts"),
-            ],
-            style: { compact: true },
-        });
-        for (const script of scriptsToProcess) {
-            const pid = script.process?.pid;
-            let status = statusTexts[script.status];
-            if (script.status == "started") {
-                if (pid) {
-                    status = colors.green("Running");
-                }
-            }
-
-            let cpu = "";
-            let memory = "";
-            if (pid && script.status == "started") {
-                try {
-                    const stats = await pidusageRecursive(pid);
-                    cpu = `${Math.round(stats.cpu)}%`;
-                    memory = prettyBytes(stats.memory);
-                } catch {
-                    //
-                }
-            }
-            table.push([script.id, script.name, status, cpu, memory, pid?.toString(), script.restartCount]);
-        }
-
+        const entries = await getScriptEntries(daemon, options.patterns);
         if (!socket.writable) break;
-        logUpdate(table.toString());
+        socket.write(`${JSON.stringify(entries)}\n`);
         if (options.interval) {
             await delay(options.interval * 1000);
         }

vscode-extension/.vscodeignore

@@ -0,0 +1,8 @@
+.vscode/**
+.vscode-test/**
+src/**
+node_modules/**
+tsconfig.json
+**/*.map
+**/*.ts
+!out/**

vscode-extension/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2019, Vivid Planet Software GmbH
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.