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

package/src/cli/commands/show.ts

@@ -6,69 +6,100 @@
  * @module
  */
 
-import { isErr } from '@mks2508/no-throw'
-import chalk from 'chalk'
-import { getCoolifyService } from '../../coolify/index.js'
-import type { ICoolifyApplication } from '../../coolify/types.js'
+import { isErr } from "@mks2508/no-throw";
+import chalk from "chalk";
+import { getCoolifyService } from "../../coolify/index.js";
+import { resolveUuid } from "../coolify-state.js";
 
 /**
  * Show 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 showCommand(uuid: string) {
-  const coolify = getCoolifyService()
-  const initResult = await coolify.init()
+export async function showCommand(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 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;
   }
 
   // We need to add getApplication method to CoolifyService
   // For now, use listApplications and filter
-  const result = await coolify.listApplications()
+  const result = await coolify.listApplications();
 
   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 app = apps.find(a => a.uuid === uuid || a.uuid.startsWith(uuid))
+  const apps = result.value;
+  const app = apps.find((a) => a.uuid === uuid || a.uuid.startsWith(uuid));
 
   if (!app) {
-    console.error(chalk.red(`Application not found: ${uuid}`))
-    return
+    console.error(chalk.red(`Application not found: ${uuid}`));
+    return;
   }
 
-  console.log(chalk.cyan('Application Details:'))
-  console.log('')
-  console.log(chalk.gray('UUID:       ') + chalk.white(app.uuid))
-  console.log(chalk.gray('Name:       ') + chalk.white(app.name))
-  console.log(chalk.gray('Status:     ') + chalk.white(app.status))
-  console.log(chalk.gray('Description:') + chalk.white(app.description || 'N/A'))
-  console.log(chalk.gray('Repository: ') + chalk.white(app.git_repository || 'N/A'))
-  console.log(chalk.gray('Branch:     ') + chalk.white(app.git_branch || 'N/A'))
-  console.log(chalk.gray('Build Pack: ') + chalk.white(app.build_pack || 'N/A'))
-  console.log(chalk.gray('Ports:      ') + chalk.white(app.ports_exposes || 'N/A'))
-  console.log(chalk.gray('FQDN:       ') + chalk.white(app.fqdn || 'N/A'))
-  console.log(chalk.gray('Dockerfile: ') + chalk.white(app.dockerfile_location || 'N/A'))
-  console.log(chalk.gray('Base Dir:   ') + chalk.white(app.base_directory || 'N/A'))
-  console.log('')
-  console.log(chalk.cyan('Destination:'))
+  console.log(chalk.cyan("Application Details:"));
+  console.log("");
+  console.log(chalk.gray("UUID:       ") + chalk.white(app.uuid));
+  console.log(chalk.gray("Name:       ") + chalk.white(app.name));
+  console.log(chalk.gray("Status:     ") + chalk.white(app.status));
+  console.log(
+    chalk.gray("Description:") + chalk.white(app.description || "N/A"),
+  );
+  console.log(
+    chalk.gray("Repository: ") + chalk.white(app.git_repository || "N/A"),
+  );
+  console.log(
+    chalk.gray("Branch:     ") + chalk.white(app.git_branch || "N/A"),
+  );
+  console.log(
+    chalk.gray("Build Pack: ") + chalk.white(app.build_pack || "N/A"),
+  );
+  console.log(
+    chalk.gray("Ports:      ") + chalk.white(app.ports_exposes || "N/A"),
+  );
+  console.log(chalk.gray("FQDN:       ") + chalk.white(app.fqdn || "N/A"));
+  console.log(
+    chalk.gray("Dockerfile: ") + chalk.white(app.dockerfile_location || "N/A"),
+  );
+  console.log(
+    chalk.gray("Base Dir:   ") + chalk.white(app.base_directory || "N/A"),
+  );
+  console.log("");
+  console.log(chalk.cyan("Destination:"));
   if (app.destination) {
-    console.log(chalk.gray('  UUID:  ') + chalk.white(app.destination.uuid))
-    console.log(chalk.gray('  Name:  ') + chalk.white(app.destination.name))
+    console.log(chalk.gray("  UUID:  ") + chalk.white(app.destination.uuid));
+    console.log(chalk.gray("  Name:  ") + chalk.white(app.destination.name));
     if (app.destination.server) {
-      console.log(chalk.gray('  Server:') + chalk.white(` ${app.destination.server.name} (${app.destination.server.ip})`))
+      console.log(
+        chalk.gray("  Server:") +
+          chalk.white(
+            ` ${app.destination.server.name} (${app.destination.server.ip})`,
+          ),
+      );
     }
   } else {
-    console.log(chalk.yellow('  No destination configured'))
+    console.log(chalk.yellow("  No destination configured"));
   }
-  console.log('')
-  console.log(chalk.cyan('Commands:'))
-  if (app.install_command) console.log(chalk.gray('  Install: ') + chalk.white(app.install_command))
-  if (app.build_command) console.log(chalk.gray('  Build:   ') + chalk.white(app.build_command))
-  if (app.start_command) console.log(chalk.gray('  Start:   ') + chalk.white(app.start_command))
+  console.log("");
+  console.log(chalk.cyan("Commands:"));
+  if (app.install_command)
+    console.log(chalk.gray("  Install: ") + chalk.white(app.install_command));
+  if (app.build_command)
+    console.log(chalk.gray("  Build:   ") + chalk.white(app.build_command));
+  if (app.start_command)
+    console.log(chalk.gray("  Start:   ") + chalk.white(app.start_command));
 }

package/src/cli/commands/start.ts

@@ -0,0 +1,60 @@
+/**
+ * Start command for CLI.
+ *
+ * @module
+ */
+
+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";
+
+/**
+ * Start command handler.
+ * If no UUID is provided, reads from .coolify.json in the current directory.
+ *
+ * @param uuid - Application UUID (optional if .coolify.json exists)
+ */
+export async function startCommand(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();
+
+    if (isErr(initResult)) {
+      spinner.fail(
+        chalk.red(`Failed to initialize: ${initResult.error.message}`),
+      );
+      return;
+    }
+
+    spinner.text = "Starting application...";
+
+    const result = await coolify.startApplication(uuid);
+
+    if (isErr(result)) {
+      spinner.fail(
+        chalk.red(`Failed to start application: ${result.error.message}`),
+      );
+      return;
+    }
+
+    spinner.succeed(chalk.green(`Application started: ${chalk.cyan(uuid)}`));
+  } catch (error) {
+    spinner.fail(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}

package/src/cli/commands/stop.ts

@@ -0,0 +1,60 @@
+/**
+ * Stop command for CLI.
+ *
+ * @module
+ */
+
+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";
+
+/**
+ * Stop command handler.
+ * If no UUID is provided, reads from .coolify.json in the current directory.
+ *
+ * @param uuid - Application UUID (optional if .coolify.json exists)
+ */
+export async function stopCommand(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();
+
+    if (isErr(initResult)) {
+      spinner.fail(
+        chalk.red(`Failed to initialize: ${initResult.error.message}`),
+      );
+      return;
+    }
+
+    spinner.text = "Stopping application...";
+
+    const result = await coolify.stopApplication(uuid);
+
+    if (isErr(result)) {
+      spinner.fail(
+        chalk.red(`Failed to stop application: ${result.error.message}`),
+      );
+      return;
+    }
+
+    spinner.succeed(chalk.green(`Application stopped: ${chalk.cyan(uuid)}`));
+  } catch (error) {
+    spinner.fail(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}

package/src/cli/commands/svc.ts

@@ -0,0 +1,68 @@
+/**
+ * Service subcommands for CLI — all go through SDK.
+ *
+ * @module
+ */
+
+import { runAction, runList, runGet, chalk, formatStatus } from "../actions.js";
+import type { ICoolifyService } from "../../coolify/types.js";
+
+/** List all services. */
+export const svcListCommand = () =>
+  runList<ICoolifyService>("service(s)", (s) => s.services.list(), [
+    { header: "UUID", value: (s) => s.uuid },
+    { header: "Name", value: (s) => s.name || "-" },
+    { header: "Type", value: (s) => s.type || "-" },
+    { header: "Status", value: (s) => formatStatus(s.status) },
+  ]);
+
+/** Get service details. */
+export const svcGetCommand = (uuid: string) =>
+  runGet<ICoolifyService>(
+    uuid,
+    "service",
+    (s, u) => s.services.get(u),
+    (svc) => {
+      console.log(chalk.cyan("Service Details:"));
+      console.log(chalk.gray("UUID:   ") + svc.uuid);
+      console.log(chalk.gray("Name:   ") + svc.name);
+      console.log(chalk.gray("Type:   ") + (svc.type || "-"));
+      console.log(chalk.gray("Status: ") + formatStatus(svc.status));
+    },
+  );
+
+/** Start a service. */
+export const svcStartCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Starting service",
+    (s, u) => s.services.start(u),
+    (u) => `Service started: ${u}`,
+  );
+
+/** Stop a service. */
+export const svcStopCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Stopping service",
+    (s, u) => s.services.stop(u),
+    (u) => `Service stopped: ${u}`,
+  );
+
+/** Restart a service. */
+export const svcRestartCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Restarting service",
+    (s, u) => s.services.restart(u),
+    (u) => `Service restarted: ${u}`,
+  );
+
+/** Delete a service. */
+export const svcDeleteCommand = (uuid: string) =>
+  runAction(
+    uuid,
+    "Deleting service",
+    (s, u) => s.services.delete(u),
+    (u) => `Service deleted: ${u}`,
+  );

