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

package/src/cli/commands/logs.ts

@@ -4,46 +4,61 @@
  * @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";
 
 /**
  * Logs 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 - Logs options
  */
-export async function logsCommand(uuid: string, options: { lines?: number; follow?: boolean }) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+export async function logsCommand(
+  uuid: string | undefined,
+  options: { lines?: number; follow?: boolean },
+) {
+  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;
   }
 
-  const result = await coolify.getApplicationLogs(uuid, { tail: options.lines || 50 })
+  const result = await coolify.getApplicationLogs(uuid, {
+    tail: options.lines || 50,
+  });
 
   if (isErr(result)) {
-    console.error(chalk.red(`Error: ${result.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
   }
 
-  const logs = result.value
+  const logs = result.value;
 
   if (logs.logs.length === 0) {
-    console.log(chalk.yellow('No logs available'))
-    return
+    console.log(chalk.yellow("No logs available"));
+    return;
   }
 
-  console.log(chalk.gray(`Application logs (${logs.logs.length} lines):\n`))
+  console.log(chalk.gray(`Application logs (${logs.logs.length} lines):\n`));
 
   for (const line of logs.logs) {
-    console.log(line)
+    console.log(line);
   }
 
   if (options.follow) {
-    console.log(chalk.yellow('\nFollow mode not yet implemented'))
+    console.log(chalk.yellow("\nFollow mode not yet implemented"));
   }
 }

package/src/cli/commands/network.ts

@@ -0,0 +1,145 @@
+/**
+ * Network diagnostic CLI commands.
+ *
+ * Inspects Docker container networking, DNS, proxy, and connectivity.
+ *
+ * @module
+ */
+
+import { chalk, getCliSdk } from "../actions.js";
+import { resolveUuid } from "../coolify-state.js";
+
+/** Inspect container network environment. */
+export async function networkInspectCommand(
+  uuid: string | undefined,
+  options: { services?: string } = {},
+): Promise<void> {
+  const resolved = resolveUuid(uuid);
+  if (!resolved) {
+    console.error(
+      chalk.red("Error: No UUID provided and no .coolify.json found"),
+    );
+    return;
+  }
+
+  const servicesToTest = options.services
+    ? options.services.split(",").map((s) => s.trim())
+    : [];
+
+  console.log(chalk.cyan(`Inspecting network for ${resolved}...\n`));
+
+  try {
+    const info = await getCliSdk().network.inspect(resolved, servicesToTest);
+
+    // Hosts
+    console.log(chalk.bold("Container Hosts (/etc/hosts):"));
+    if (info.hosts.length > 0) {
+      for (const h of info.hosts) {
+        console.log(`  ${chalk.gray(h)}`);
+      }
+    } else {
+      console.log(chalk.yellow("  No entries"));
+    }
+
+    // Network interfaces
+    if (info.interfaces.length > 0) {
+      console.log(chalk.bold("\nNetwork Interfaces:"));
+      for (const iface of info.interfaces) {
+        console.log(`  ${chalk.gray(iface.trim())}`);
+      }
+    }
+
+    // Network env vars
+    const envEntries = Object.entries(info.networkEnv);
+    if (envEntries.length > 0) {
+      console.log(chalk.bold("\nNetwork Environment Variables:"));
+      for (const [key, val] of envEntries) {
+        console.log(`  ${chalk.green(key)} = ${chalk.gray(val)}`);
+      }
+    }
+
+    // DNS resolution
+    if (info.dns.length > 0) {
+      console.log(chalk.bold("\nDNS Resolution:"));
+      for (const d of info.dns) {
+        const status = d.resolved
+          ? chalk.green(`✓ ${d.ip}`)
+          : chalk.red("✗ FAILED");
+        console.log(`  ${chalk.white(d.hostname)} → ${status}`);
+      }
+    }
+
+    // Connectivity
+    if (info.connectivity.length > 0) {
+      console.log(chalk.bold("\nService Connectivity:"));
+      for (const c of info.connectivity) {
+        const status = c.reachable
+          ? chalk.green(`✓ reachable (${c.responseTime}ms)`)
+          : chalk.red("✗ unreachable");
+        console.log(`  ${chalk.white(c.target)} → ${status}`);
+      }
+    }
+
+    // Trace
+    console.log(chalk.bold("\nTrace:"));
+    for (const step of info.trace.steps) {
+      console.log(
+        `  ${chalk.gray(step.step)} ${chalk.yellow(step.durationMs + "ms")}${step.detail ? chalk.gray(` (${step.detail})`) : ""}`,
+      );
+    }
+    console.log(chalk.gray(`  Total: ${info.trace.totalMs}ms`));
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}
+
+/** Analyze a failed deployment. */
+export async function analyzeDeployCommand(
+  deploymentUuid: string,
+): Promise<void> {
+  console.log(chalk.cyan(`Analyzing deployment ${deploymentUuid}...\n`));
+
+  try {
+    const analysis = await getCliSdk().diagnose.deployFailure(deploymentUuid);
+
+    console.log(chalk.bold("Deployment:"));
+    console.log(`  ${chalk.gray("UUID:")}     ${analysis.deploymentUuid}`);
+    console.log(`  ${chalk.gray("Status:")}   ${analysis.status}`);
+    console.log(
+      `  ${chalk.gray("Category:")} ${chalk.yellow(analysis.category)}`,
+    );
+
+    console.log(chalk.bold.red(`\nDiagnosis: ${analysis.summary}`));
+    console.log(chalk.cyan(`Suggestion: ${analysis.suggestion}`));
+
+    if (analysis.errors.length > 0) {
+      console.log(chalk.bold(`\nError Lines (${analysis.errors.length}):`));
+      for (const line of analysis.errors.slice(0, 10)) {
+        console.log(`  ${chalk.red(line.trim())}`);
+      }
+      if (analysis.errors.length > 10) {
+        console.log(
+          chalk.gray(`  ... and ${analysis.errors.length - 10} more`),
+        );
+      }
+    }
+
+    // Trace
+    console.log(chalk.bold("\nTrace:"));
+    for (const step of analysis.trace.steps) {
+      console.log(
+        `  ${chalk.gray(step.step)} ${chalk.yellow(step.durationMs + "ms")}${step.detail ? chalk.gray(` (${step.detail})`) : ""}`,
+      );
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}

package/src/cli/commands/projects.ts

@@ -4,83 +4,95 @@
  * @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";
 
 /**
  * Projects command handler.
  * Lists all projects, or creates a new one if --create is provided.
  */
-export async function projectsCommand(options: { full?: boolean; create?: string; description?: string } = {}) {
-  const spinner = ora('Connecting to Coolify...').start()
+export async function projectsCommand(
+  options: { full?: boolean; create?: string; description?: string } = {},
+) {
+  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;
     }
 
     // Create mode
     if (options.create) {
-      spinner.text = `Creating project "${options.create}"...`
-      const createResult = await coolify.createProject(options.create, options.description)
+      spinner.text = `Creating project "${options.create}"...`;
+      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)}`)
+        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)}`);
       } else {
-        spinner.fail(chalk.red(`Failed to create project: ${createResult.error.message}`))
+        spinner.fail(
+          chalk.red(`Failed to create project: ${createResult.error.message}`),
+        );
       }
-      return
+      return;
     }
 
     // List mode
-    spinner.text = 'Fetching projects...'
+    spinner.text = "Fetching projects...";
 
-    const result = await coolify.listProjects()
+    const result = await coolify.listProjects();
 
     if (isOk(result)) {
-      spinner.succeed(chalk.green('Projects retrieved'))
+      spinner.succeed(chalk.green("Projects retrieved"));
 
-      const projects = result.value
+      const projects = result.value;
 
       if (projects.length === 0) {
-        console.log(chalk.yellow('No projects found'))
-        return
+        console.log(chalk.yellow("No projects found"));
+        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, 30, 40] } : {}),
-      })
+      });
 
       for (const project of projects) {
-        table.push([
-          options.full ? project.uuid : project.uuid.slice(0, 8),
-          project.name,
-          project.description || '-',
-        ])
+        table.push([project.uuid, project.name, project.description || "-"]);
       }
 
-      console.log(table.toString())
-      console.log(chalk.gray(`Total: ${projects.length} project(s)`))
+      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}`))
+      spinner.fail(
+        chalk.red(`Failed to fetch projects: ${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/restart.ts

@@ -4,41 +4,57 @@
  * @module
  */
 
-import { isErr } from '@mks2508/no-throw'
-import ora from 'ora'
-import chalk from 'chalk'
-import { getCoolifyService } from '../../coolify/index.js'
+import { isErr } from "@mks2508/no-throw";
+import ora from "ora";
+import chalk from "chalk";
+import { getCoolifyService } from "../../coolify/index.js";
+import { resolveUuid } from "../coolify-state.js";
 
 /**
  * Restart 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)
  */
-export async function restartCommand(uuid: string) {
-  const spinner = ora('Initializing Coolify connection...').start()
+export async function restartCommand(uuid?: string) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(
+      chalk.red("Error: No UUID provided and no .coolify.json found"),
+    );
+    return;
+  }
+  uuid = resolvedUuid;
+  const spinner = ora("Initializing Coolify connection...").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 = 'Restarting application...'
+    spinner.text = "Restarting application...";
 
-    const result = await coolify.restartApplication(uuid)
+    const result = await coolify.restartApplication(uuid);
 
     if (isErr(result)) {
-      spinner.fail(chalk.red(`Failed to restart application: ${result.error.message}`))
-      return
+      spinner.fail(
+        chalk.red(`Failed to restart application: ${result.error.message}`),
+      );
+      return;
     }
 
-    spinner.succeed(chalk.green(`Application restarted: ${chalk.cyan(uuid.slice(0, 8))}`))
+    spinner.succeed(chalk.green(`Application restarted: ${chalk.cyan(uuid)}`));
   } 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/server-resources.ts

@@ -0,0 +1,71 @@
+/**
+ * Server resources command for CLI.
+ *
+ * Shows resources deployed on a specific server.
+ *
+ * @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";
+
+/**
+ * Server resources command handler.
+ *
+ * @param serverUuid - Server UUID
+ * @param options - Command options
+ */
+export async function serverResourcesCommand(
+  serverUuid: string,
+  _options: { full?: boolean } = {},
+) {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+
+  const result = await coolify.getServerResources(serverUuid);
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
+  }
+
+  const resources = result.value;
+
+  if (resources.length === 0) {
+    console.log(chalk.yellow("No resources found on this server"));
+    return;
+  }
+
+  const table = new Table({
+    head: [
+      chalk.cyan("UUID"),
+      chalk.cyan("Name"),
+      chalk.cyan("Type"),
+      chalk.cyan("Status"),
+    ],
+  });
+
+  for (const res of resources) {
+    table.push([
+      res.uuid,
+      res.name || "-",
+      res.type || "-",
+      formatStatus(res.status),
+    ]);
+  }
+
+  console.log(table.toString());
+  console.log(
+    chalk.gray(
+      `Total: ${resources.length} resource(s) on server ${serverUuid}`,
+    ),
+  );
+}

package/src/cli/commands/servers.ts

@@ -4,49 +4,49 @@
  * @module
  */
 
-import { isErr } from '@mks2508/no-throw'
-import chalk from 'chalk'
-import { getCoolifyService } from '../../coolify/index.js'
-import { createTable } from '../../utils/format.js'
+import { isErr } from "@mks2508/no-throw";
+import chalk from "chalk";
+import { getCoolifyService } from "../../coolify/index.js";
+import { createTable } from "../../utils/format.js";
 
 /**
  * Servers command handler.
  */
-export async function serversCommand(options: { full?: boolean } = {}) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+export async function serversCommand(_options: { full?: boolean } = {}) {
+  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.listServers()
+  const result = await coolify.listServers();
 
   if (isErr(result)) {
-    console.error(chalk.red(`Error: ${result.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
   }
 
-  const servers = result.value
+  const servers = result.value;
 
   if (servers.length === 0) {
-    console.log(chalk.yellow('No servers found'))
-    return
+    console.log(chalk.yellow("No servers found"));
+    return;
   }
 
-  const table = createTable(['UUID', 'Name', 'IP', 'Status'], [options.full ? 36 : 8, 25, 20, 15])
+  const table = createTable(["UUID", "Name", "IP", "Status"], [28, 25, 20, 15]);
 
   for (const server of servers) {
-    const statusColor = server.is_usable ? chalk.green : chalk.red
+    const statusColor = server.is_usable ? chalk.green : chalk.red;
     table.push([
-      options.full ? server.uuid : server.uuid.slice(0, 8),
+      server.uuid,
       server.name,
-      server.ip || 'N/A',
-      statusColor(server.is_usable ? '● Usable' : '○ Unusable'),
-    ])
+      server.ip || "N/A",
+      statusColor(server.is_usable ? "● Usable" : "○ Unusable"),
+    ]);
   }
 
