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

package/src/cli/commands/delete.ts

@@ -10,6 +10,7 @@ import { isErr } from "@mks2508/no-throw";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
 import { resolveUuid } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
 
 /**
  * Executes the delete command.
@@ -22,10 +23,13 @@ export async function deleteCommand(
   uuid: string | undefined,
   options: { force?: boolean; yes?: boolean } = {},
 ): Promise<void> {
-  const resolvedUuid = resolveUuid(uuid);
+  let resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid && uuid) {
+    resolvedUuid = await resolveAppNameOrUuid(uuid);
+  }
   if (!resolvedUuid) {
     console.error(
-      chalk.red("Error: No UUID provided and no .coolify.json found"),
+      chalk.red("Error: No UUID/name provided and no .coolify.json found"),
     );
     return;
   }

package/src/cli/commands/deploy.ts

@@ -1,77 +1,375 @@
 /**
- * Deploy command for CLI.
+ * Deploy command for CLI — with real-time progress polling and multi-app support.
+ * Detects TTY and falls back to static output when not interactive.
  *
  * @module
  */
 
-import { isOk, isErr } from "@mks2508/no-throw";
-import ora from "ora";
+import * as p from "@clack/prompts";
+import { isErr } from "@mks2508/no-throw";
+import boxen from "boxen";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
-import { resolveUuid } from "../coolify-state.js";
+import {
+  resolveUuid,
+  loadMultiAppState,
+  type ICoolifyMultiAppState,
+} from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
+
+const POLL_INTERVAL = 3000;
+const isTTY = process.stdout.isTTY === true;
 
 /**
  * Deploy command handler.
- * If no UUID is provided, reads from .coolify.json in the current directory.
+ * Supports --all for multi-app, --service for specific service,
+ * and polls deployment status for real-time progress feedback.
  *
- * @param uuid - Application UUID (optional if .coolify.json exists)
+ * @param uuid - Application UUID or name (optional)
  * @param options - Deploy options
  */
 export async function deployCommand(
   uuid: string | undefined,
-  options: { force?: boolean; tag?: string },
+  options: { force?: boolean; tag?: string; all?: boolean; service?: string },
 ) {
-  const resolvedUuid = resolveUuid(uuid);
-  if (!resolvedUuid) {
-    console.error(
-      chalk.red(
-        "Error: No UUID provided and no .coolify.json found in current directory",
-      ),
-    );
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`));
     return;
   }
-  uuid = resolvedUuid;
-  const spinner = ora("Initializing Coolify connection...").start();
 
-  try {
-    const coolify = getCoolifyService();
-    const initResult = await coolify.init();
+  // Multi-app deploy: --all or --service
+  const multiState = loadMultiAppState();
+
+  if (options.all && multiState?.apps?.length) {
+    await deployMultiApp(coolify, multiState, options);
+    return;
+  }
 
-    if (isErr(initResult)) {
-      spinner.fail(
-        chalk.red(`Failed to initialize: ${initResult.error.message}`),
+  if (options.service && multiState?.apps?.length) {
+    const app = multiState.apps.find(
+      (a) => a.service === options.service || a.name === options.service,
+    );
+    if (!app) {
+      console.error(
+        chalk.red(`Service "${options.service}" not found in .coolify.json`),
+      );
+      console.log(
+        chalk.gray(
+          `Available: ${multiState.apps.map((a) => a.service || a.name).join(", ")}`,
+        ),
       );
       return;
     }
+    await deploySingleApp(coolify, app.uuid, app.name, options);
+    return;
+  }
 
-    spinner.text = "Triggering deployment...";
-
-    const result = await coolify.deploy(
-      {
-        uuid,
-        force: options.force,
-        tag: options.tag,
-      },
-      (percent, message) => {
-        spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`;
-      },
-    );
+  // Interactive selection if no UUID
+  let displayName = uuid || "";
+  if (!uuid) {
+    uuid = await resolveOrPromptApp(multiState);
+    if (!uuid) return;
+    const app = multiState?.apps?.find((a) => a.uuid === uuid);
+    displayName = app?.name || uuid.slice(0, 8);
+  } else {
+    displayName = uuid;
+    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;
+  }
 
