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

package/src/cli/commands/create.ts

@@ -4,30 +4,36 @@
  * @module
  */
 
-import { isOk, isErr } from '@mks2508/no-throw'
-import ora from 'ora'
-import chalk from 'chalk'
-import { getCoolifyService } from '../../coolify/index.js'
+import { isOk, isErr } from "@mks2508/no-throw";
+import ora from "ora";
+import chalk from "chalk";
+import { getCoolifyService } from "../../coolify/index.js";
 
 /**
  * Create command options.
  */
 interface ICreateOptions {
-  name: string
-  description?: string
-  server: string
-  project: string
-  environment?: string
-  repo?: string
-  branch?: string
-  type?: 'public' | 'private-github-app' | 'private-deploy-key' | 'dockerfile' | 'docker-image' | 'docker-compose'
-  buildPack?: 'dockerfile' | 'nixpacks' | 'static' | 'dockercompose'
-  ports?: string
-  dockerImage?: string
-  dockerCompose?: string
-  dockerComposeLocation?: string
-  dockerfileLocation?: string
-  baseDirectory?: string
+  name: string;
+  description?: string;
+  server: string;
+  project: string;
+  environment?: string;
+  repo?: string;
+  branch?: string;
+  type?:
+    | "public"
+    | "private-github-app"
+    | "private-deploy-key"
+    | "dockerfile"
+    | "docker-image"
+    | "docker-compose";
+  buildPack?: "dockerfile" | "nixpacks" | "static" | "dockercompose";
+  ports?: string;
+  dockerImage?: string;
+  dockerCompose?: string;
+  dockerComposeLocation?: string;
+  dockerfileLocation?: string;
+  baseDirectory?: string;
 }
 
 /**
@@ -36,43 +42,51 @@ interface ICreateOptions {
  * @param options - Create options
  */
 export async function createCommand(options: ICreateOptions) {
-  const spinner = ora('Initializing Coolify connection...').start()
+  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;
     }
 
     // Auto-fetch environment UUID if not provided
-    let environmentUuid: string | undefined = options.environment
+    let environmentUuid: string | undefined = options.environment;
 
     if (!environmentUuid) {
-      spinner.text = 'Fetching project environments...'
+      spinner.text = "Fetching project environments...";
 
-      const envResult = await coolify.getProjectEnvironments(options.project)
+      const envResult = await coolify.getProjectEnvironments(options.project);
 
       if (isOk(envResult) && envResult.value.length > 0) {
         // Use the first environment (usually "production")
-        environmentUuid = envResult.value[0].uuid
-        const envName = envResult.value[0].name
-        spinner.info(chalk.cyan(`Using environment: ${envName} (${environmentUuid.slice(0, 8)}...)`))
+        environmentUuid = envResult.value[0].uuid;
+        const envName = envResult.value[0].name;
+        spinner.info(
+          chalk.cyan(`Using environment: ${envName} (${environmentUuid})`),
+        );
       } else {
-        spinner.fail(chalk.red('No environments found for project. Please specify --environment <uuid>'))
-        return
+        spinner.fail(
+          chalk.red(
+            "No environments found for project. Please specify --environment <uuid>",
+          ),
+        );
+        return;
       }
     }
 
     // Ensure environmentUuid is defined before creating application
     if (!environmentUuid) {
-      spinner.fail(chalk.red('Environment UUID is required'))
-      return
+      spinner.fail(chalk.red("Environment UUID is required"));
+      return;
     }
 
