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

package/src/cli/index.ts

@@ -9,12 +9,17 @@
 
 import { Command } from "commander";
 import chalk from "chalk";
+import { setVerbosity } from "@mks2508/better-logger";
+
+// Silence SDK logger in CLI mode — all progress goes through spinners/prompts
+setVerbosity("silent");
 import { createCommand } from "./commands/create.js";
 import { deployCommand } from "./commands/deploy.js";
 import { listCommand } from "./commands/list.js";
 import { logsCommand } from "./commands/logs.js";
 import { serversCommand } from "./commands/servers.js";
 import { projectsCommand } from "./commands/projects.js";
+import { statusCommand } from "./commands/status.js";
 import { environmentsCommand } from "./commands/environments.js";
 import { configCommand } from "./commands/config.js";
 import { envCommand } from "./commands/env.js";
@@ -28,6 +33,7 @@ import { stopCommand } from "./commands/stop.js";
 import { restartCommand } from "./commands/restart.js";
 import { buildLogsCommand } from "./commands/build-logs.js";
 import { serviceLogsCommand } from "./commands/service-logs.js";
+import { initCommand } from "./commands/init.js";
 import { versionCommand } from "./commands/version.js";
 import { databasesCommand } from "./commands/databases.js";
 import { servicesCommand as servicesListCommand } from "./commands/services.js";
@@ -37,6 +43,7 @@ import {
   dbListCommand,
   dbGetCommand,
   dbCreateCommand,
+  dbUpdateCommand,
   dbStartCommand,
   dbStopCommand,
   dbRestartCommand,
@@ -75,13 +82,30 @@ import {
   networkInspectCommand,
   analyzeDeployCommand,
 } from "./commands/network.js";
+import {
+  volumesListCommand,
+  volumesAddCommand,
+  volumesRemoveCommand,
+} from "./commands/volumes.js";
 
 const program = new Command();
 
+// Detect binary name to show correct help
+const binaryName = process.argv[1]?.includes("coolify-cli") ? "coolify-cli" : "coolify-mcp";
+
 program
-  .name("coolify-mcp")
-  .description("CLI for Coolify deployment management")
-  .version("0.1.0");
+  .name(binaryName)
+  .description(
+    `${chalk.bold.hex("#8c52ff")("Coolify CLI")} — Manage deployments, env vars, and resources\n` +
+    `  Global: ${chalk.gray("bun install -g @mks2508/coolify-mks-cli-mcp")}`,
+  )
+  .version("0.9.0")
+  .addHelpText("beforeAll", () => {
+    // Show banner before help output
+    const { showAutoBanner } = require("./ui/banner.js");
+    showAutoBanner("0.9.0");
+    return "";
+  });
 
 // Create application
 program
@@ -126,6 +150,18 @@ program
     'Base directory for build context (default: "/")',
     "/",
   )
+  .option(
+    "--github-app-uuid <uuid>",
+    "GitHub App UUID (auto-detected if not provided)",
+  )
+  .option(
+    "--private-key-uuid <uuid>",
+    "Private key UUID (required for private-deploy-key type)",
+  )
+  .option(
+    "--domain <domain>",
+    "Domain to set after creation (e.g., app.example.com or https://app.example.com)",
+  )
   .action(createCommand);
 
 // Config command
@@ -137,6 +173,16 @@ program
   .option("--value <value>", 'Configuration value (for "set" action)')
   .action(configCommand);
 
+// Init application (link existing or create new)
+program
+  .command("init")
+  .description("Initialize Coolify deployment (link existing or create new)")
+  .option("--yes", "Auto-mode with defaults")
+  .option("--force", "Ignore existing .coolify.json")
+  .option("--name <name>", "App name")
+  .option("--link", "Link-only mode (don't create new apps)")
+  .action(initCommand);
+
 // List applications
 program
   .command("list")
@@ -152,6 +198,8 @@ program
   .description("Deploy an application (reads .coolify.json if no UUID)")
   .option("-f, --force", "Force rebuild without cache")
   .option("-t, --tag <tag>", "Deploy specific tag/version")
+  .option("--all", "Deploy all apps from .coolify.json in parallel")
+  .option("--service <name>", "Deploy specific service from .coolify.json")
   .action(deployCommand);
 
 // Logs command
@@ -159,10 +207,17 @@ program
   .command("logs [uuid]")
   .description("Get application logs (reads .coolify.json if no UUID)")
   .option("-n, --lines <number>", "Number of lines to retrieve", "50")
