@longshot/cli 0.0.1

package/dist/services.js

@@ -0,0 +1,194 @@
+import { spawn } from "node:child_process";
+import { appendFile, writeFile, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import * as store from "./store.js";
+import { getProjectRoot } from "./projects.js";
+const MAX_LOG_LINES = 10_000;
+const TRUNCATE_CHECK_INTERVAL = 1000; // check every 1000 lines appended
+// In-memory map of running services
+const runningServices = new Map();
+export function getServiceStatus(id) {
+    const running = runningServices.get(id);
+    if (running) {
+        return {
+            status: running.status,
+            pid: running.pid,
+            startedAt: running.startedAt,
+            exitCode: running.exitCode,
+        };
+    }
+    return { status: "stopped" };
+}
+export function getAllServiceStatuses() {
+    const result = new Map();
+    for (const [id, running] of runningServices) {
+        result.set(id, {
+            status: running.status,
+            pid: running.pid,
+            startedAt: running.startedAt,
+            exitCode: running.exitCode,
+        });
+    }
+    return result;
+}
+function logPath(id) {
+    return join(store.getServicesLogDir(), `${id}.log`);
+}
+async function appendLog(id, data) {
+    const dir = await store.ensureServicesLogDir();
+    const path = logPath(id);
+    const timestamp = new Date().toISOString();
+    const lines = data.split("\n").filter(Boolean);
+    const formatted = lines.map((line) => `[${timestamp}] ${line}\n`).join("");
+    await appendFile(path, formatted, "utf-8");
+    // Track lines for truncation
+    const running = runningServices.get(id);
+    if (running) {
+        running.linesAppended += lines.length;
+        if (running.linesAppended >= TRUNCATE_CHECK_INTERVAL) {
+            running.linesAppended = 0;
+            truncateLog(id).catch(() => { });
+        }
+    }
+}
+async function truncateLog(id) {
+    const path = logPath(id);
+    if (!existsSync(path))
+        return;
+    try {
+        const content = await readFile(path, "utf-8");
+        const lines = content.split("\n");
+        if (lines.length > MAX_LOG_LINES) {
+            const kept = lines.slice(lines.length - MAX_LOG_LINES).join("\n");
+            await writeFile(path, kept, "utf-8");
+        }
+    }
+    catch {
+        // Ignore truncation errors
+    }
+}
+export async function startService(id) {
+    if (runningServices.has(id)) {
+        const existing = runningServices.get(id);
+        if (existing.status === "running") {
+            return { ok: false, error: "Service already running" };
+        }
+        // Clean up crashed/stopped entry
+        runningServices.delete(id);
+    }
+    const service = await store.getService(id);
+    if (!service) {
+        return { ok: false, error: "Service not found" };
+    }
+    const cwd = service.cwd || getProjectRoot();
+    // Ensure log directory exists
+    await store.ensureServicesLogDir();
+    const child = spawn("sh", ["-c", service.command], {
+        cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    if (!child.pid) {
+        return { ok: false, error: "Failed to spawn process" };
+    }
+    const running = {
+        id,
+        process: child,
+        status: "running",
+        pid: child.pid,
+        startedAt: new Date().toISOString(),
+        linesAppended: 0,
+    };
+    runningServices.set(id, running);
+    // Pipe stdout/stderr to log file
+    child.stdout?.on("data", (data) => {
+        appendLog(id, data.toString()).catch(() => { });
+    });
+    child.stderr?.on("data", (data) => {
+        appendLog(id, data.toString()).catch(() => { });
+    });
+    child.on("exit", (code, signal) => {
+        const entry = runningServices.get(id);
+        if (entry) {
+            entry.exitCode = code ?? undefined;
+            if (entry.status === "running") {
+                // Was not manually stopped — it crashed
+                entry.status = code === 0 ? "stopped" : "crashed";
+            }
+        }
+        appendLog(id, `Process exited with code ${code} (signal: ${signal})`).catch(() => { });
+    });
+    child.on("error", (err) => {
+        const entry = runningServices.get(id);
+        if (entry) {
+            entry.status = "crashed";
+        }
+        appendLog(id, `Process error: ${err.message}`).catch(() => { });
+    });
+    await appendLog(id, `Started: ${service.command} (pid: ${child.pid})`);
+    return { ok: true };
+}
+export async function stopService(id) {
+    const running = runningServices.get(id);
+    if (!running || running.status !== "running") {
+        return { ok: false, error: "Service not running" };
+    }
+    running.status = "stopped";
+    return new Promise((resolve) => {
+        const child = running.process;
+        // Send SIGTERM
+        child.kill("SIGTERM");
+        // Escalate to SIGKILL after 5s
+        const killTimeout = setTimeout(() => {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // Already dead
+            }
+        }, 5000);
+        child.on("exit", () => {
+            clearTimeout(killTimeout);
+            resolve({ ok: true });
+        });
+        // Safety timeout — if exit never fires
+        setTimeout(() => {
+            clearTimeout(killTimeout);
+            resolve({ ok: true });
+        }, 10000);
+    });
+}
+export async function restartService(id) {
+    const running = runningServices.get(id);
+    if (running && running.status === "running") {
+        await stopService(id);
+    }
+    runningServices.delete(id);
+    return startService(id);
+}
+export async function getServiceLogs(id, tailLines = 200) {
+    const path = logPath(id);
+    if (!existsSync(path))
+        return "";
+    try {
+        const content = await readFile(path, "utf-8");
+        const lines = content.split("\n");
+        return lines.slice(-tailLines).join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+export async function clearServiceLogs(id) {
+    const path = logPath(id);
+    await store.ensureServicesLogDir();
+    await writeFile(path, "", "utf-8");
+}
+export async function getServicesWithStatus() {
+    const services = await store.readServices();
+    return services.map((s) => {
+        const status = getServiceStatus(s.id);
+        return { ...s, ...status };
+    });
+}