-  console.log(table.toString())
-  console.log(chalk.gray(`Total: ${servers.length} server(s)`))
+  console.log(table.toString());
+  console.log(chalk.gray(`Total: ${servers.length} server(s)`));
 }

package/src/cli/commands/service-logs.ts

@@ -6,9 +6,9 @@
  * @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";
 
 /**
  * Service logs command handler.
@@ -17,35 +17,43 @@ import { getCoolifyService } from '../../coolify/index.js'
  * @param serviceName - Docker Compose service name
  * @param options - Logs options
  */
-export async function serviceLogsCommand(uuid: string, serviceName: string, options: { lines?: number }) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+export async function serviceLogsCommand(
+  uuid: string,
+  serviceName: string,
+  options: { lines?: number },
+) {
+  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.getApplicationLogs(uuid, {
     tail: options.lines || 50,
     serviceName,
-  })
+  });
 
   if (isErr(result)) {
-    console.error(chalk.red(`Error: ${result.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
   }
 
-  const logs = result.value
+  const logs = result.value;
 
   if (logs.logs.length === 0) {
-    console.log(chalk.yellow(`No logs available for service "${serviceName}"`))
-    return
+    console.log(chalk.yellow(`No logs available for service "${serviceName}"`));
+    return;
   }
 
-  console.log(chalk.gray(`Service "${chalk.white(serviceName)}" logs (${logs.logs.length} lines):\n`))
+  console.log(
+    chalk.gray(
+      `Service "${chalk.white(serviceName)}" logs (${logs.logs.length} lines):\n`,
+    ),
+  );
 
   for (const line of logs.logs) {
-    console.log(line)
+    console.log(line);
   }
 }