@mks2508/coolify-mks-cli-mcp 0.5.0 → 0.6.0

package/src/cli/commands/destinations.ts

@@ -6,10 +6,10 @@
  * @module
  */
 
-import { isErr } from '@mks2508/no-throw'
-import chalk from 'chalk'
-import Table from 'cli-table3'
-import { getCoolifyService } from '../../coolify/index.js'
+import { isErr } from "@mks2508/no-throw";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { getCoolifyService } from "../../coolify/index.js";
 
 /**
  * Destinations command handler.
@@ -17,44 +17,36 @@ import { getCoolifyService } from '../../coolify/index.js'
  * @param serverUuid - Server UUID
  */
 export async function destinationsCommand(serverUuid: string) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
 
   if (isErr(initResult)) {
-    console.error(chalk.red(`Error: ${initResult.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${initResult.error.message}`));
+    return;
   }
 
-  const result = await coolify.getServerDestinations(serverUuid)
+  const result = await coolify.getServerDestinations(serverUuid);
 
   if (isErr(result)) {
-    console.error(chalk.red(`Error: ${result.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
   }
 
-  const destinations = result.value
+  const destinations = result.value;
 
   if (destinations.length === 0) {
-    console.log(chalk.yellow('No destinations found'))
-    return
+    console.log(chalk.yellow("No destinations found"));
+    return;
   }
 
   const table = new Table({
-    head: [
-      chalk.cyan('UUID'),
-      chalk.cyan('Name'),
-      chalk.cyan('Network'),
-    ],
-  })
+    head: [chalk.cyan("UUID"), chalk.cyan("Name"), chalk.cyan("Network")],
+  });
 
   for (const dest of destinations) {
-    table.push([
-      dest.uuid,
-      dest.name,
-      dest.network || 'N/A',
-    ])
+    table.push([dest.uuid, dest.name, dest.network || "N/A"]);
   }
 
-  console.log(table.toString())
-  console.log(chalk.gray(`Total: ${destinations.length} destination(s)`))
+  console.log(table.toString());
+  console.log(chalk.gray(`Total: ${destinations.length} destination(s)`));
 }

package/src/cli/commands/diagnose.ts

@@ -0,0 +1,139 @@
+/**
+ * Diagnostic subcommands for CLI — all go through SDK.
+ *
+ * @module
+ */
+
+import { chalk, getCliSdk, formatStatus } from "../actions.js";
+import { resolveUuid } from "../coolify-state.js";
+
+/** Diagnose an application. */
+export async function diagnoseAppCommand(query?: string): Promise<void> {
+  const resolved = query || resolveUuid(undefined);
+  if (!resolved) {
+    console.error(
+      chalk.red("Error: No app name/UUID provided and no .coolify.json found"),
+    );
+    return;
+  }
+
+  console.log(chalk.cyan(`Diagnosing application: ${resolved}...\n`));
+
+  try {
+    const { application, recentDeployments, envVarCount, recentLogs, issues } =
+      await getCliSdk().diagnose.app(resolved);
+
+    console.log(chalk.bold("Application:"));
+    console.log(`  ${chalk.gray("Name:")}   ${application.name}`);
+    console.log(`  ${chalk.gray("UUID:")}   ${application.uuid}`);
+    console.log(
+      `  ${chalk.gray("Status:")} ${formatStatus(application.status)}`,
+    );
+    console.log(`  ${chalk.gray("FQDN:")}   ${application.fqdn || "none"}`);
+    console.log(`  ${chalk.gray("Env vars:")} ${envVarCount}`);
+
+    if (recentDeployments.length > 0) {
+      console.log(chalk.bold("\nRecent Deployments:"));
+      for (const d of recentDeployments) {
+        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())}`,
+        );
+      }
+    }
+
+    if (recentLogs.length > 0) {
+      console.log(chalk.bold("\nRecent Logs (last 5):"));
+      for (const line of recentLogs.slice(-5)) {
+        console.log(`  ${chalk.gray(line)}`);
+      }
+    }
+
+    if (issues.length > 0) {
+      console.log(chalk.bold.red(`\nIssues (${issues.length}):`));
+      for (const issue of issues) {
+        console.log(`  ${chalk.red("!")} ${issue}`);
+      }
+    } else {
+      console.log(chalk.bold.green("\nNo issues detected"));
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}
+
+/** Diagnose a server. */
+export async function diagnoseServerCommand(query: string): Promise<void> {
+  console.log(chalk.cyan(`Diagnosing server: ${query}...\n`));
+
+  try {
+    const { server, resources, domains, issues } =
+      await getCliSdk().diagnose.server(query);
+
+    console.log(chalk.bold("Server:"));
+    console.log(`  ${chalk.gray("Name:")}      ${server.name}`);
+    console.log(`  ${chalk.gray("UUID:")}      ${server.uuid}`);
+    console.log(`  ${chalk.gray("IP:")}        ${server.ip || "-"}`);
+    console.log(
+      `  ${chalk.gray("Reachable:")} ${server.is_reachable ? chalk.green("Yes") : chalk.red("No")}`,
+    );
+    console.log(`  ${chalk.gray("Resources:")} ${resources.length}`);
+    console.log(`  ${chalk.gray("Domains:")}   ${domains.length}`);
+
+    if (issues.length > 0) {
+      console.log(chalk.bold.red(`\nIssues (${issues.length}):`));
+      for (const issue of issues) {
+        console.log(`  ${chalk.red("!")} ${issue}`);
+      }
+    } else {
+      console.log(chalk.bold.green("\nNo issues detected"));
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}
+
+/** Scan all infrastructure for issues. */
+export async function scanIssuesCommand(): Promise<void> {
+  console.log(chalk.cyan("Scanning infrastructure...\n"));
+
+  try {
+    const { totalServers, totalApps, totalDatabases, totalServices, issues } =
+      await getCliSdk().diagnose.infrastructure();
+
+    console.log(chalk.bold("Infrastructure Summary:"));
+    console.log(`  ${chalk.gray("Servers:")}    ${totalServers}`);
+    console.log(`  ${chalk.gray("Apps:")}       ${totalApps}`);
+    console.log(`  ${chalk.gray("Databases:")}  ${totalDatabases}`);
+    console.log(`  ${chalk.gray("Services:")}   ${totalServices}`);
+
+    if (issues.length > 0) {
+      console.log(chalk.bold.red(`\nIssues (${issues.length}):`));
+      for (const issue of issues) {
+        console.log(
+          `  ${chalk.red("!")} [${issue.type}] ${issue.resource} (${issue.uuid}): ${issue.message}`,
+        );
+      }
+    } else {
+      console.log(
+        chalk.bold.green("\nNo issues detected across all infrastructure"),
+      );
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}

package/src/cli/commands/env.ts

@@ -4,99 +4,124 @@
  * @module
  */
 
-import { isErr } from '@mks2508/no-throw'
-import chalk from 'chalk'
-import { getCoolifyService } from '../../coolify/index.js'
+import { isErr } from "@mks2508/no-throw";
+import chalk from "chalk";
+import { getCoolifyService } from "../../coolify/index.js";
+import { resolveUuid } from "../coolify-state.js";
 
 interface IEnvCommandOptions {
-  set?: string
-  delete?: string
-  buildtime?: boolean
+  set?: string;
+  delete?: string;
+  buildtime?: boolean;
 }
 
 /**
  * Env vars command handler.
+ * If no UUID is provided, reads from .coolify.json in the current directory.
  *
- * @param uuid - Application UUID
+ * @param uuid - Application UUID (optional if .coolify.json exists)
  * @param options - Command options
  */
-export async function envCommand(uuid: string, options: IEnvCommandOptions = {}) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+export async function envCommand(
+  uuid: string | undefined,
+  options: IEnvCommandOptions = {},
+) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(
+      chalk.red("Error: No UUID provided and no .coolify.json found"),
+    );
+    return;
+  }
+  uuid = resolvedUuid;
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
 
   if (isErr(initResult)) {
-    console.error(chalk.red(`Error: ${initResult.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${initResult.error.message}`));
+    return;
   }
 
   // Handle --set KEY=VALUE
   if (options.set) {
-    const [key, ...valueParts] = options.set.split('=')
-    const value = valueParts.join('=') // Handle values with = in them
+    const [key, ...valueParts] = options.set.split("=");
+    const value = valueParts.join("="); // Handle values with = in them
 
     if (!key || value === undefined) {
-      console.error(chalk.red('Error: Invalid format. Use --set KEY=VALUE'))
-      return
+      console.error(chalk.red("Error: Invalid format. Use --set KEY=VALUE"));
+      return;
     }
 
-    const result = await coolify.setEnvironmentVariable(uuid, key, value, options.buildtime ?? false)
+    const result = await coolify.setEnvironmentVariable(
+      uuid,
+      key,
+      value,
+      options.buildtime ?? false,
+    );
 
     if (isErr(result)) {
-      console.error(chalk.red(`Error: ${result.error.message}`))
-      return
+      console.error(chalk.red(`Error: ${result.error.message}`));
+      return;
     }
 
-    console.log(chalk.green(`✓ Set ${chalk.bold(key)} for ${uuid.slice(0, 8)}`))
-    return
+    console.log(chalk.green(`✓ Set ${chalk.bold(key)} for ${uuid}`));
+    return;
   }
 
   // Handle --delete KEY
   if (options.delete) {
-    const result = await coolify.deleteEnvironmentVariable(uuid, options.delete)
+    const result = await coolify.deleteEnvironmentVariable(
+      uuid,
+      options.delete,
+    );
 
     if (isErr(result)) {
-      console.error(chalk.red(`Error: ${result.error.message}`))
-      return
+      console.error(chalk.red(`Error: ${result.error.message}`));
+      return;
     }
 
-    console.log(chalk.green(`✓ Deleted ${chalk.bold(options.delete)} from ${uuid.slice(0, 8)}`))
-    return
+    console.log(
+      chalk.green(`✓ Deleted ${chalk.bold(options.delete)} from ${uuid}`),
+    );
+    return;
   }
 
   // Default: list env vars
-  const result = await coolify.getEnvironmentVariables(uuid)
+  const result = await coolify.getEnvironmentVariables(uuid);
 
   if (isErr(result)) {
-    console.error(chalk.red(`Error: ${result.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
   }
 
-  const envVars = result.value
+  const envVars = result.value;
 
   if (envVars.length === 0) {
-    console.log(chalk.yellow('No environment variables found'))
-    return
+    console.log(chalk.yellow("No environment variables found"));
+    return;
   }
 
-  console.log(chalk.cyan(`Environment variables (${envVars.length}):\n`))
+  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)
+  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:'))
+    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)}`)
+      const required = ev.is_required ? chalk.red(" *") : "";
+      console.log(
+        `  ${chalk.green(ev.key)}${required} = ${chalk.gray(ev.value)}`,
+      );
     }
-    console.log()
+    console.log();
   }
 
   if (buildtimeVars.length > 0) {
-    console.log(chalk.blue.bold('Buildtime:'))
+    console.log(chalk.blue.bold("Buildtime:"));
     for (const ev of buildtimeVars) {
-      console.log(`  ${chalk.green(ev.key)} = ${chalk.gray(ev.value)}`)
+      console.log(`  ${chalk.green(ev.key)} = ${chalk.gray(ev.value)}`);
     }
   }
 }

package/src/cli/commands/environments.ts

@@ -4,11 +4,11 @@
  * @module
  */
 
-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 { 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";
 
 /**
  * Environments command handler.
@@ -16,57 +16,61 @@ import { getCoolifyService } from '../../coolify/index.js'
  * @param projectUuid - Project UUID to get environments for
  * @param options - Command options
  */
-export async function environmentsCommand(projectUuid: string, options: { full?: boolean } = {}) {
-  const spinner = ora('Connecting to Coolify...').start()
+export async function environmentsCommand(
+  projectUuid: string,
+  _options: { full?: boolean } = {},
+) {
+  const spinner = ora("Connecting to Coolify...").start();
 
   try {
-    const coolify = getCoolifyService()
-    const initResult = await coolify.init()
+    const coolify = getCoolifyService();
+    const initResult = await coolify.init();
 
     if (isErr(initResult)) {
-      spinner.fail(chalk.red(`Failed to initialize: ${initResult.error.message}`))
-      return
+      spinner.fail(
+        chalk.red(`Failed to initialize: ${initResult.error.message}`),
+      );
+      return;
     }
 
-    spinner.text = `Fetching environments for project ${projectUuid.slice(0, 8)}...`
+    spinner.text = `Fetching environments for project ${projectUuid}...`;
 
-    const result = await coolify.getProjectEnvironments(projectUuid)
+    const result = await coolify.getProjectEnvironments(projectUuid);
 
     if (isOk(result)) {
-      spinner.succeed(chalk.green('Environments retrieved'))
+      spinner.succeed(chalk.green("Environments retrieved"));
 
-      const environments = result.value
+      const environments = result.value;
 
       if (environments.length === 0) {
-        console.log(chalk.yellow('No environments found for this project'))
-        return
+        console.log(chalk.yellow("No environments found for this project"));
+        return;
       }
 
       const table = new Table({
         head: [
-          chalk.cyan('UUID'),
-          chalk.cyan('Name'),
-          chalk.cyan('Description'),
+          chalk.cyan("UUID"),
+          chalk.cyan("Name"),
+          chalk.cyan("Description"),
         ],
-        ...(options.full ? { colWidths: [36, 25, 40] } : {}),
-      })
+      });
 
       for (const env of environments) {
-        table.push([
-          options.full ? env.uuid : env.uuid.slice(0, 8),
-          env.name,
-          env.description || '-',
-        ])
+        table.push([env.uuid, env.name, env.description || "-"]);
       }
 
-      console.log(table.toString())
-      console.log(chalk.gray(`Total: ${environments.length} environment(s)`))
+      console.log(table.toString());
+      console.log(chalk.gray(`Total: ${environments.length} environment(s)`));
     } else {
-      spinner.fail(chalk.red(`Failed to fetch environments: ${result.error.message}`))
+      spinner.fail(
+        chalk.red(`Failed to fetch environments: ${result.error.message}`),
+      );
     }
   } catch (error) {
     spinner.fail(
-      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`)
-    )
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
   }
 }

package/src/cli/commands/exec.ts

@@ -0,0 +1,39 @@
+/**
+ * Execute command on application container — goes through SDK.
+ *
+ * @module
+ */
+
+import { chalk, getCliSdk } from "../actions.js";
+import { resolveUuid } from "../coolify-state.js";
+
+/** Execute a command on an application's running container. */
+export async function execCommand(
+  uuid: string | undefined,
+  command: string,
+): Promise<void> {
+  const resolved = resolveUuid(uuid);
+  if (!resolved) {
+    console.error(
+      chalk.red("Error: No UUID provided and no .coolify.json found"),
+    );
+    return;
+  }
+
+  console.log(chalk.gray(`Executing on ${resolved}: ${command}`));
+
+  try {
+    const result = await getCliSdk().applications.exec(resolved, command);
+    if (result.response) {
+      console.log(result.response);
+    } else if (result.message) {
+      console.log(chalk.green(result.message));
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}

package/src/cli/commands/keys.ts

@@ -0,0 +1,46 @@
+/**
+ * SSH Private key subcommands for CLI — all go through SDK.
+ *
+ * @module
+ */
+
+import { runAction, runList, runGet, chalk } from "../actions.js";
+import type { ICoolifyPrivateKey } from "../../coolify/types.js";
+
+/** List all private keys. */
+export const keysListCommand = () =>
+  runList<ICoolifyPrivateKey>("key(s)", (s) => s.keys.list(), [
+    { header: "UUID", value: (k) => k.uuid },
+    { header: "Name", value: (k) => k.name || "-" },
+    { header: "Git?", value: (k) => (k.is_git_related ? "Yes" : "No") },
+    {
+      header: "Created",
+      value: (k) =>
+        k.created_at ? new Date(k.created_at).toLocaleDateString() : "-",
+    },
+  ]);
+
+/** Get private key details. */
+export const keysGetCommand = (uuid: string) =>
+  runGet<ICoolifyPrivateKey>(
+    uuid,
+    "private key",
+    (s, u) => s.keys.get(u),
+    (key) => {
+      console.log(chalk.cyan("Private Key Details:"));
+      console.log(chalk.gray("UUID:       ") + key.uuid);
+      console.log(chalk.gray("Name:       ") + key.name);
+      console.log(
+        chalk.gray("Git-related:") + (key.is_git_related ? " Yes" : " No"),
+      );
+    },
+  );
+
+/** Delete a private key. */
+export const keysDeleteCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Deleting private key",
+    (s, u) => s.keys.delete(u),
+    (u) => `Private key deleted: ${u}`,
+  );

package/src/cli/commands/list.ts

@@ -4,60 +4,62 @@
  * @module
  */
 
-import { isErr } from '@mks2508/no-throw'
-import chalk from 'chalk'
-import Table from 'cli-table3'
-import { getCoolifyService } from '../../coolify/index.js'
-import { formatStatus } from '../../utils/format.js'
+import { isErr } from "@mks2508/no-throw";
+import chalk from "chalk";
+import Table from "cli-table3";
+import { getCoolifyService } from "../../coolify/index.js";
+import { formatStatus } from "../../utils/format.js";
 
 /**
  * List command handler.
  *
  * @param options - List options
  */
-export async function listCommand(options: { team?: string; project?: string; full?: boolean }) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+export async function listCommand(options: {
+  team?: string;
+  project?: string;
+}) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
 
   if (isErr(initResult)) {
-    console.error(chalk.red(`Error: ${initResult.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${initResult.error.message}`));
+    return;
   }
 
-  const result = await coolify.listApplications(options.team, options.project)
+  const result = await coolify.listApplications(options.team, options.project);
 
   if (isErr(result)) {
-    console.error(chalk.red(`Error: ${result.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
   }
 
-  const apps = result.value
+  const apps = result.value;
 
   if (apps.length === 0) {
-    console.log(chalk.yellow('No applications found'))
-    return
+    console.log(chalk.yellow("No applications found"));
+    return;
   }
 
   // Usar ancho dinámico basado en el contenido
   const table = new Table({
     head: [
-      chalk.cyan('UUID'),
-      chalk.cyan('Name'),
-      chalk.cyan('Status'),
-      chalk.cyan('Server')
+      chalk.cyan("UUID"),
+      chalk.cyan("Name"),
+      chalk.cyan("Status"),
+      chalk.cyan("Server"),
     ],
-    ...(options.full ? { colWidths: [36, 30, 20, 10] } : {}),
-  })
+  });
 
   for (const app of apps) {
     table.push([
-      options.full ? app.uuid : app.uuid.slice(0, 8),
+      app.uuid,
       app.name,
       formatStatus(app.status),
-      app.destination?.server?.name || 'N/A',
-    ])
+      app.destination?.server?.name || "N/A",
+    ]);
   }
 
-  console.log(table.toString())
-  console.log(chalk.gray(`Total: ${apps.length} application(s)`))
+  console.log(table.toString());
+  console.log(chalk.gray(`Total: ${apps.length} application(s)`));
 }