-  .option("-f, --follow", "Follow logs in real-time")
+  .option("-f, --follow", "Follow logs in real-time (polls every 2s)")
+  .option("--errors", "Show errors only")
+  .option("--since <duration>", "Show logs since duration (e.g. 1h, 30m, 2d)")
   .action((uuid, options) => {
     const lines = parseInt(options.lines, 10);
-    logsCommand(uuid, { lines, follow: options.follow });
+    logsCommand(uuid, {
+      lines,
+      follow: options.follow,
+      errors: options.errors,
+      since: options.since,
+    });
   });
 
 // Servers command
@@ -172,6 +227,13 @@ program
 
   .action((options) => serversCommand(options));
 
+// Status dashboard
+program
+  .command("status")
+  .description("Show status dashboard")
+  .option("-w, --watch", "Auto-refresh every 5s")
+  .action((options) => statusCommand(options));
+
 // Projects command
 program
   .command("projects")
@@ -179,6 +241,8 @@ program
 
   .option("--create <name>", "Create a new project with this name")
   .option("--description <desc>", "Project description (use with --create)")
+  .option("--show <uuid>", "Show project details with environments, apps, and databases")
+  .option("--apps <uuid>", "Show all applications in a project")
   .action((options) => projectsCommand(options));
 
 // Environments command
@@ -192,9 +256,21 @@ program
 program
   .command("env [uuid]")
   .description("Manage env vars (reads .coolify.json if no UUID)")
-  .option("--set <KEY=VALUE>", "Set an environment variable")
+  .option(
+    "--set <KEY=VALUE>",
+    "Set an environment variable (can be repeated: --set A=1 --set B=2)",
+    (value: string, prev: string[] | undefined) => (prev ?? []).concat(value),
+    [] as string[],
+  )
   .option("--delete <KEY>", "Delete an environment variable")
+  .option("--get <KEY>", "Get a single environment variable value (prints value, no colors)")
   .option("--buildtime", "Mark variable as build-time only (use with --set)")
+  .option("--runtime-only", "Mark variable as runtime only, not build-time (use with --set)")
+  .option("--sync [file]", "Sync env vars from .env file (default: .env, or stdin with -)")
+  .option("--dry-run", "Preview changes without applying (use with --sync)")
+  .option("--prune", "Delete vars not in file (use with --sync)")
+  .option("--table", "Show env vars in table format")
+  .option("--json", "Output machine-parseable JSON (ICoolifyEnvVar[])")
   .action((uuid, options) => envCommand(uuid, options));
 
 // Update application
@@ -223,7 +299,20 @@ program
   )
   .option("--auto-deploy", "Enable auto-deploy on git push")
   .option("--no-auto-deploy", "Disable auto-deploy on git push")
+  .option(
+    "--watch-paths <paths>",
+    'Watch paths for selective auto-deploy (newline-separated globs, e.g. "src/**\\npackages/**")',
+  )
+  .option("--clear-watch-paths", "Clear watch paths (deploy on all changes)")
   .option("--force-https", "Enable forced HTTPS redirect")
+  .option("--health-check-enabled", "Enable health check")
+  .option("--no-health-check-enabled", "Disable health check")
+  .option("--health-check-path <path>", "Health check path (e.g., /health)")
+  .option("--health-check-port <port>", "Health check port")
+  .option("--health-check-interval <seconds>", "Health check interval in seconds")
+  .option("--health-check-timeout <seconds>", "Health check timeout in seconds")
+  .option("--health-check-retries <n>", "Health check retries")
+  .option("--health-check-start-period <seconds>", "Health check start period in seconds")
   .action((uuid, options) => updateCommand({ uuid, ...options }));
 
 // Delete application
@@ -335,6 +424,12 @@ db.command("list").description("List all databases").action(dbListCommand);
 db.command("get <uuid>")
   .description("Get database details")
   .action(dbGetCommand);