-    spinner.text = 'Creating application...'
+    spinner.text = "Creating application...";
 
     const result = await coolify.createApplication(
       {
@@ -81,11 +95,11 @@ export async function createCommand(options: ICreateOptions) {
         projectUuid: options.project,
         environmentUuid,
         serverUuid: options.server,
-        type: options.type || 'public',
+        type: options.type || "public",
         githubRepoUrl: options.repo,
-        branch: options.branch || 'main',
-        buildPack: options.buildPack || 'dockerfile',
-        portsExposes: options.ports || '3000',
+        branch: options.branch || "main",
+        buildPack: options.buildPack || "dockerfile",
+        portsExposes: options.ports || "3000",
         dockerImage: options.dockerImage,
         dockerCompose: options.dockerCompose,
         dockerComposeLocation: options.dockerComposeLocation,
@@ -93,26 +107,33 @@ export async function createCommand(options: ICreateOptions) {
         baseDirectory: options.baseDirectory,
       },
       (percent, message) => {
-        spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`
-      }
-    )
+        spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`;
+      },
+    );
 
     if (isOk(result)) {
       spinner.succeed(
-        chalk.green(`Application created! UUID: ${chalk.cyan(result.value.uuid?.slice(0, 8))}`)
-      )
-      console.log(`  Full UUID: ${chalk.cyan(result.value.uuid)}`)
-      console.log(`  Name: ${chalk.cyan(options.name)}`)
-      console.log(`  Type: ${chalk.cyan(options.type || 'public')}`)
-      console.log(`  Next steps:`)
-      console.log(`    1. Set environment variables: ${chalk.yellow('coolify-mcp env ' + result.value.uuid?.slice(0, 8))}`)
-      console.log(`    2. Deploy application: ${chalk.yellow('coolify-mcp deploy ' + result.value.uuid?.slice(0, 8))}`)
+        chalk.green(
+          `Application created! UUID: ${chalk.cyan(result.value.uuid)}`,
+        ),
+      );
+      console.log(`  Name: ${chalk.cyan(options.name)}`);
+      console.log(`  Type: ${chalk.cyan(options.type || "public")}`);
+      console.log(`  Next steps:`);
+      console.log(
+        `    1. Set environment variables: ${chalk.yellow("coolify-mcp env " + result.value.uuid)}`,
+      );
+      console.log(
+        `    2. Deploy application: ${chalk.yellow("coolify-mcp deploy " + result.value.uuid)}`,
+      );
     } else {
-      spinner.fail(chalk.red(`Creation failed: ${result.error.message}`))
+      spinner.fail(chalk.red(`Creation failed: ${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/databases.ts

@@ -0,0 +1,63 @@
+/**
+ * Databases command for CLI.
+ *
+ * Lists all databases in Coolify.
+ *
+ * @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";
+
+/**
+ * Databases command handler.
+ *
+ * @param options - Command options
+ */
+export async function databasesCommand(_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.listDatabases();
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
+  }
+
+  const databases = result.value;
+
+  if (databases.length === 0) {
+    console.log(chalk.yellow("No databases found"));
+    return;
+  }
+
+  const table = new Table({
+    head: [
+      chalk.cyan("UUID"),
+      chalk.cyan("Name"),
+      chalk.cyan("Type"),
+      chalk.cyan("Status"),
+    ],
+  });
+
+  for (const db of databases) {
+    table.push([
+      db.uuid,
+      db.name || "-",
+      db.type || "-",
+      formatStatus(db.status),
+    ]);
+  }
+
+  console.log(table.toString());
+  console.log(chalk.gray(`Total: ${databases.length} database(s)`));
+}

package/src/cli/commands/db.ts

@@ -0,0 +1,68 @@
+/**
+ * Database subcommands for CLI — all go through SDK.
+ *
+ * @module
+ */
+
+import { runAction, runList, runGet, chalk, formatStatus } from "../actions.js";
+import type { ICoolifyDatabase } from "../../coolify/types.js";
+
+/** List all databases. */
+export const dbListCommand = () =>
+  runList<ICoolifyDatabase>("database(s)", (s) => s.databases.list(), [
+    { header: "UUID", value: (d) => d.uuid },
+    { header: "Name", value: (d) => d.name || "-" },
+    { header: "Type", value: (d) => d.type || "-" },
+    { header: "Status", value: (d) => formatStatus(d.status) },
+  ]);
+
+/** Get database details. */
+export const dbGetCommand = (uuid: string) =>
+  runGet<ICoolifyDatabase>(
+    uuid,
+    "database",
+    (s, u) => s.databases.get(u),
+    (db) => {
+      console.log(chalk.cyan("Database Details:"));
+      console.log(chalk.gray("UUID:   ") + db.uuid);
+      console.log(chalk.gray("Name:   ") + db.name);
+      console.log(chalk.gray("Type:   ") + (db.type || "-"));
+      console.log(chalk.gray("Status: ") + formatStatus(db.status));
+    },
+  );
+
+/** Start a database. */
+export const dbStartCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Starting database",
+    (s, u) => s.databases.start(u),
+    (u) => `Database started: ${u}`,
+  );
+
+/** Stop a database. */
+export const dbStopCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Stopping database",
+    (s, u) => s.databases.stop(u),
+    (u) => `Database stopped: ${u}`,
+  );
+
+/** Restart a database. */
+export const dbRestartCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Restarting database",
+    (s, u) => s.databases.restart(u),
+    (u) => `Database restarted: ${u}`,
+  );
+
+/** Delete a database. */
+export const dbDeleteCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Deleting database",
+    (s, u) => s.databases.delete(u),
+    (u) => `Database deleted: ${u}`,
+  );

package/src/cli/commands/delete.ts

@@ -6,64 +6,76 @@
  * @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";
 
 /**
  * Executes the delete command.
+ * 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 deleteCommand(
-  uuid: string,
-  options: { force?: boolean; yes?: boolean } = {}
+  uuid: string | undefined,
+  options: { force?: boolean; yes?: boolean } = {},
 ): Promise<void> {
-  const service = getCoolifyService()
-  const initResult = await service.init()
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(
+      chalk.red("Error: No UUID provided and no .coolify.json found"),
+    );
+    return;
+  }
+  uuid = resolvedUuid;
+  const service = getCoolifyService();
+  const initResult = await service.init();
 
   if (isErr(initResult)) {
-    console.error(chalk.red('Failed to initialize Coolify service'))
-    console.error(chalk.gray(initResult.error.message))
-    process.exit(1)
+    console.error(chalk.red("Failed to initialize Coolify service"));
+    console.error(chalk.gray(initResult.error.message));
+    process.exit(1);
   }
 
   if (!options.force && !options.yes) {
-    const readline = await import('readline')
+    const readline = await import("readline");
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
-    })
+    });
 
     const answer = await new Promise<string>((resolve) => {
       rl.question(
-        chalk.yellow(`Are you sure you want to delete application ${chalk.bold(uuid)}? (yes/no): `),
+        chalk.yellow(
+          `Are you sure you want to delete application ${chalk.bold(uuid)}? (yes/no): `,
+        ),
         (ans) => {
-          rl.close()
-          resolve(ans.toLowerCase())
-        }
-      )
-    })
+          rl.close();
+          resolve(ans.toLowerCase());
+        },
+      );
+    });
 
-    if (answer !== 'yes' && answer !== 'y') {
-      console.log(chalk.gray('Operation cancelled'))
-      process.exit(0)
+    if (answer !== "yes" && answer !== "y") {
+      console.log(chalk.gray("Operation cancelled"));
+      process.exit(0);
     }
   }
 
-  console.log(chalk.cyan(`Deleting application ${chalk.bold(uuid)}...`))
+  console.log(chalk.cyan(`Deleting application ${chalk.bold(uuid)}...`));
 
-  const result = await service.deleteApplication(uuid)
+  const result = await service.deleteApplication(uuid);
 
   if (isErr(result)) {
-    console.error(chalk.red('Failed to delete application'))
-    console.error(chalk.gray(result.error.message))
-    process.exit(1)
+    console.error(chalk.red("Failed to delete application"));
+    console.error(chalk.gray(result.error.message));
+    process.exit(1);
   }
 
-  console.log(chalk.green('Application deleted successfully'))
+  console.log(chalk.green("Application deleted successfully"));
   if (result.value.message) {
-    console.log(chalk.gray(result.value.message))
+    console.log(chalk.gray(result.value.message));
   }
 }

package/src/cli/commands/deploy.ts

@@ -4,30 +4,47 @@
  * @module
  */
 
-import { isOk, isErr } from '@mks2508/no-throw'
-import ora from 'ora'
-import chalk from 'chalk'
-import { getCoolifyService } from '../../coolify/index.js'
+import { isOk, 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";
 
 /**
  * Deploy 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 - Deploy options
  */
-export async function deployCommand(uuid: string, options: { force?: boolean; tag?: string }) {
-  const spinner = ora('Initializing Coolify connection...').start()
+export async function deployCommand(
+  uuid: string | undefined,
+  options: { force?: boolean; tag?: string },
+) {
+  const resolvedUuid = resolveUuid(uuid);
+  if (!resolvedUuid) {
+    console.error(
+      chalk.red(
+        "Error: No UUID provided and no .coolify.json found in current directory",
+      ),
+    );
+    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 = 'Triggering deployment...'
+    spinner.text = "Triggering deployment...";
 
     const result = await coolify.deploy(
       {
@@ -36,21 +53,25 @@ export async function deployCommand(uuid: string, options: { force?: boolean; ta
         tag: options.tag,
       },
       (percent, message) => {
-        spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`
-      }
-    )
+        spinner.text = `${chalk.bold(`[${percent}%]`)} ${message}`;
+      },
+    );
 
     if (isOk(result)) {
       spinner.succeed(
-        chalk.green(`Deployment triggered! UUID: ${chalk.cyan(result.value.deploymentUuid?.slice(0, 8))}`)
-      )
-      console.log(`  Resource UUID: ${chalk.cyan(result.value.resourceUuid?.slice(0, 8))}`)
+        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}`))
+      spinner.fail(chalk.red(`Deployment failed: ${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/deployments.ts

@@ -6,72 +6,82 @@
  * @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";
+import { resolveUuid } from "../coolify-state.js";
 
 /**
  * Deployments 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 deploymentsCommand(
-  uuid: string,
-  options: { full?: boolean; limit?: number } = {}
+  uuid: string | undefined,
+  options: { full?: boolean; limit?: number } = {},
 ) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+  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.getApplicationDeploymentHistory(uuid)
+  const result = await coolify.getApplicationDeploymentHistory(uuid);
 
   if (isErr(result)) {
-    console.error(chalk.red(`Error: ${result.error.message}`))
-    return
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
   }
 
-  let deployments = result.value
+  let deployments = result.value;
 
   // Show most recent first
-  deployments = deployments.reverse()
+  deployments = deployments.reverse();
 
   if (options.limit) {
-    deployments = deployments.slice(0, options.limit)
+    deployments = deployments.slice(0, options.limit);
   }
 
   if (deployments.length === 0) {
-    console.log(chalk.yellow('No deployments found'))
-    return
+    console.log(chalk.yellow("No deployments found"));
+    return;
   }
 
   const table = new Table({
     head: [
-      chalk.cyan('ID'),
-      chalk.cyan('UUID'),
-      chalk.cyan('Status'),
-      chalk.cyan('Commit'),
-      chalk.cyan('Created'),
+      chalk.cyan("ID"),
+      chalk.cyan("UUID"),
+      chalk.cyan("Status"),
+      chalk.cyan("Commit"),
+      chalk.cyan("Created"),
     ],
     ...(options.full ? { colWidths: [8, 36, 20, 10, 20] } : {}),
-  })
+  });
 
   for (const dep of deployments) {
     table.push([
       String(dep.id),
-      options.full ? dep.uuid : dep.uuid.slice(0, 8),
+      dep.uuid || "-",
       formatStatus(dep.status),
-      dep.commit?.slice(0, 7) || '-',
+      dep.commit?.slice(0, 7) || "-",
       new Date(dep.created_at).toLocaleString(),
-    ])
+    ]);
   }
 
-  console.log(table.toString())
-  console.log(chalk.gray(`Total: ${deployments.length} deployment(s)`))
+  console.log(table.toString());
+  console.log(chalk.gray(`Total: ${deployments.length} deployment(s)`));
 }