@mks2508/coolify-mks-cli-mcp 0.6.3 → 0.9.0

package/src/cli/commands/update.ts

@@ -9,8 +9,10 @@
 import { isErr } from "@mks2508/no-throw";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
+import { cacheAppSettings } from "../../coolify/config.js";
 import type { ICoolifyUpdateOptions } from "../../coolify/types.js";
 import { resolveUuid } from "../coolify-state.js";
+import { resolveAppNameOrUuid } from "../name-resolver.js";
 
 /**
  * Options for the update command.
@@ -29,7 +31,16 @@ interface IUpdateCommandOptions {
   baseDirectory?: string;
   domains?: string;
   autoDeploy?: boolean;
+  watchPaths?: string;
+  clearWatchPaths?: boolean;
   forceHttps?: boolean;
+  healthCheckEnabled?: boolean;
+  healthCheckPath?: string;
+  healthCheckPort?: string;
+  healthCheckInterval?: string;
+  healthCheckTimeout?: string;
+  healthCheckRetries?: string;
+  healthCheckStartPeriod?: string;
 }
 
 /**
@@ -40,10 +51,13 @@ interface IUpdateCommandOptions {
 export async function updateCommand(
   options: IUpdateCommandOptions,
 ): Promise<void> {
-  const uuid = resolveUuid(options.uuid);
+  let uuid = resolveUuid(options.uuid);
+  if (!uuid && options.uuid) {
+    uuid = await resolveAppNameOrUuid(options.uuid);
+  }
   if (!uuid) {
     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;
   }
@@ -82,7 +96,26 @@ export async function updateCommand(
   if (options.domains) updateOptions.domains = options.domains;
   if (options.autoDeploy !== undefined)
     updateOptions.isAutoDeployEnabled = options.autoDeploy;
+  if (options.clearWatchPaths) {
+    updateOptions.watchPaths = null;
+  } else if (options.watchPaths) {
+    updateOptions.watchPaths = options.watchPaths.replace(/\\n/g, "\n");
+  }
   if (options.forceHttps) updateOptions.isForceHttpsEnabled = true;
+  if (options.healthCheckEnabled !== undefined)
+    updateOptions.healthCheckEnabled = options.healthCheckEnabled;
+  if (options.healthCheckPath)
+    updateOptions.healthCheckPath = options.healthCheckPath;
+  if (options.healthCheckPort)
+    updateOptions.healthCheckPort = options.healthCheckPort;
+  if (options.healthCheckInterval)
+    updateOptions.healthCheckInterval = parseInt(options.healthCheckInterval, 10);
+  if (options.healthCheckTimeout)
+    updateOptions.healthCheckTimeout = parseInt(options.healthCheckTimeout, 10);
+  if (options.healthCheckRetries)
+    updateOptions.healthCheckRetries = parseInt(options.healthCheckRetries, 10);
+  if (options.healthCheckStartPeriod)
+    updateOptions.healthCheckStartPeriod = parseInt(options.healthCheckStartPeriod, 10);
 
   if (Object.keys(updateOptions).length === 0) {
     console.warn(
@@ -108,4 +141,48 @@ export async function updateCommand(
   if (result.value.description) {
     console.log(chalk.gray(`Description: ${result.value.description}`));
   }
+
+  // Cache and display auto-deploy and watch_paths settings
+  if (
+    options.autoDeploy !== undefined ||
+    options.watchPaths ||
+    options.clearWatchPaths
+  ) {
+    // Cache settings locally (API GET doesn't return is_auto_deploy_enabled)
+    const settingsToCache: Record<string, unknown> = {};
+    if (options.autoDeploy !== undefined) {
+      settingsToCache.isAutoDeployEnabled = options.autoDeploy;
+    }
+    if (options.clearWatchPaths) {
+      settingsToCache.watchPaths = null;
+    } else if (options.watchPaths) {
+      settingsToCache.watchPaths = updateOptions.watchPaths;
+    }
+    await cacheAppSettings(options.uuid, settingsToCache);
+
+    // Display what was set
+    if (options.autoDeploy !== undefined) {
+      console.log(
+        chalk.gray(`Auto-deploy: `) +
+          (options.autoDeploy ? chalk.green("ON") : chalk.red("OFF")),
+      );
+    }
+
+    // Verify watch_paths from API (this field IS returned by GET)
+    const verifyResult = await service.getApplication(options.uuid);
+    if (!isErr(verifyResult)) {
+      const app = verifyResult.value;
+      if (app.watch_paths) {
+        console.log(chalk.gray(`Watch paths:`));
+        for (const p of app.watch_paths.split("\n").filter(Boolean)) {
+          console.log(chalk.gray(`  ${p}`));
+        }
+      } else {
+        console.log(
+          chalk.gray(`Watch paths: `) +
+            chalk.yellow("none (deploys on all changes)"),
+        );
+      }
+    }
+  }
 }

package/src/cli/commands/volumes.ts

@@ -0,0 +1,293 @@
+/**
+ * Volumes subcommands for CLI — add/list/remove bind mounts on docker-compose apps.
+ *
+ * @module
+ */
+
+import { getCliSdk, chalk, Table } from "../actions.js";
+
+interface IComposeService {
+  image?: string;
+  volumes?: string[];
+  [key: string]: unknown;
+}
+
+interface IComposeFile {
+  services?: Record<string, IComposeService>;
+  [key: string]: unknown;
+}
+
+/**
+ * Parse a volume string like "/host/path:/container/path" or "named_vol:/container/path".
+ */
+function parseVolumeEntry(v: string): { source: string; target: string } {
+  const colonIdx = v.indexOf(":");
+  if (colonIdx === -1) return { source: "", target: v };
+  return { source: v.slice(0, colonIdx), target: v.slice(colonIdx + 1) };
+}
+
+/**
+ * List volumes for an application.
+ */
+export async function volumesListCommand(
+  uuid: string,
+  options: { service?: string },
+): Promise<void> {
+  try {
+    const sdk = getCliSdk();
+    const app = await sdk.applications.get(uuid);
+
+    if (!app.docker_compose_raw) {
+      console.log(chalk.yellow("Application has no docker_compose_raw (not a docker-compose app)."));
+      return;
+    }
+
+    let compose: IComposeFile;
+    try {
+      compose = Bun.YAML.parse(app.docker_compose_raw) as IComposeFile;
+    } catch {
+      console.error(chalk.red("Failed to parse docker_compose_raw YAML."));
+      return;
+    }
+
+    const services = compose.services ?? {};
+    const serviceNames = Object.keys(services);
+
+    if (serviceNames.length === 0) {
+      console.log(chalk.yellow("No services found in docker-compose."));
+      return;
+    }
+
+    // Filter by service if specified
+    const displayServices = options.service
+      ? serviceNames.filter((s) => s === options.service)
+      : serviceNames;
+
+    if (options.service && displayServices.length === 0) {
+      console.error(
+        chalk.red(`Service "${options.service}" not found. Available: ${serviceNames.join(", ")}`),
+      );
+      return;
+    }
+
+    for (const svcName of displayServices) {
+      const svc = services[svcName];
+      const volumes = svc?.volumes ?? [];
+
+      console.log(chalk.cyan(`\nService: ${chalk.bold(svcName)}`));
+
+      if (volumes.length === 0) {
+        console.log(chalk.gray("  No volumes configured."));
+        continue;
+      }
+
+      const table = new Table({
+        head: [chalk.cyan("Source"), chalk.cyan("Target"), chalk.cyan("Type")],
+      });
+
+      for (const vol of volumes) {
+        const { source, target } = parseVolumeEntry(vol);
+        const volType = source.startsWith("/") ? "bind" : "named";
+        table.push([source || "(no source)", target, volType]);
+      }
+
+      console.log(table.toString());
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`),
+    );
+  }
+}
+
+/**
+ * Add a volume (bind mount) to an application.
+ */
+export async function volumesAddCommand(
+  uuid: string,
+  options: {
+    source: string;
+    target: string;
+    service?: string;
+    noRestart?: boolean;
+  },
+): Promise<void> {
+  try {
+    const sdk = getCliSdk();
+    const app = await sdk.applications.get(uuid);
+
+    if (!app.docker_compose_raw) {
+      console.log(
+        chalk.yellow("Application has no docker_compose_raw. Only docker-compose buildPack apps support volume management via CLI."),
+      );
+      return;
+    }
+
+    let compose: IComposeFile;
+    try {
+      compose = Bun.YAML.parse(app.docker_compose_raw) as IComposeFile;
+    } catch {
+      console.error(chalk.red("Failed to parse docker_compose_raw YAML."));
+      return;
+    }
+
+    const services = compose.services ?? {};
+    const serviceNames = Object.keys(services);
+
+    // Determine target service
+    let targetService = options.service;
+    if (!targetService) {
+      if (serviceNames.length === 1) {
+        targetService = serviceNames[0];
+      } else {
+        console.error(
+          chalk.red(
+            `Multiple services found (${serviceNames.join(", ")}). Use --service to specify which one.`,
+          ),
+        );
+        return;
+      }
+    }
+
+    if (!services[targetService]) {
+      console.error(
+        chalk.red(`Service "${targetService}" not found. Available: ${serviceNames.join(", ")}`),
+      );
+      return;
+    }
+
+    const svc = services[targetService];
+    const volumes = svc.volumes ?? [];
+
+    // Check if volume already exists
+    const existing = volumes.find((v) => {
+      const { target: t } = parseVolumeEntry(v);
+      return t === options.target;
+    });
+
+    if (existing) {
+      console.log(chalk.yellow(`Volume with target "${options.target}" already exists — skipping.`));
+      return;
+    }
+
+    // Add the volume
+    const volStr = `${options.source}:${options.target}`;
+    svc.volumes = [...volumes, volStr];
+
+    // Serialize back to YAML
+    const updatedYaml = Bun.YAML.stringify(compose);
+
+    // PATCH the application
+    console.log(chalk.cyan(`Adding volume: ${chalk.bold(volStr)} to service "${targetService}"...`));
+    await sdk.applications.update(uuid, { dockerComposeRaw: updatedYaml });
+    console.log(chalk.green("Volume added successfully."));
+
+    // Deploy if not --no-restart
+    if (!options.noRestart) {
+      console.log(chalk.cyan("Redeploying to apply changes..."));
+      await sdk.applications.deploy(uuid);
+      console.log(chalk.green("Redeploy triggered."));
+    } else {
+      console.log(chalk.gray("Skipped redeploy (--no-restart). Changes apply on next deploy."));
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`),
+    );
+  }
+}
+
+/**
+ * Remove a volume from an application.
+ */
+export async function volumesRemoveCommand(
+  uuid: string,
+  options: {
+    target: string;
+    service?: string;
+    noRestart?: boolean;
+  },
+): Promise<void> {
+  try {
+    const sdk = getCliSdk();
+    const app = await sdk.applications.get(uuid);
+
+    if (!app.docker_compose_raw) {
+      console.log(
+        chalk.yellow("Application has no docker_compose_raw. Only docker-compose buildPack apps support volume management via CLI."),
+      );
+      return;
+    }
+
+    let compose: IComposeFile;
+    try {
+      compose = Bun.YAML.parse(app.docker_compose_raw) as IComposeFile;
+    } catch {
+      console.error(chalk.red("Failed to parse docker_compose_raw YAML."));
+      return;
+    }
+
+    const services = compose.services ?? {};
+    const serviceNames = Object.keys(services);
+
+    // Determine target service
+    let targetService = options.service;
+    if (!targetService) {
+      if (serviceNames.length === 1) {
+        targetService = serviceNames[0];
+      } else {
+        console.error(
+          chalk.red(
+            `Multiple services found (${serviceNames.join(", ")}). Use --service to specify which one.`,
+          ),
+        );
+        return;
+      }
+    }
+
+    if (!services[targetService]) {
+      console.error(
+        chalk.red(`Service "${targetService}" not found. Available: ${serviceNames.join(", ")}`),
+      );
+      return;
+    }
+
+    const svc = services[targetService];
+    const volumes = svc.volumes ?? [];
+
+    // Find volume by target path
+    const idx = volumes.findIndex((v) => {
+      const { target: t } = parseVolumeEntry(v);
+      return t === options.target;
+    });
+
+    if (idx === -1) {
+      console.error(chalk.red(`No volume found with target "${options.target}".`));
+      return;
+    }
+
+    const removed = volumes[idx];
+    svc.volumes = volumes.filter((_, i) => i !== idx);
+
+    // Serialize back to YAML
+    const updatedYaml = Bun.YAML.stringify(compose);
+
+    // PATCH the application
+    console.log(chalk.cyan(`Removing volume: ${chalk.bold(removed)} from service "${targetService}"...`));
+    await sdk.applications.update(uuid, { dockerComposeRaw: updatedYaml });
+    console.log(chalk.green("Volume removed successfully."));
+
+    // Deploy if not --no-restart
+    if (!options.noRestart) {
+      console.log(chalk.cyan("Redeploying to apply changes..."));
+      await sdk.applications.deploy(uuid);
+      console.log(chalk.green("Redeploy triggered."));
+    } else {
+      console.log(chalk.gray("Skipped redeploy (--no-restart). Changes apply on next deploy."));
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`),
+    );
+  }
+}

package/src/cli/coolify-state.ts

@@ -8,21 +8,33 @@
  * @module
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { validateCoolifyState } from "../utils/format.js";
 
 /**
- * State stored in .coolify.json (generated by create-bunspace deployer).
+ * State stored in .coolify.json (generated by create-bunspace deployer or init command).
+ *
+ * This file links a local directory to a Coolify deployment, storing all necessary
+ * UUIDs and metadata for CLI commands to work without manual UUID entry.
  */
 export interface ICoolifyDeployState {
   /** Application UUID in Coolify */
   appUuid: string;
+  /** Application name (for display purposes) */
+  appName?: string;
   /** Server UUID */
   serverUuid: string;
+  /** Server name (for display purposes) */
+  serverName?: string;
   /** Project UUID */
   projectUuid: string;
+  /** Project name (for display purposes) */
+  projectName?: string;
   /** Environment UUID */
   environmentUuid: string;
+  /** Environment name (for display purposes) */
+  environmentName?: string;
   /** Domain if configured */
   domain?: string;
   /** Docker compose or Dockerfile path */
@@ -31,18 +43,80 @@ export interface ICoolifyDeployState {
   baseDirectory?: string;
   /** Git branch */
   branch?: string;
-  /** Application type */
+  /** Git repository URL */
+  gitRepository?: string;
+  /** Application source type (github-app, deploy-key, docker-image, etc.) */
+  sourceType?: string;
+  /** Application type (legacy, may be undefined) */
   type?: string;
-  /** Build pack */
+  /** Build pack (dockerfile, nixpacks, static, dockercompose) */
   buildPack?: string;
-  /** Auto-deploy enabled */
+  /** Ports exposed (comma-separated) */
+  portsExposes?: string;
+  /** Auto-deploy enabled (Coolify default: true) */
   autoDeployEnabled?: boolean;
+  /** Watch paths for selective auto-deploy (newline-separated globs, null = all changes) */
+  watchPaths?: string | null;
+  /** When this state was last updated */
+  updatedAt?: string;
+  /** Coolify instance URL */
+  coolifyUrl?: string;
+}
+
+/**
+ * Multi-app state for monorepos deploying multiple services from one repo.
+ *
+ * Stored alongside or instead of the single-app state in .coolify.json.
+ */
+export interface ICoolifyMultiAppState {
+  /** All apps deployed from this repo */
+  apps: Array<{
+    /** Application UUID in Coolify */
+    uuid: string;
+    /** Application name */
+    name: string;
+    /** Service role (e.g. "backend", "admin", "docs", "proxy") */
+    service: string;
+    /** Domain if configured (with protocol). Null for internal services. */
+    domain?: string | null;
+    /** Dockerfile path relative to repo root */
+    dockerfile?: string | null;
+    /** Exposed port */
+    port?: number;
+    /** Auto-deploy enabled (Coolify default: true) */
+    autoDeployEnabled?: boolean;
+    /** Watch paths for selective auto-deploy (newline-separated globs, null = all changes) */
+    watchPaths?: string | null;
+  }>;
+  /** Server UUID */
+  serverUuid: string;
+  /** Server name (for display purposes) */
+  serverName?: string;
+  /** Project UUID */
+  projectUuid: string;
+  /** Project name (for display purposes) */
+  projectName?: string;
+  /** Environment UUID */
+  environmentUuid: string;
+  /** Environment name (for display purposes) */
+  environmentName?: string;
+  /** Git branch */
+  branch?: string;
+  /** Git repository URL */
+  gitRepository?: string;
+  /** Coolify instance URL */
+  coolifyUrl?: string;
+  /** When this state was last updated */
+  updatedAt?: string;
 }
 
 const STATE_FILE = ".coolify.json";
 
 /**
- * Loads .coolify.json from the current working directory.
+ * Loads .coolify.json from the current working directory (single-app format).
+ *
+ * Handles both single-app and multi-app formats. For multi-app state with
+ * exactly one app, returns a synthesized single-app state for backward compat.
  *
  * @returns The deploy state if found, null otherwise
  */
@@ -55,21 +129,127 @@ export function loadCoolifyState(): ICoolifyDeployState | null {
 
   try {
     const content = readFileSync(statePath, "utf-8");
-    const state = JSON.parse(content) as ICoolifyDeployState;
+    const state = JSON.parse(content);
 
+    // Multi-app format — synthesize single-app state if exactly 1 app
+    if (Array.isArray(state.apps)) {
+      if (state.apps.length === 1) {
+        const app = state.apps[0];
+        return {
+          appUuid: app.uuid,
+          appName: app.name,
+          serverUuid: state.serverUuid,
+          serverName: state.serverName,
+          projectUuid: state.projectUuid,
+          projectName: state.projectName,
+          environmentUuid: state.environmentUuid,
+          environmentName: state.environmentName,
+          domain: app.domain,
+          branch: state.branch,
+          gitRepository: state.gitRepository,
+          coolifyUrl: state.coolifyUrl,
+          updatedAt: state.updatedAt,
+        };
+      }
+      // Multi-app with multiple apps — cannot auto-select
+      return null;
+    }
+
+    // Single-app format
     if (!state.appUuid) {
       return null;
     }
 
-    return state;
+    // Validate state against schema rules
+    const validation = validateCoolifyState(state);
+    if (!validation.valid) {
+      console.error(
+        `Warning: .coolify.json has errors: ${validation.errors.join("; ")}`,
+      );
+    }
+    if (validation.warnings.length > 0) {
+      for (const w of validation.warnings) {
+        console.error(`Warning: .coolify.json — ${w}`);
+      }
+    }
+
+    return state as ICoolifyDeployState;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Loads .coolify.json in multi-app format.
+ *
+ * If the file is in single-app format, returns null (use loadCoolifyState instead).
+ *
+ * @returns The multi-app state if found, null otherwise
+ */
+export function loadMultiAppState(): ICoolifyMultiAppState | 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);
+
+    if (!Array.isArray(state.apps)) {
+      return null;
+    }
+
+    return state as ICoolifyMultiAppState;
   } catch {
     return null;
   }
 }
 
+/**
+ * Writes .coolify.json in multi-app format to the current working directory.
+ *
+ * @param state - The multi-app state to write
+ */
+export function writeMultiAppState(state: ICoolifyMultiAppState): void {
+  const validation = validateCoolifyState(
+    state as unknown as Record<string, unknown>,
+  );
+  if (!validation.valid) {
+    console.error(
+      `Warning: writing .coolify.json with errors: ${validation.errors.join("; ")}`,
+    );
+  }
+  const statePath = join(process.cwd(), STATE_FILE);
+  writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+
+/**
+ * Writes .coolify.json to the current working directory.
+ *
+ * @param state - The state to write
+ */
+export function writeCoolifyState(state: ICoolifyDeployState): void {
+  const validation = validateCoolifyState(
+    state as unknown as Record<string, unknown>,
+  );
+  if (!validation.valid) {
+    console.error(
+      `Warning: writing .coolify.json with errors: ${validation.errors.join("; ")}`,
+    );
+  }
+  const statePath = join(process.cwd(), STATE_FILE);
+  writeFileSync(statePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+
 /**
  * Resolves a UUID argument — if not provided, tries to read from .coolify.json.
  *
+ * Supports both single-app and multi-app state formats. For multi-app state
+ * with exactly one app, auto-selects that app. For multiple apps, returns null
+ * (user must specify explicitly).
+ *
  * @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
@@ -78,11 +258,22 @@ export function resolveUuid(
   uuid: string | undefined,
   field: keyof ICoolifyDeployState = "appUuid",
 ): string | null {
-  if (uuid) return uuid;
+  // Only return directly if it looks like a UUID (lowercase alphanumeric, 16-40 chars)
+  // Names like "mks-backend" should fall through to .coolify.json or name resolver
+  if (uuid && /^[a-z0-9]{16,40}$/.test(uuid)) return uuid;
 
+  // Try single-app state first (also handles multi-app with 1 app)
   const state = loadCoolifyState();
-  if (!state) return null;
+  if (state) {
+    const value = state[field];
+    return typeof value === "string" ? value : null;
+  }
+
+  // Try multi-app state — only auto-resolve if exactly 1 app
+  const multiState = loadMultiAppState();
+  if (multiState && multiState.apps.length === 1 && field === "appUuid") {
+    return multiState.apps[0].uuid;
+  }
 
-  const value = state[field];
-  return typeof value === "string" ? value : null;
+  return null;
 }