+db.command("update <uuid>")
+  .description("Update database configuration")
+  .option("--public-port <port>", "Publish port (e.g., 127.0.0.1:5432 or 5432)")
+  .option("--is-public", "Make database publicly accessible")
+  .option("--no-is-public", "Make database private")
+  .action((uuid, options) => dbUpdateCommand(uuid, options));
 db.command("create <type>")
   .description(
     "Create database (postgresql, mysql, mariadb, mongodb, redis, keydb, clickhouse, dragonfly)",
@@ -479,11 +574,43 @@ program
   .description("Analyze a failed deployment (extract errors, suggest fixes)")
   .action(analyzeDeployCommand);
 
-// Show help by default
-program.action(() => {
-  console.log(chalk.cyan("Coolify MCP CLI v0.6.0"));
-  console.log(chalk.gray("Manage Coolify deployments from the command line\n"));
-  program.help();
+// ─── Volumes subcommands ──────────────────────────────────────────────────────
+
+const volumes = program.command("volumes").description("Manage volumes for docker-compose apps");
+volumes
+  .command("list <uuid>")
+  .description("List volumes for an application")
+  .option("--service <name>", "Service name (for multi-service compose)")
+  .action((uuid, options) => volumesListCommand(uuid, options));
+volumes
+  .command("add <uuid>")
+  .description("Add a bind mount volume")
+  .requiredOption("--source <path>", "Source path on host")
+  .requiredOption("--target <path>", "Target path in container")
+  .option("--service <name>", "Service name (required for multi-service compose)")
+  .option("--no-restart", "Skip automatic redeploy after adding volume")
+  .action((uuid, options) => volumesAddCommand(uuid, options));
+volumes
+  .command("remove <uuid>")
+  .description("Remove a volume by target path")
+  .requiredOption("--target <path>", "Target path in container to remove")
+  .option("--service <name>", "Service name (required for multi-service compose)")
+  .option("--no-restart", "Skip automatic redeploy after removing volume")
+  .action((uuid, options) => volumesRemoveCommand(uuid, options));
+volumes.action(() => volumes.help());
+
+// Show help by default (or interactive menu if no args)
+program.action(async () => {
+  // If called without arguments, show interactive menu
+  if (process.argv.length <= 2) {
+    const { mainMenu } = await import("./commands/main-menu.js");
+    await mainMenu();
+  } else {
+    // Show help if called with unknown command
+    console.log(chalk.cyan("Coolify MCP CLI v0.8.0"));
+    console.log(chalk.gray("Manage Coolify deployments from the command line\n"));
+    program.help();
+  }
 });
 
 program.parse();

package/src/cli/name-resolver.ts

@@ -0,0 +1,228 @@
+/**
+ * Name-to-UUID resolver for CLI.
+ *
+ * Allows users to reference Coolify resources by friendly name instead
+ * of UUID. Caches API responses in-memory during the CLI session.
+ *
+ * @module
+ */
+
+import { isOk } from "@mks2508/no-throw";
+import { getCoolifyService } from "../coolify/index.js";
+import type { ICoolifyApplication } from "../coolify/types.js";
+import type { ICoolifyDatabase } from "../coolify/types.js";
+import type { ICoolifyProject } from "../coolify/types.js";
+import type { ICoolifyService as ICoolifyServiceType } from "../coolify/types.js";
+
+/** In-memory cache for API responses during a single CLI session. */
+const cache = {
+  apps: null as ICoolifyApplication[] | null,
+  databases: null as ICoolifyDatabase[] | null,
+  services: null as ICoolifyServiceType[] | null,
+  projects: null as ICoolifyProject[] | null,
+};
+
+/**
+ * Checks if a string looks like a Coolify UUID.
+ *
+ * Coolify UUIDs are lowercase alphanumeric strings, typically 20-30 chars.
+ *
+ * @param value - The string to check
+ * @returns True if the string looks like a UUID
+ */
+function looksLikeUuid(value: string): boolean {
+  return /^[a-z0-9]{16,40}$/.test(value);
+}
+
+/**
+ * Fetches and caches the list of applications from Coolify API.
+ *
+ * @returns Array of applications, or empty array on error
+ */
+async function getApps(): Promise<ICoolifyApplication[]> {
+  if (cache.apps) return cache.apps;
+
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isOk(initResult)) {
+    const result = await coolify.listApplications();
+    if (isOk(result)) {
+      cache.apps = result.value;
+      return cache.apps;
+    }
+  }
+  return [];
+}
+
+/**
+ * Fetches and caches the list of databases from Coolify API.
+ *
+ * @returns Array of databases, or empty array on error
+ */
+async function getDatabases(): Promise<ICoolifyDatabase[]> {
+  if (cache.databases) return cache.databases;
+
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isOk(initResult)) {
+    const result = await coolify.listDatabases();
+    if (isOk(result)) {
+      cache.databases = result.value;
+      return cache.databases;
+    }
+  }
+  return [];
+}
+
+/**
+ * Fetches and caches the list of services from Coolify API.
+ *
+ * @returns Array of services, or empty array on error
+ */
+async function getServices(): Promise<ICoolifyServiceType[]> {
+  if (cache.services) return cache.services;
+
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isOk(initResult)) {
+    const result = await coolify.listServices();
+    if (isOk(result)) {
+      cache.services = result.value;
+      return cache.services;
+    }
+  }
+  return [];
+}
+
+/**
+ * Resolves a name or UUID to a UUID.
+ *
+ * Accepts: UUID directly, app name, database name, or service name.
+ * Searches applications first, then databases, then services.
+ * Results are cached in-memory for the duration of the CLI session.
+ *
+ * @param nameOrUuid - A friendly name or UUID string
+ * @returns The resolved UUID, or null if not found
+ */
+export async function resolveNameOrUuid(
+  nameOrUuid: string,
+): Promise<string | null> {
+  if (looksLikeUuid(nameOrUuid)) return nameOrUuid;
+
+  const query = nameOrUuid.toLowerCase();
+
+  // Search applications
+  const apps = await getApps();
+  const app = apps.find((a) => a.name?.toLowerCase() === query);
+  if (app) return app.uuid;
+
+  // Search databases
+  const databases = await getDatabases();
+  const db = databases.find((d) => d.name?.toLowerCase() === query);
+  if (db) return db.uuid;
+
+  // Search services
+  const services = await getServices();
+  const svc = services.find((s) => s.name?.toLowerCase() === query);
+  if (svc) return svc.uuid;
+
+  return null;
+}
+
+/**
+ * Resolves a name or UUID specifically for applications.
+ *
+ * @param nameOrUuid - A friendly name or UUID string
+ * @returns The resolved application UUID, or null if not found
+ */
+export async function resolveAppNameOrUuid(
+  nameOrUuid: string,
+): Promise<string | null> {
+  if (looksLikeUuid(nameOrUuid)) return nameOrUuid;
+
+  const query = nameOrUuid.toLowerCase();
+  const apps = await getApps();
+  const app = apps.find((a) => a.name?.toLowerCase() === query);
+  return app?.uuid ?? null;
+}
+
+/**
+ * Resolves a name or UUID specifically for databases.
+ *
+ * @param nameOrUuid - A friendly name or UUID string
+ * @returns The resolved database UUID, or null if not found
+ */
+export async function resolveDbNameOrUuid(
+  nameOrUuid: string,
+): Promise<string | null> {
+  if (looksLikeUuid(nameOrUuid)) return nameOrUuid;
+
+  const query = nameOrUuid.toLowerCase();
+  const databases = await getDatabases();
+  const db = databases.find((d) => d.name?.toLowerCase() === query);
+  return db?.uuid ?? null;
+}
+
+/**
+ * Fetches and caches the list of projects from Coolify API.
+ *
+ * @returns Array of projects, or empty array on error
+ */
+async function getProjects(): Promise<ICoolifyProject[]> {
+  if (cache.projects) return cache.projects;
+
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+  if (isOk(initResult)) {
+    const result = await coolify.listProjects();
+    if (isOk(result)) {
+      cache.projects = result.value;
+      return cache.projects;
+    }
+  }
+  return [];
+}
+
+/**
+ * Resolves a name or UUID specifically for projects.
+ *
+ * @param nameOrUuid - A friendly name or UUID string
+ * @returns The resolved project UUID, or null if not found
+ */
+export async function resolveProjectNameOrUuid(
+  nameOrUuid: string,
+): Promise<string | null> {
+  if (looksLikeUuid(nameOrUuid)) return nameOrUuid;
+
+  const query = nameOrUuid.toLowerCase();
+  const projects = await getProjects();
+  const project = projects.find((p) => p.name?.toLowerCase() === query);
+  return project?.uuid ?? null;
+}
+
+/**
+ * Resolves a name or UUID specifically for services.
+ *
+ * @param nameOrUuid - A friendly name or UUID string
+ * @returns The resolved service UUID, or null if not found
+ */
+export async function resolveSvcNameOrUuid(
+  nameOrUuid: string,
+): Promise<string | null> {
+  if (looksLikeUuid(nameOrUuid)) return nameOrUuid;
+
+  const query = nameOrUuid.toLowerCase();
+  const services = await getServices();
+  const svc = services.find((s) => s.name?.toLowerCase() === query);
+  return svc?.uuid ?? null;
+}
+
+/**
+ * Clears the in-memory cache. Useful for testing or long-running sessions.
+ */
+export function clearResolverCache(): void {
+  cache.apps = null;
+  cache.databases = null;
+  cache.services = null;
+  cache.projects = null;
+}