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

package/src/cli/commands/projects.ts

@@ -5,94 +5,377 @@
  */
 
 import { isOk, isErr } from "@mks2508/no-throw";
-import ora from "ora";
 import chalk from "chalk";
 import Table from "cli-table3";
 import { getCoolifyService } from "../../coolify/index.js";
+import { resolveProjectNameOrUuid } from "../name-resolver.js";
+import {
+  createSpinner,
+} from "../ui/spinners.js";
+import {
+  createSummaryCard,
+} from "../ui/index.js";
 
 /**
  * Projects command handler.
- * Lists all projects, or creates a new one if --create is provided.
+ * Lists all projects, shows project details, or creates a new one.
  */
 export async function projectsCommand(
-  options: { full?: boolean; create?: string; description?: string } = {},
+  options: {
+    full?: boolean;
+    create?: string;
+    description?: string;
+    show?: string; // Show project details by UUID
+    apps?: string; // Show apps for project by UUID
+  } = {},
 ) {
-  const spinner = ora("Connecting to Coolify...").start();
+  console.log("");
+  console.log(chalk.bold.cyan("┌─────────────────────────────────────────────┐"));
+  console.log(chalk.bold.cyan("│") + chalk.bold.white("  📁 Coolify Projects") + chalk.bold.cyan("                        │"));
+  console.log(chalk.bold.cyan("└─────────────────────────────────────────────┘"));
+  console.log("");
+
+  const spinner = createSpinner({
+    text: "Connecting to Coolify...",
+    color: "cyan",
+  }).start();
 
   try {
     const coolify = getCoolifyService();
     const initResult = await coolify.init();
 
     if (isErr(initResult)) {
-      spinner.fail(
-        chalk.red(`Failed to initialize: ${initResult.error.message}`),
-      );
+      spinner.fail("Connection failed");
+      console.error(chalk.red(`  ✗ Failed to initialize: ${initResult.error.message}`));
       return;
     }
 
+    spinner.succeed("Connected to Coolify");
+
     // Create mode
     if (options.create) {
-      spinner.text = `Creating project "${options.create}"...`;
+      const createSpinner = createSpinner({
+        text: `Creating project "${options.create}"...`,
+        color: "green",
+      }).start();
+
       const createResult = await coolify.createProject(
         options.create,
         options.description,
       );
 
       if (isOk(createResult)) {
-        spinner.succeed(
-          chalk.green(
-            `Project created: ${chalk.cyan(createResult.value.uuid)}`,
-          ),
-        );
-        console.log(`  Name: ${chalk.cyan(options.create)}`);
-        console.log(`  UUID: ${chalk.cyan(createResult.value.uuid)}`);
+        createSpinner.succeed(`Project ${chalk.bold.white(options.create)} created`);
+        console.log("");
+        console.log(createSummaryCard("Project Details", {
+          "Name": { value: options.create, color: chalk.white },
+          "UUID": { value: createResult.value.uuid, color: chalk.cyan },
+          "Description": { value: options.description || "-", color: chalk.gray },
+        }));
+        console.log("");
       } else {
-        spinner.fail(
-          chalk.red(`Failed to create project: ${createResult.error.message}`),
-        );
+        createSpinner.fail("Failed to create project");
+        console.error(chalk.red(`  ✗ ${createResult.error.message}`));
+      }
+      return;
+    }
+
+    // Show project details mode
+    if (options.show) {
+      const resolvedShow = await resolveProjectNameOrUuid(options.show);
+      if (!resolvedShow) {
+        console.error(chalk.red(`  ✗ Project not found: ${options.show}`));
+        return;
       }
+      await showProjectDetails(coolify, resolvedShow);
+      return;
+    }
+
+    // Show apps for project mode
+    if (options.apps) {
+      const resolvedApps = await resolveProjectNameOrUuid(options.apps);
+      if (!resolvedApps) {
+        console.error(chalk.red(`  ✗ Project not found: ${options.apps}`));
+        return;
+      }
+      await showProjectApps(coolify, resolvedApps);
       return;
     }
 
     // List mode
-    spinner.text = "Fetching projects...";
+    const listSpinner = createSpinner({
+      text: "Fetching projects...",
+      color: "cyan",
+    }).start();
 
     const result = await coolify.listProjects();
 
     if (isOk(result)) {
-      spinner.succeed(chalk.green("Projects retrieved"));
+      listSpinner.succeed(`Found ${chalk.bold.green(String(result.value.length))} project(s)`);
 
       const projects = result.value;
 
       if (projects.length === 0) {
-        console.log(chalk.yellow("No projects found"));
+        console.log("");
+        console.log(chalk.yellow("  ⚠ No projects found"));
+        console.log("");
         return;
       }
 
+      console.log("");
       const table = new Table({
         head: [
-          chalk.cyan("UUID"),
           chalk.cyan("Name"),
+          chalk.cyan("UUID"),
           chalk.cyan("Description"),
         ],
+        wordWrap: true,
+        colWidths: [30, 40, 50],
       });
 
       for (const project of projects) {
-        table.push([project.uuid, project.name, project.description || "-"]);
+        table.push([
+          chalk.white(project.name),
+          chalk.gray(project.uuid.slice(0, 8) + "..."),
+          project.description || chalk.gray("-"),
+        ]);
       }
 
       console.log(table.toString());
-      console.log(chalk.gray(`Total: ${projects.length} project(s)`));
-    } else {
-      spinner.fail(
-        chalk.red(`Failed to fetch projects: ${result.error.message}`),
+      console.log("");
+      console.log(chalk.gray("  Commands:"));
+      console.log(
+        "    " +
+          chalk.cyan("coolify-cli projects --show <uuid>") +
+          chalk.gray("  - Show project details"),
       );
+      console.log(
+        "    " +
+          chalk.cyan("coolify-cli projects --apps <uuid>") +
+          chalk.gray("  - Show apps in project"),
+      );
+      console.log("");
+    } else {
+      listSpinner.fail("Failed to fetch projects");
+      console.error(chalk.red(`  ✗ ${result.error.message}`));
     }
   } catch (error) {
-    spinner.fail(
+    spinner.fail("Error");
+    console.error(
       chalk.red(
-        `Error: ${error instanceof Error ? error.message : String(error)}`,
+        `  ✗ ${error instanceof Error ? error.message : String(error)}`,
       ),
     );
   }
 }
+
+/**
+ * Show detailed information about a project.
+ */
+async function showProjectDetails(coolify: any, projectUuid: string) {
+  const spinner = createSpinner({
+    text: "Fetching project details...",
+    color: "cyan",
+  }).start();
+
+  // Get project info
+  const projectsResult = await coolify.listProjects();
+  if (isErr(projectsResult)) {
+    spinner.fail("Failed to fetch project");
+    console.error(chalk.red(`  ✗ ${projectsResult.error.message}`));
+    return;
+  }
+
+  const project = projectsResult.value.find((p: any) => p.uuid === projectUuid);
+  if (!project) {
+    spinner.fail("Project not found");
+    console.error(chalk.red(`  ✗ Project not found: ${projectUuid}`));
+    return;
+  }
+
+  // Get environments
+  const envsResult = await coolify.getProjectEnvironments(projectUuid);
+  const environments = isOk(envsResult) ? envsResult.value : [];
+
+  // Get all apps and filter by project
+  const appsResult = await coolify.listApplications();
+  const projectApps = isOk(appsResult)
+    ? appsResult.value.filter((app: any) => app.environment_id &&
+      environments.some((env: any) => env.id === app.environment_id))
+    : [];
+
+  // Get all databases and filter by project
+  const dbsResult = await coolify.listDatabases();
+  const projectDbs = isOk(dbsResult)
+    ? dbsResult.value.filter((db: any) => db.environment_id &&
+      environments.some((env: any) => env.id === db.environment_id))
+    : [];
+
+  spinner.succeed("Project details retrieved");
+
+  console.log("");
+  console.log(createSummaryCard("Project Details", {
+    "Name": { value: project.name, color: chalk.white },
+    "UUID": { value: project.uuid, color: chalk.gray },
+    "Description": { value: project.description || "-", color: chalk.gray },
+    "Environments": { value: String(environments.length), color: chalk.cyan },
+    "Applications": { value: String(projectApps.length), color: chalk.green },
+    "Databases": { value: String(projectDbs.length), color: chalk.yellow },
+  }));
+
+  // Show environments
+  if (environments.length > 0) {
+    console.log("");
+    console.log(chalk.gray("  ") + chalk.bold("Environments:"));
+    console.log("");
+    for (const env of environments) {
+      const envApps = projectApps.filter((app: any) => app.environment_id === env.id);
+      const envDbs = projectDbs.filter((db: any) => db.environment_id === env.id);
+      console.log(
+        "    " +
+          chalk.cyan("●") +
+          " " +
+          chalk.bold.white(env.name) +
+          chalk.gray(` (${env.uuid.slice(0, 8)}...)`),
+      );
+      console.log(
+        "      " +
+          chalk.gray("Apps: ") +
+          chalk.green(String(envApps.length)) +
+          chalk.gray(" | Databases: ") +
+          chalk.yellow(String(envDbs.length)),
+      );
+    }
+    console.log("");
+  }
+
+  // Show apps
+  if (projectApps.length > 0) {
+    console.log("");
+    console.log(chalk.gray("  ") + chalk.bold("Applications:"));
+    console.log("");
+    for (const app of projectApps) {
+      const statusIcon = app.status.includes("running")
+        ? chalk.green("●")
+        : chalk.yellow("○");
+      console.log(
+        "    " +
+          statusIcon +
+          " " +
+          chalk.bold.white(app.name) +
+          chalk.gray(` (${app.uuid.slice(0, 8)}...)`),
+      );
+      console.log(
+        "      " +
+          chalk.gray("Status: ") +
+          chalk.white(app.status) +
+          chalk.gray(" | Branch: ") +
+          chalk.cyan(app.git_branch || "-"),
+      );
+    }
+    console.log("");
+  }
+
+  // Show databases
+  if (projectDbs.length > 0) {
+    console.log("");
+    console.log(chalk.gray("  ") + chalk.bold("Databases:"));
+    console.log("");
+    for (const db of projectDbs) {
+      const statusIcon = db.status === "running"
+        ? chalk.green("●")
+        : chalk.yellow("○");
+      console.log(
+        "    " +
+          statusIcon +
+          " " +
+          chalk.bold.white(db.name) +
+          chalk.gray(` (${db.type})`),
+      );
+      console.log(
+        "      " +
+          chalk.gray("Status: ") +
+          chalk.white(db.status) +
+          chalk.gray(" | UUID: ") +
+          chalk.gray(db.uuid.slice(0, 8)) +
+          chalk.gray("..."),
+      );
+    }
+    console.log("");
+  }
+}
+
+/**
+ * Show all applications in a project.
+ */
+async function showProjectApps(coolify: any, projectUuid: string) {
+  const spinner = createSpinner({
+    text: "Fetching project applications...",
+    color: "cyan",
+  }).start();
+
+  // Get environments
+  const envsResult = await coolify.getProjectEnvironments(projectUuid);
+  const environments = isOk(envsResult) ? envsResult.value : [];
+
+  // Get all apps and filter by project
+  const appsResult = await coolify.listApplications();
+  const projectApps = isOk(appsResult)
+    ? appsResult.value.filter((app: any) => app.environment_id &&
+      environments.some((env: any) => env.id === app.environment_id))
+    : [];
+
+  spinner.succeed(`Found ${chalk.bold.green(String(projectApps.length))} application(s)`);
+
+  if (projectApps.length === 0) {
+    console.log("");
+    console.log(chalk.yellow("  ⚠ No applications found in this project"));
+    console.log("");
+    return;
+  }
+
+  console.log("");
+  const table = new Table({
+    head: [
+      chalk.cyan("Name"),
+      chalk.cyan("Status"),
+      chalk.cyan("Type"),
+      chalk.cyan("Branch"),
+      chalk.cyan("UUID"),
+    ],
+    wordWrap: true,
+    colWidths: [30, 20, 15, 15, 40],
+  });
+
+  for (const app of projectApps) {
+    const statusColor = app.status.includes("running") ? chalk.green : chalk.yellow;
+    const appType = getAppTypeFromSourceType(app.source_type);
+
+    table.push([
+      chalk.white(app.name),
+      statusColor(app.status),
+      chalk.gray(appType),
+      chalk.cyan(app.git_branch || "-"),
+      chalk.gray(app.uuid.slice(0, 8) + "..."),
+    ]);
+  }
+
+  console.log(table.toString());
+  console.log("");
+}
+
+/**
+ * Map source_type to readable app type.
+ */
+function getAppTypeFromSourceType(sourceType: string | undefined): string {
+  if (!sourceType) return "unknown";
+
+  if (sourceType.includes("GithubApp")) return "github-app";
+  if (sourceType.includes("DeployKey")) return "deploy-key";
+  if (sourceType.includes("Dockerfile")) return "dockerfile";
+  if (sourceType.includes("DockerCompose")) return "docker-compose";
+  if (sourceType.includes("DockerImage")) return "docker-image";
+  if (sourceType.includes("Public")) return "public";
+
+  return "unknown";
+}

package/src/cli/commands/restart.ts

@@ -9,6 +9,7 @@ import ora from "ora";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
 import { resolveUuid } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
 
 /**
  * Restart command handler.
@@ -17,10 +18,13 @@ import { resolveUuid } from "../coolify-state.js";
  * @param uuid - Application UUID (optional if .coolify.json exists)
  */
 export async function restartCommand(uuid?: string) {
-  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/service-logs.ts

@@ -9,6 +9,8 @@
 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";
 
 /**
  * Service logs command handler.
@@ -22,6 +24,18 @@ export async function serviceLogsCommand(
   serviceName: string,
   options: { lines?: number },
 ) {
+  let resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid && uuid) {
+    resolvedUuid = await resolveAppNameOrUuid(uuid);
+  }
+  if (!resolvedUuid) {
+    console.error(
+      chalk.red("Error: No UUID/name provided and no .coolify.json found"),
+    );
+    return;
+  }
+  uuid = resolvedUuid;
+
   const coolify = getCoolifyService();
   const initResult = await coolify.init();
 

package/src/cli/commands/show.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";
 
 /**
  * Show command handler.
@@ -18,10 +19,13 @@ import { resolveUuid } from "../coolify-state.js";
  * @param uuid - Application UUID (optional if .coolify.json exists)
  */
 export async function showCommand(uuid?: string) {
-  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/start.ts

@@ -9,6 +9,7 @@ import ora from "ora";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
 import { resolveUuid } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
 
 /**
  * Start command handler.
@@ -17,10 +18,13 @@ import { resolveUuid } from "../coolify-state.js";
  * @param uuid - Application UUID (optional if .coolify.json exists)
  */
 export async function startCommand(uuid?: string) {
-  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;
   }