@mks2508/coolify-mks-cli-mcp 0.6.3 → 0.8.0

package/src/cli/commands/logs.ts

@@ -1,43 +1,68 @@
 /**
- * Logs command for CLI.
+ * Logs command — application logs with follow mode (polling).
+ * Ctrl+C stops the follow loop without killing the process.
  *
  * @module
  */
 
+import * as p from "@clack/prompts";
 import { isErr } from "@mks2508/no-throw";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
-import { resolveUuid } from "../coolify-state.js";
+import { resolveUuid, loadMultiAppState } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
+
+const POLL_INTERVAL = 2000;
 
 /**
- * Logs command handler.
- * If no UUID is provided, reads from .coolify.json in the current directory.
- *
- * @param uuid - Application UUID (optional if .coolify.json exists)
- * @param options - Logs options
+ * Logs command handler (CLI entry point).
  */
 export async function logsCommand(
   uuid: string | undefined,
-  options: { lines?: number; follow?: boolean },
+  options: {
+    lines?: number;
+    follow?: boolean;
+    errors?: boolean;
+    since?: string;
+  },
 ) {
-  const resolvedUuid = resolveUuid(uuid);
-  if (!resolvedUuid) {
-    console.error(
-      chalk.red("Error: No UUID provided and no .coolify.json found"),
-    );
-    return;
+  if (!uuid) {
+    uuid = await resolveOrPromptApp();
+    if (!uuid) return;
+  } else {
+    let resolvedUuid = resolveUuid(uuid);
+    if (!resolvedUuid) resolvedUuid = await resolveAppNameOrUuid(uuid);
+    if (!resolvedUuid) {
+      console.error(chalk.red("Error: Could not resolve app UUID/name"));
+      return;
+    }
+    uuid = resolvedUuid;
   }
-  uuid = resolvedUuid;
+
   const coolify = getCoolifyService();
   const initResult = await coolify.init();
-
   if (isErr(initResult)) {
     console.error(chalk.red(`Error: ${initResult.error.message}`));
     return;
   }
 
+  if (options.follow) {
+    await followLogs(coolify, uuid, options);
+  } else {
+    await showLogs(coolify, uuid, options);
+  }
+}
+
+/**
+ * Show logs once (non-follow).
+ */
+async function showLogs(
+  coolify: ReturnType<typeof getCoolifyService>,
+  uuid: string,
+  options: { lines?: number; errors?: boolean; since?: string },
+): Promise<void> {
   const result = await coolify.getApplicationLogs(uuid, {
-    tail: options.lines || 50,
+    tail: options.lines || 100,
   });
 
   if (isErr(result)) {
@@ -45,20 +70,195 @@ export async function logsCommand(
     return;
   }
 
-  const logs = result.value;
+  let logs = result.value.logs;
+  logs = filterLogs(logs, options);
 
-  if (logs.logs.length === 0) {
+  if (logs.length === 0) {
     console.log(chalk.yellow("No logs available"));
     return;
   }
 
-  console.log(chalk.gray(`Application logs (${logs.logs.length} lines):\n`));
+  console.log(chalk.gray(`Logs (${logs.length} lines):\n`));
+  for (const line of logs) {
+    console.log(colorizeLogLine(line));
+  }
+}
+
+/**
+ * Follow logs with polling.
+ * Ctrl+C stops the follow and returns control to caller (does NOT exit process).
+ */
+async function followLogs(
+  coolify: ReturnType<typeof getCoolifyService>,
+  uuid: string,
+  options: { lines?: number; errors?: boolean; since?: string },
+): Promise<void> {
+  console.log(
+    chalk.gray(
+      `Following logs for ${chalk.cyan(uuid.slice(0, 12))} — ${chalk.bold("Ctrl+C")} to stop\n`,
+    ),
+  );
+
+  let seenLines = new Set<string>();
+  let tail = options.lines || 20; // Start small — only recent lines
+  let isFirstFetch = true;
+  let running = true;
+
+  // Ctrl+C handler — stops the loop, does NOT exit process
+  const abort = () => {
+    running = false;
+  };
+  process.on("SIGINT", abort);
+
+  try {
+    while (running) {
+      const result = await coolify.getApplicationLogs(uuid, { tail });
+
+      if (isErr(result)) {
+        if (!running) break; // Aborted during fetch
+        console.error(chalk.red(`Error: ${result.error.message}`));
+        await sleep(POLL_INTERVAL);
+        continue;
+      }
 
-  for (const line of logs.logs) {
-    console.log(line);
+      let logs = result.value.logs;
+      logs = filterLogs(logs, options);
+
+      for (const line of logs) {
+        const lineHash = line.trim();
+        if (!seenLines.has(lineHash) && lineHash.length > 0) {
+          seenLines.add(lineHash);
+          console.log(colorizeLogLine(line));
+        }
+      }
+
+      if (seenLines.size > 5000) {
+        const entries = [...seenLines];
+        seenLines = new Set(entries.slice(-2000));
+      }
+
+      // Keep tail small — we rely on dedup to only show new lines
+      tail = 30;
+
+      // Interruptible sleep
+      await new Promise<void>((resolve) => {
+        const timer = setTimeout(resolve, POLL_INTERVAL);
+        const checkAbort = () => {
+          if (!running) {
+            clearTimeout(timer);
+            resolve();
+          }
+        };
+        // Check abort every 100ms during sleep
+        const interval = setInterval(checkAbort, 100);
+        setTimeout(() => clearInterval(interval), POLL_INTERVAL + 50);
+      });
+    }
+  } finally {
+    process.removeListener("SIGINT", abort);
   }
 
-  if (options.follow) {
-    console.log(chalk.yellow("\nFollow mode not yet implemented"));
+  console.log(chalk.gray("\nStopped following logs."));
+}
+
+/**
+ * Fetch latest N log lines for a preview panel (no follow, just snapshot).
+ * Returns colorized string lines.
+ *
+ * @param uuid - Application UUID (already resolved)
+ * @param lines - Number of lines to fetch
+ * @returns Array of colorized log lines
+ */
+export async function fetchLogPreview(
+  uuid: string,
+  lines: number = 8,
+): Promise<string[]> {
+  const coolify = getCoolifyService();
+  const result = await coolify.getApplicationLogs(uuid, { tail: lines });
+  if (isErr(result)) return [chalk.gray("(logs unavailable)")];
+
+  const logs = result.value.logs;
+  if (logs.length === 0) return [chalk.gray("(no logs)")];
+
+  return logs.slice(-lines).map(colorizeLogLine);
+}
+
+// ─── Filters & helpers ───────────────────────────────────────────────────────
+
+function filterLogs(
+  logs: string[],
+  options: { errors?: boolean; since?: string },
+): string[] {
+  let filtered = logs;
+
+  if (options.errors) {
+    filtered = filtered.filter(
+      (line) =>
+        /\b(error|err|fatal|panic|exception|fail)\b/i.test(line) ||
+        /stderr/i.test(line),
+    );
   }
+
+  if (options.since) {
+    const sinceMs = parseDuration(options.since);
+    if (sinceMs > 0) {
+      const cutoff = Date.now() - sinceMs;
+      filtered = filtered.filter((line) => {
+        const ts = extractTimestamp(line);
+        return ts === null || ts >= cutoff;
+      });
+    }
+  }
+
+  return filtered;
+}
+
+export function colorizeLogLine(line: string): string {
+  if (/\b(error|fatal|panic)\b/i.test(line)) return chalk.red(line);
+  if (/\b(warn|warning)\b/i.test(line)) return chalk.yellow(line);
+  if (/\b(info)\b/i.test(line)) return chalk.white(line);
+  if (/\b(debug|trace)\b/i.test(line)) return chalk.gray(line);
+  return line;
+}
+
+function parseDuration(str: string): number {
+  const match = str.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) return 0;
+  const value = parseInt(match[1], 10);
+  const multipliers: Record<string, number> = {
+    s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000,
+  };
+  return value * (multipliers[match[2]] || 0);
+}
+
+function extractTimestamp(line: string): number | null {
+  const isoMatch = line.match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+  if (isoMatch) return new Date(isoMatch[0]).getTime();
+  return null;
+}
+
+async function resolveOrPromptApp(): Promise<string | null> {
+  const resolved = resolveUuid(undefined);
+  if (resolved) return resolved;
+
+  const multiState = loadMultiAppState();
+  if (multiState && multiState.apps.length > 0) {
+    const response = await p.select({
+      message: "Select an application:",
+      options: multiState.apps.map((app) => ({
+        label: app.name,
+        value: app.uuid,
+        hint: app.domain || app.service,
+      })),
+    });
+    if (p.isCancel(response)) return null;
+    return response as string;
+  }
+
+  console.error(chalk.red("Error: No UUID/name and no .coolify.json found"));
+  return null;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/cli/commands/main-menu.ts

@@ -0,0 +1,21 @@
+/**
+ * Main interactive menu when CLI is called without arguments.
+ * Shows banner + infrastructure tree + interactive navigation.
+ *
+ * @module
+ */
+
+import { showAutoBanner } from "../ui/banner.js";
+
+/**
+ * Main interactive menu entry point.
+ */
+export async function mainMenu(): Promise<void> {
+  if (process.stdout.isTTY) {
+    console.clear();
+  }
+  showAutoBanner("0.8.0");
+
+  // Go directly to status which shows tree + interactive navigation
+  await (await import("./status.js")).statusCommand();
+}