package/src/cli/commands/teams.ts

@@ -0,0 +1,60 @@
+/**
+ * Teams subcommands for CLI — all go through SDK.
+ *
+ * @module
+ */
+
+import { runList, chalk, getCliSdk } from "../actions.js";
+import type { ICoolifyTeam } from "../../coolify/types.js";
+
+/** List all teams. */
+export const teamsListCommand = () =>
+  runList<ICoolifyTeam>("team(s)", (s) => s.teams.list(), [
+    { header: "ID", value: (t) => String(t.id) },
+    { header: "Name", value: (t) => t.name },
+    { header: "Personal", value: (t) => (t.personal_team ? "Yes" : "No") },
+  ]);
+
+/** Get current team. */
+export async function teamsCurrentCommand(): Promise<void> {
+  try {
+    const team = await getCliSdk().teams.current();
+    console.log(chalk.cyan("Current Team:"));
+    console.log(chalk.gray("ID:       ") + team.id);
+    console.log(chalk.gray("Name:     ") + team.name);
+    console.log(chalk.gray("Personal: ") + (team.personal_team ? "Yes" : "No"));
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}
+
+/** Get team members. */
+export async function teamsMembersCommand(teamId: string): Promise<void> {
+  const id = parseInt(teamId, 10);
+  if (isNaN(id)) {
+    console.error(chalk.red("Error: Team ID must be a number"));
+    return;
+  }
+
+  try {
+    const members = await getCliSdk().teams.members(id);
+    if (members.length === 0) {
+      console.log(chalk.yellow("No members found"));
+      return;
+    }
+    console.log(chalk.cyan(`Team ${teamId} Members:`));
+    for (const m of members) {
+      console.log(`  ${chalk.bold(m.name)} (${chalk.gray(m.email)})`);
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}

package/src/cli/commands/update.ts

@@ -6,29 +6,30 @@
  * @module
  */
 
-import { isErr } from '@mks2508/no-throw'
-import chalk from 'chalk'
-import { getCoolifyService } from '../../coolify/index.js'
-import type { ICoolifyUpdateOptions } from '../../coolify/types.js'
+import { isErr } from "@mks2508/no-throw";
+import chalk from "chalk";
+import { getCoolifyService } from "../../coolify/index.js";
+import type { ICoolifyUpdateOptions } from "../../coolify/types.js";
+import { resolveUuid } from "../coolify-state.js";
 
 /**
  * Options for the update command.
  */
 interface IUpdateCommandOptions {
-  uuid: string
-  name?: string
-  description?: string
-  buildPack?: string
-  gitBranch?: string
-  ports?: string
-  installCommand?: string
-  buildCommand?: string
-  startCommand?: string
-  dockerfileLocation?: string
-  baseDirectory?: string
-  domains?: string
-  autoDeploy?: boolean
-  forceHttps?: boolean
+  uuid?: string;
+  name?: string;
+  description?: string;
+  buildPack?: string;
+  gitBranch?: string;
+  ports?: string;
+  installCommand?: string;
+  buildCommand?: string;
+  startCommand?: string;
+  dockerfileLocation?: string;
+  baseDirectory?: string;
+  domains?: string;
+  autoDeploy?: boolean;
+  forceHttps?: boolean;
 }
 
 /**
@@ -36,52 +37,75 @@ interface IUpdateCommandOptions {
  *
  * @param options - Command options
  */
-export async function updateCommand(options: IUpdateCommandOptions): Promise<void> {
-  console.log(chalk.cyan(`Updating application ${chalk.bold(options.uuid)}...`))
+export async function updateCommand(
+  options: IUpdateCommandOptions,
+): Promise<void> {
+  const uuid = resolveUuid(options.uuid);
+  if (!uuid) {
+    console.error(
+      chalk.red("Error: No UUID provided and no .coolify.json found"),
+    );
+    return;
+  }
+  options.uuid = uuid;
+  console.log(chalk.cyan(`Updating application ${chalk.bold(uuid)}...`));
 
-  const service = getCoolifyService()
-  const initResult = await service.init()
+  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);
   }
 
-  const updateOptions: ICoolifyUpdateOptions = {}
+  const updateOptions: ICoolifyUpdateOptions = {};
 
-  if (options.name) updateOptions.name = options.name
-  if (options.description) updateOptions.description = options.description
-  if (options.buildPack) updateOptions.buildPack = options.buildPack as 'dockerfile' | 'nixpacks' | 'static' | 'dockercompose'
-  if (options.gitBranch) updateOptions.gitBranch = options.gitBranch
-  if (options.ports) updateOptions.portsExposes = options.ports
-  if (options.installCommand) updateOptions.installCommand = options.installCommand
-  if (options.buildCommand) updateOptions.buildCommand = options.buildCommand
-  if (options.startCommand) updateOptions.startCommand = options.startCommand
-  if (options.dockerfileLocation) updateOptions.dockerfileLocation = options.dockerfileLocation
-  if (options.baseDirectory) updateOptions.baseDirectory = options.baseDirectory
-  if (options.domains) updateOptions.domains = options.domains
-  if (options.autoDeploy !== undefined) updateOptions.isAutoDeployEnabled = options.autoDeploy
-  if (options.forceHttps) updateOptions.isForceHttpsEnabled = true
+  if (options.name) updateOptions.name = options.name;
+  if (options.description) updateOptions.description = options.description;
+  if (options.buildPack)
+    updateOptions.buildPack = options.buildPack as
+      | "dockerfile"
+      | "nixpacks"
+      | "static"
+      | "dockercompose";
+  if (options.gitBranch) updateOptions.gitBranch = options.gitBranch;
+  if (options.ports) updateOptions.portsExposes = options.ports;
+  if (options.installCommand)
+    updateOptions.installCommand = options.installCommand;
+  if (options.buildCommand) updateOptions.buildCommand = options.buildCommand;
+  if (options.startCommand) updateOptions.startCommand = options.startCommand;
+  if (options.dockerfileLocation)
+    updateOptions.dockerfileLocation = options.dockerfileLocation;
+  if (options.baseDirectory)
+    updateOptions.baseDirectory = options.baseDirectory;
+  if (options.domains) updateOptions.domains = options.domains;
+  if (options.autoDeploy !== undefined)
+    updateOptions.isAutoDeployEnabled = options.autoDeploy;
+  if (options.forceHttps) updateOptions.isForceHttpsEnabled = true;
 
   if (Object.keys(updateOptions).length === 0) {
-    console.warn(chalk.yellow('No update options provided. Use --help to see available options.'))
-    process.exit(0)
+    console.warn(
+      chalk.yellow(
+        "No update options provided. Use --help to see available options.",
+      ),
+    );
+    process.exit(0);
   }
 
-  const result = await service.updateApplication(options.uuid, updateOptions)
+  const result = await service.updateApplication(options.uuid, updateOptions);
 
   if (isErr(result)) {
-    console.error(chalk.red('Failed to update application'))
-    console.error(chalk.gray(result.error.message))
-    process.exit(1)
+    console.error(chalk.red("Failed to update application"));
+    console.error(chalk.gray(result.error.message));
+    process.exit(1);
   }
 
-  console.log(chalk.green('Application updated successfully'))
-  console.log(chalk.gray(`UUID: ${result.value.uuid}`))
-  console.log(chalk.gray(`Name: ${result.value.name}`))
+  console.log(chalk.green("Application updated successfully"));
+  console.log(chalk.gray(`UUID: ${result.value.uuid}`));
+  console.log(chalk.gray(`Name: ${result.value.name}`));
 
   if (result.value.description) {
-    console.log(chalk.gray(`Description: ${result.value.description}`))
+    console.log(chalk.gray(`Description: ${result.value.description}`));
   }
 }

package/src/cli/commands/version.ts

@@ -0,0 +1,37 @@
+/**
+ * Version command for CLI.
+ *
+ * Shows the Coolify server version.
+ *
+ * @module
+ */
+
+import { isErr } from "@mks2508/no-throw";
+import chalk from "chalk";
+import { getCoolifyService } from "../../coolify/index.js";
+
+/**
+ * Version command handler.
+ * Displays the Coolify server version.
+ */
+export async function versionCommand() {
+  const coolify = getCoolifyService();
+  const initResult = await coolify.init();
+
+  if (isErr(initResult)) {
+    console.error(chalk.red(`Error: ${initResult.error.message}`));
+    return;
+  }
+
+  const result = await coolify.getVersion();
+
+  if (isErr(result)) {
+    console.error(chalk.red(`Error: ${result.error.message}`));
+    return;
+  }
+
+  console.log(
+    chalk.cyan("Coolify Server Version:"),
+    chalk.bold(result.value.version),
+  );
+}

package/src/cli/coolify-state.ts

@@ -0,0 +1,88 @@
+/**
+ * .coolify.json state loader for CLI.
+ *
+ * When running CLI commands from a project directory that has a .coolify.json
+ * (generated by create-bunspace or first deploy), reads the state to auto-fill
+ * UUIDs so users don't need to copy-paste them.
+ *
+ * @module
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * State stored in .coolify.json (generated by create-bunspace deployer).
+ */
+export interface ICoolifyDeployState {
+  /** Application UUID in Coolify */
+  appUuid: string;
+  /** Server UUID */
+  serverUuid: string;
+  /** Project UUID */
+  projectUuid: string;
+  /** Environment UUID */
+  environmentUuid: string;
+  /** Domain if configured */
+  domain?: string;
+  /** Docker compose or Dockerfile path */
+  dockerComposePath?: string;
+  /** Base directory for build context */
+  baseDirectory?: string;
+  /** Git branch */
+  branch?: string;
+  /** Application type */
+  type?: string;
+  /** Build pack */
+  buildPack?: string;
+  /** Auto-deploy enabled */
+  autoDeployEnabled?: boolean;
+}
+
+const STATE_FILE = ".coolify.json";
+
+/**
+ * Loads .coolify.json from the current working directory.
+ *
+ * @returns The deploy state if found, null otherwise
+ */
+export function loadCoolifyState(): ICoolifyDeployState | null {
+  const statePath = join(process.cwd(), STATE_FILE);
+
+  if (!existsSync(statePath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(statePath, "utf-8");
+    const state = JSON.parse(content) as ICoolifyDeployState;
+
+    if (!state.appUuid) {
+      return null;
+    }
+
+    return state;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolves a UUID argument — if not provided, tries to read from .coolify.json.
+ *
+ * @param uuid - UUID from CLI argument (may be undefined)
+ * @param field - Which field to read from .coolify.json (default: appUuid)
+ * @returns The resolved UUID or null if not found
+ */
+export function resolveUuid(
+  uuid: string | undefined,
+  field: keyof ICoolifyDeployState = "appUuid",
+): string | null {
+  if (uuid) return uuid;
+
+  const state = loadCoolifyState();
+  if (!state) return null;
+
+  const value = state[field];
+  return typeof value === "string" ? value : null;
+}