-    if (isOk(result)) {
-      spinner.succeed(
-        chalk.green(
-          `Deployment triggered! UUID: ${chalk.cyan(result.value.deploymentUuid)}`,
-        ),
-      );
-      console.log(`  Resource UUID: ${chalk.cyan(result.value.resourceUuid)}`);
-    } else {
-      spinner.fail(chalk.red(`Deployment failed: ${result.error.message}`));
+  if (uuid === "_all" && multiState) {
+    await deployMultiApp(coolify, multiState, options);
+    return;
+  }
+
+  await deploySingleApp(coolify, uuid, displayName, options);
+}
+
+/**
+ * Deploy a single app with real-time progress polling.
+ */
+async function deploySingleApp(
+  coolify: ReturnType<typeof getCoolifyService>,
+  uuid: string,
+  displayName: string,
+  options: { force?: boolean; tag?: string },
+): Promise<{ success: boolean; deploymentUuid?: string }> {
+  log(`Triggering deployment for ${displayName}...`);
+
+  const result = await coolify.deploy({
+    uuid,
+    force: options.force,
+    tag: options.tag,
+  });
+
+  if (isErr(result)) {
+    log(chalk.red(`Deploy failed: ${result.error.message}`));
+    return { success: false };
+  }
+
+  const deploymentUuid = result.value.deploymentUuid;
+  log(chalk.green(`✓ Deployment #${deploymentUuid.slice(0, 8)} triggered for ${displayName}`));
+
+  await pollDeploymentProgress(coolify, deploymentUuid, displayName);
+
+  return { success: true, deploymentUuid };
+}
+
+/**
+ * Poll deployment status until finished or failed.
+ * Uses spinner in TTY mode, static lines in non-TTY mode.
+ */
+async function pollDeploymentProgress(
+  coolify: ReturnType<typeof getCoolifyService>,
+  deploymentUuid: string,
+  displayName: string,
+): Promise<void> {
+  let spinner: ReturnType<typeof p.spinner> | null = null;
+  if (isTTY) {
+    spinner = p.spinner();
+    spinner.start(`${chalk.cyan(displayName)} — Building...`);
+  }
+
+  let lastLogLength = 0;
+  let lastStatus = "";
+
+  while (true) {
+    const result = await coolify.getDeploymentLogs(deploymentUuid);
+
+    if (isErr(result)) {
+      if (spinner) spinner.stop(chalk.yellow("Could not fetch deployment status"));
+      else log(chalk.yellow("Could not fetch deployment status"));
+      break;
     }
-  } catch (error) {
-    spinner.fail(
-      chalk.red(
-        `Error: ${error instanceof Error ? error.message : String(error)}`,
-      ),
-    );
+
+    const { status, logs } = result.value;
+
+    const logLines = logs ? logs.split("\n") : [];
+    const newLines = logLines.slice(lastLogLength);
+    lastLogLength = logLines.length;
+
+    const progressHint = extractProgressHint(newLines);
+
+    if (status !== lastStatus || progressHint) {
+      const statusIcon = getStatusIcon(status);
+      const progressText = progressHint ? ` — ${progressHint}` : "";
+      const msg = `${statusIcon} ${displayName} ${status}${progressText}`;
+
+      if (spinner) {
+        spinner.message(msg);
+      } else if (status !== lastStatus) {
+        // Non-TTY: only log on status change to avoid spam
+        log(msg);
+      }
+      lastStatus = status;
+    }
+
+    // Terminal states
+    if (status === "finished") {
+      const msg = `${chalk.green("✓")} ${chalk.cyan(displayName)} — deployed successfully`;
+      if (spinner) spinner.stop(msg);
+      else log(msg);
+      break;
+    }
+
+    if (status === "failed" || status === "cancelled") {
+      const msg = `${chalk.red("✗")} ${chalk.cyan(displayName)} — ${status}`;
+      if (spinner) spinner.stop(msg);
+      else log(msg);
+
+      const errorLines = logLines.slice(-5).filter((l) => l.trim().length > 0);
+      if (errorLines.length > 0) {
+        if (isTTY) {
+          console.log(
+            boxen(errorLines.join("\n"), {
+              title: chalk.red("Error"),
+              borderStyle: "round",
+              borderColor: "red",
+              padding: { left: 1, right: 1, top: 0, bottom: 0 },
+            }),
+          );
+        } else {
+          log(chalk.red("--- Error context ---"));
+          errorLines.forEach((l) => log(`  ${l}`));
+        }
+      }
+      break;
+    }
+
+    await sleep(POLL_INTERVAL);
+  }
+}
+
+/**
+ * Deploy multiple apps in parallel with individual progress tracking.
+ */
+async function deployMultiApp(
+  coolify: ReturnType<typeof getCoolifyService>,
+  state: ICoolifyMultiAppState,
+  options: { force?: boolean; tag?: string },
+): Promise<void> {
+  const apps = state.apps;
+  log(`Deploying ${apps.length} apps in parallel...`);
+
+  const deployPromises = apps.map(async (app) => {
+    log(`  ${chalk.cyan(app.name)} — triggering...`);
+
+    const result = await coolify.deploy({
+      uuid: app.uuid,
+      force: options.force,
+      tag: options.tag,
+    });
+
+    if (isErr(result)) {
+      log(`  ${chalk.red("✗")} ${app.name} — ${result.error.message}`);
+      return { app, success: false, deploymentUuid: undefined };
+    }
+
+    const deploymentUuid = result.value.deploymentUuid;
+    log(`  ${chalk.cyan(app.name)} — building (#${deploymentUuid.slice(0, 8)})`);
+
+    let finalStatus = "unknown";
+    while (true) {
+      const statusResult = await coolify.getDeploymentLogs(deploymentUuid);
+
+      if (isErr(statusResult)) {
+        log(`  ${chalk.yellow("⚠")} ${app.name} — could not fetch status`);
+        break;
+      }
+
+      const { status, logs } = statusResult.value;
+
+      if (status !== finalStatus) {
+        const hint = extractProgressHint(logs ? logs.split("\n").slice(-10) : []);
+        log(`  ${getStatusIcon(status)} ${app.name} — ${status}${hint ? ` (${hint})` : ""}`);
+        finalStatus = status;
+      }
+
+      if (status === "finished") {
+        log(`  ${chalk.green("✓")} ${app.name} — deployed`);
+        break;
+      }
+
+      if (status === "failed" || status === "cancelled") {
+        log(`  ${chalk.red("✗")} ${app.name} — ${status}`);
+        break;
+      }
+
+      await sleep(POLL_INTERVAL);
+    }
+
+    return { app, success: finalStatus === "finished", deploymentUuid };
+  });
+
+  const results = await Promise.allSettled(deployPromises);
+
+  const succeeded = results.filter(
+    (r) => r.status === "fulfilled" && r.value?.success,
+  ).length;
+  const failed = results.length - succeeded;
+
+  log("");
+  if (failed === 0) {
+    log(chalk.green(`All ${succeeded} apps deployed successfully`));
+  } else {
+    log(`${chalk.green(`${succeeded} succeeded`)}, ${chalk.red(`${failed} failed`)}`);
+  }
+}
+
+/**
+ * Extract a human-readable progress hint from recent build log lines.
+ */
+function extractProgressHint(lines: string[]): string | null {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+
+    const stepMatch = line.match(/Step (\d+)\/(\d+)/i);
+    if (stepMatch) return `Step ${stepMatch[1]}/${stepMatch[2]}`;
+
+    const buildKitMatch = line.match(/#(\d+) \[.*?\] (.*)/);
+    if (buildKitMatch) return buildKitMatch[2].slice(0, 40);
+
+    if (/cloning|clone/i.test(line)) return "Git clone";
+    if (/installing|npm install|bun install|yarn install/i.test(line))
+      return "Installing dependencies";
+    if (/health.?check|healthy/i.test(line)) return "Health check";
+    if (/starting|container.*start/i.test(line)) return "Starting container";
+  }
+  return null;
+}
+
+/**
+ * Get a status icon for deployment state.
+ */
+function getStatusIcon(status: string): string {
+  switch (status) {
+    case "finished":
+      return chalk.green("✓");
+    case "failed":
+    case "cancelled":
+      return chalk.red("✗");
+    case "in_progress":
+    case "queued":
+      return chalk.cyan("●");
+    default:
+      return chalk.yellow("○");
+  }
+}
+
+/**
+ * Resolve app UUID or prompt user to pick from multi-app state.
+ */
+async function resolveOrPromptApp(
+  multiState: ICoolifyMultiAppState | null,
+): Promise<string | null> {
+  const resolved = resolveUuid(undefined);
+  if (resolved) return resolved;
+
+  if (isTTY && multiState && multiState.apps.length > 0) {
+    const response = await p.select({
+      message: "Deploy which app?",
+      options: [
+        {
+          label: `All (${multiState.apps.length} apps in parallel)`,
+          value: "_all",
+          hint: "parallel deploy",
+        },
+        ...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 provided and no .coolify.json found"),
+  );
+  return null;
+}
+
+/**
+ * Log a message to stdout (static, no spinner frames).
+ */
+function log(msg: string): void {
+  console.log(msg);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/cli/commands/deployments.ts

@@ -12,6 +12,7 @@ import Table from "cli-table3";
 import { getCoolifyService } from "../../coolify/index.js";
 import { formatStatus } from "../../utils/format.js";
 import { resolveUuid } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
 
 /**
  * Deployments command handler.
@@ -24,10 +25,13 @@ export async function deploymentsCommand(
   uuid: string | undefined,
   options: { full?: boolean; limit?: number } = {},
 ) {
-  const resolvedUuid = resolveUuid(uuid);
+  let resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid && uuid) {
+    resolvedUuid = await resolveAppNameOrUuid(uuid);
+  }
   if (!resolvedUuid) {
     console.error(
-      chalk.red("Error: No UUID provided and no .coolify.json found"),
+      chalk.red("Error: No UUID/name provided and no .coolify.json found"),
     );
     return;
   }

package/src/cli/commands/diagnose.ts

@@ -38,9 +38,9 @@ export async function diagnoseAppCommand(query?: string): Promise<void> {
         const status = d.status?.includes("failed")
           ? chalk.red(d.status)
           : chalk.green(d.status);
-        console.log(
-          `  ${chalk.gray(d.uuid.slice(0, 12))} ${status} ${chalk.gray(new Date(d.created_at).toLocaleString())}`,
-        );
+        const id = (d.deployment_uuid || d.uuid || "").slice(0, 12) || "-";
+        const date = d.created_at ? new Date(d.created_at).toLocaleString() : "";
+        console.log(`  ${chalk.gray(id)} ${status} ${chalk.gray(date)}`);
       }
     }
 

package/src/cli/commands/env.ts

@@ -6,13 +6,28 @@
 
 import { isErr } from "@mks2508/no-throw";
 import chalk from "chalk";
+import ora from "ora";
 import { getCoolifyService } from "../../coolify/index.js";
+import { getCliSdk } from "../actions.js";
 import { resolveUuid } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
+import {
+  createEnvTable,
+  createChangeSummary,
+  createSpinner,
+  highlightEnvLine,
+  createDiff,
+} from "../ui/index.js";
 
 interface IEnvCommandOptions {
   set?: string;
   delete?: string;
   buildtime?: boolean;
+  "runtime-only"?: boolean;
+  sync?: boolean | string;
+  "dry-run"?: boolean;
+  prune?: boolean;
+  table?: boolean;
 }
 
 /**
@@ -26,10 +41,13 @@ export async function envCommand(
   uuid: string | undefined,
   options: IEnvCommandOptions = {},
 ) {
-  const resolvedUuid = resolveUuid(uuid);
+  let resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid && uuid) {
+    resolvedUuid = await resolveAppNameOrUuid(uuid);
+  }
   if (!resolvedUuid) {
     console.error(
-      chalk.red("Error: No UUID provided and no .coolify.json found"),
+      chalk.red("Error: No UUID/name provided and no .coolify.json found"),
     );
     return;
   }
@@ -52,11 +70,14 @@ export async function envCommand(
       return;
     }
 
+    // --runtime-only explicitly sets is_buildtime=false, --buildtime sets it to true
+    const isBuildTime = options["runtime-only"] ? false : (options.buildtime ?? false);
+
     const result = await coolify.setEnvironmentVariable(
       uuid,
       key,
       value,
-      options.buildtime ?? false,
+      isBuildTime,
     );
 
     if (isErr(result)) {
@@ -86,6 +107,74 @@ export async function envCommand(
     return;
   }
 
+  // Handle --sync [file]
+  if (options.sync) {
+    const envFile = options.sync === true ? ".env" : options.sync;
+
+    console.log("");
+    console.log(chalk.cyan.bold("  🔄 Env Sync"));
+
+    try {
+      const sdk = getCliSdk();
+      const spinner = createSpinner({
+        text: "Reading environment variables...",
+        color: "cyan",
+      }).start();
+
+      const result = await sdk.applications.syncEnv(uuid, {
+        filePath: envFile,
+        dryRun: options["dry-run"] ?? false,
+        prune: options.prune ?? false,
+        onProgress: (update) => {
+          if (update.type === "add") {
+            spinner.succeed(
+              `  ${chalk.green("+")} ${highlightEnvLine(`${update.key}=${update.value ?? ""}`)}`,
+            );
+            spinner.text = "Syncing...";
+            spinner.start();
+          } else if (update.type === "update") {
+            const diff = createDiff(
+              result.updated.find((u) => u.key === update.key)?.oldValue ?? "",
+              update.value ?? "",
+            );
+            spinner.succeed(
+              `  ${chalk.yellow("~")} ${chalk.bold(update.key)} updated`,
+            );
+            spinner.text = "Syncing...";
+            spinner.start();
+          } else if (update.type === "remove") {
+            spinner.succeed(`  ${chalk.red("-")} ${chalk.bold(update.key)} removed`);
+            spinner.text = "Syncing...";
+            spinner.start();
+          }
+        },
+      });
+
+      spinner.stop();
+
+      const totalChanges =
+        result.added.length + result.updated.length + result.removed.length;
+
+      if (totalChanges === 0) {
+        console.log("");
+        console.log(chalk.green("  ✓ All variables are already in sync"));
+        console.log("");
+      } else {
+        console.log(createChangeSummary(result));
+
+        if (options["dry-run"]) {
+          console.log(chalk.yellow("  ⚠ Dry run mode - no changes applied"));
+        } else {
+          console.log(chalk.green(`  ✓ Synced ${totalChanges} variable(s)`));
+        }
+        console.log("");
+      }
+    } catch (error) {
+      console.error(chalk.red(`  ✗ Error: ${error}`));
+    }
+    return;
+  }
+
   // Default: list env vars
   const result = await coolify.getEnvironmentVariables(uuid);
 
@@ -101,27 +190,37 @@ export async function envCommand(
     return;
   }
 
-  console.log(chalk.cyan(`Environment variables (${envVars.length}):\n`));
-
-  // Separar runtime de buildtime
-  const runtimeVars = envVars.filter((ev) => ev.is_runtime);
-  const buildtimeVars = envVars.filter((ev) => ev.is_buildtime);
-
-  if (runtimeVars.length > 0) {
-    console.log(chalk.yellow.bold("Runtime:"));
-    for (const ev of runtimeVars) {
-      const required = ev.is_required ? chalk.red(" *") : "";
-      console.log(
-        `  ${chalk.green(ev.key)}${required} = ${chalk.gray(ev.value)}`,
-      );
+  // Use table view if --table flag, otherwise use highlighted list view
+  if (options.table) {
+    console.log(
+      createEnvTable(envVars, {
+        compact: true,
+        showType: true,
+      }),
+    );
+  } else {
+    console.log(chalk.cyan(`Environment variables (${envVars.length}):\n`));
+
+    // Separar runtime de buildtime
+    const runtimeVars = envVars.filter((ev) => ev.is_runtime);
+    const buildtimeVars = envVars.filter((ev) => ev.is_buildtime);
+
+    if (runtimeVars.length > 0) {
+      console.log(chalk.yellow.bold("Runtime:"));
+      for (const ev of runtimeVars) {
+        const required = ev.is_required ? chalk.red(" *") : "";
+        const line = `${ev.key}=${ev.value}`;
+        console.log(`  ${highlightEnvLine(line)}${required}`);
+      }
+      console.log();
     }
-    console.log();
-  }
 
-  if (buildtimeVars.length > 0) {
-    console.log(chalk.blue.bold("Buildtime:"));
-    for (const ev of buildtimeVars) {
-      console.log(`  ${chalk.green(ev.key)} = ${chalk.gray(ev.value)}`);
+    if (buildtimeVars.length > 0) {
+      console.log(chalk.blue.bold("Buildtime:"));
+      for (const ev of buildtimeVars) {
+        const line = `${ev.key}=${ev.value}`;
+        console.log(`  ${highlightEnvLine(line)}`);
+      }
     }
   }
 }