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

package/src/cli/commands/show.ts

@@ -9,6 +9,7 @@
 import { isErr } from "@mks2508/no-throw";
 import chalk from "chalk";
 import { getCoolifyService } from "../../coolify/index.js";
+import { getCachedAppSettings } from "../../coolify/config.js";
 import { resolveUuid } from "../coolify-state.js";
 import { resolveAppNameOrUuid } from "../name-resolver.js";
 
@@ -38,22 +39,14 @@ export async function showCommand(uuid?: string) {
     return;
   }
 
-  // We need to add getApplication method to CoolifyService
-  // For now, use listApplications and filter
-  const result = await coolify.listApplications();
+  const result = await coolify.getApplication(uuid);
 
   if (isErr(result)) {
     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));
-
-  if (!app) {
-    console.error(chalk.red(`Application not found: ${uuid}`));
-    return;
-  }
+  const app = result.value;
 
   console.log(chalk.cyan("Application Details:"));
   console.log("");
@@ -83,6 +76,42 @@ export async function showCommand(uuid?: string) {
     chalk.gray("Base Dir:   ") + chalk.white(app.base_directory || "N/A"),
   );
   console.log("");
+  console.log(chalk.cyan("Deploy Settings:"));
+  // Coolify API GET does not return settings.is_auto_deploy_enabled (stored in
+  // application_settings table, not eager-loaded by the API). We check:
+  // 1. API response (future-proof for when Coolify fixes this)
+  // 2. Local cache (set when user runs `update --auto-deploy/--no-auto-deploy`)
+  // 3. Default: ON (Coolify default)
+  const cached = await getCachedAppSettings(uuid);
+  const autoDeployFromApi = app.settings?.is_auto_deploy_enabled;
+  const autoDeployFromCache = cached?.isAutoDeployEnabled;
+  const autoDeployEnabled = autoDeployFromApi ?? autoDeployFromCache;
+
+  if (autoDeployEnabled !== undefined) {
+    const source = autoDeployFromApi ? "" : chalk.dim(" (cached)");
+    console.log(
+      chalk.gray("Auto-deploy:") +
+        (autoDeployEnabled ? chalk.green(" ON") : chalk.red(" OFF")) +
+        source,
+    );
+  } else {
+    console.log(
+      chalk.gray("Auto-deploy:") +
+        chalk.dim(" unknown (default: ON, set via --auto-deploy/--no-auto-deploy)"),
+    );
+  }
+  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)"),
+    );
+  }
+  console.log("");
   console.log(chalk.cyan("Destination:"));
   if (app.destination) {
     console.log(chalk.gray("  UUID:  ") + chalk.white(app.destination.uuid));

package/src/cli/commands/status.ts

@@ -26,7 +26,7 @@ import {
 } from "../ui/screen.js";
 import { showStatusDashboard, formatStatus } from "../ui/tables.js";
 import { loadCoolifyState, loadMultiAppState } from "../coolify-state.js";
-import { loadConfig } from "../../coolify/config.js";
+import { loadConfig, getCachedAppSettings } from "../../coolify/config.js";
 import {
   inlineSelect,
   fullSelect,
@@ -232,8 +232,20 @@ async function navigateResource(
   let logPreview: string[] | undefined;
   if (kind === "app") {
     const coolify = getCoolifyService();
-    const [dr, lp] = await Promise.all([coolify.getApplication(uuid), fetchLogPreview(uuid, 6)]);
-    if (!isErr(dr)) appDetail = dr.value;
+    const [dr, lp, cached] = await Promise.all([
+      coolify.getApplication(uuid),
+      fetchLogPreview(uuid, 6),
+      getCachedAppSettings(uuid),
+    ]);
+    if (!isErr(dr)) {
+      appDetail = dr.value;
+      // Augment with cached settings (API GET doesn't return settings)
+      if (cached && !appDetail.settings) {
+        appDetail.settings = {
+          is_auto_deploy_enabled: cached.isAutoDeployEnabled,
+        };
+      }
+    }
     if (lp.length > 0 && !lp[0].includes("unavailable")) logPreview = lp;
   }
 
@@ -348,10 +360,14 @@ async function logsSubMenu(uuid: string, appName: string, pos?: { row: number; c
         const { spawnSync } = await import("child_process");
         const bunPath = process.argv[0] || "bun";
         const scriptPath = process.argv[1] || "coolify-cli";
-        const envVars = `COOLIFY_URL='${process.env.COOLIFY_URL || ""}' COOLIFY_TOKEN='${process.env.COOLIFY_TOKEN || ""}'`;
-        const cmd = `${envVars} '${bunPath}' '${scriptPath}' logs ${uuid} -f`;
+        const cmd = `'${bunPath}' '${scriptPath}' logs ${uuid} -f`;
+        const childEnv = {
+          ...process.env,
+          COOLIFY_URL: process.env.COOLIFY_URL ?? "",
+          COOLIFY_TOKEN: process.env.COOLIFY_TOKEN ?? "",
+        };
         spawnSync("tmux", ["kill-session", "-t", sessionName], { stdio: "ignore" });
-        spawnSync("tmux", ["new-session", "-d", "-s", sessionName, cmd]);
+        spawnSync("tmux", ["new-session", "-d", "-s", sessionName, cmd], { env: childEnv });
         const check = spawnSync("tmux", ["has-session", "-t", sessionName]);
         if (check.status === 0) {
           console.log(chalk.green(`\n  ✓ Session "${sessionName}" created`));
@@ -392,7 +408,7 @@ async function envSubMenu(uuid: string, appName: string, pos?: { row: number; co
     case "list": await envCommand(uuid, {}); await waitForKey(); break;
     case "set": {
       const input = await textInput("KEY=VALUE:");
-      if (input) { await envCommand(uuid, { set: input }); await waitForKey(); }
+      if (input) { await envCommand(uuid, { set: [input] }); await waitForKey(); }
       break;
     }
     case "delete": {

package/src/cli/commands/svc.ts

@@ -83,7 +83,13 @@ export const svcEnvCommand = (uuid: string) =>
     { header: "Runtime", value: (e) => (e.is_runtime ? "Yes" : "No") },
   ]);
 
-/** Set env var for a service. */
+/**
+ * Set env var for a service.
+ *
+ * Note: `services.setEnv` delegates to the bulk endpoint internally, so
+ * calling this for a key that already exists as an override UPDATES the
+ * value instead of failing with 409. Repeatable across deploys.
+ */
 export async function svcSetEnvCommand(
   uuid: string,
   keyValue: string,

package/src/cli/commands/update.ts

@@ -9,6 +9,7 @@
 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";
@@ -30,6 +31,8 @@ interface IUpdateCommandOptions {
   baseDirectory?: string;
   domains?: string;
   autoDeploy?: boolean;
+  watchPaths?: string;
+  clearWatchPaths?: boolean;
   forceHttps?: boolean;
   healthCheckEnabled?: boolean;
   healthCheckPath?: string;
@@ -93,6 +96,11 @@ 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;
@@ -133,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

@@ -10,6 +10,7 @@
 
 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 or init command).
@@ -50,8 +51,12 @@ export interface ICoolifyDeployState {
   type?: string;
   /** 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 */
@@ -72,12 +77,16 @@ export interface ICoolifyMultiAppState {
     name: string;
     /** Service role (e.g. "backend", "admin", "docs", "proxy") */
     service: string;
-    /** Domain if configured */
-    domain?: string;
+    /** Domain if configured (with protocol). Null for internal services. */
+    domain?: string | null;
     /** Dockerfile path relative to repo root */
-    dockerfile?: string;
+    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;
@@ -151,6 +160,19 @@ export function loadCoolifyState(): ICoolifyDeployState | null {
       return null;
     }
 
+    // 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;
@@ -191,6 +213,14 @@ export function loadMultiAppState(): ICoolifyMultiAppState | null {
  * @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");
 }
@@ -201,6 +231,14 @@ export function writeMultiAppState(state: ICoolifyMultiAppState): void {
  * @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");
 }