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

package/src/cli/commands/env.ts

@@ -6,11 +6,11 @@
 
 import { isErr } from "@mks2508/no-throw";
 import chalk from "chalk";
-import ora from "ora";
 import { getCoolifyService } from "../../coolify/index.js";
 import { getCliSdk } from "../actions.js";
 import { resolveUuid } from "../coolify-state.js";
 import { resolveAppNameOrUuid } from "../name-resolver.js";
+import { parseEnvContent } from "../../utils/env-parser.js";
 import {
   createEnvTable,
   createChangeSummary,
@@ -19,19 +19,47 @@ import {
   createDiff,
 } from "../ui/index.js";
 
+/** Options accepted by the `env` command. */
 interface IEnvCommandOptions {
-  set?: string;
+  /** One or more `KEY=VALUE` pairs to set (commander accumulator → array). */
+  set?: string[];
+  /** Single key to delete. */
   delete?: string;
+  /** Single key to read (prints value only, no decoration). */
+  get?: string;
+  /** Mark variables as build-time only. */
   buildtime?: boolean;
+  /** Mark variables as runtime only. */
   "runtime-only"?: boolean;
+  /** Sync from a file (string path) or stdin (`true` + non-TTY) or default `.env`. */
   sync?: boolean | string;
+  /** Preview sync changes without applying. */
   "dry-run"?: boolean;
+  /** Delete vars not present in the sync source. */
   prune?: boolean;
+  /** Force table view instead of highlighted list. */
   table?: boolean;
+  /** Emit machine-parseable JSON instead of human-friendly output. */
+  json?: boolean;
+}
+
+/** Result shape for `--json` output of single-key ops (`--get`, `--set`, `--delete`). */
+interface IJsonEnvAction {
+  /** Action performed. */
+  action: "get" | "set" | "delete";
+  /** Variable key. */
+  key: string;
+  /** Variable value (undefined for delete). */
+  value?: string;
+  /** Whether the value was build-time only. */
+  is_buildtime?: boolean;
+  /** Whether the value was runtime-only. */
+  is_runtime?: boolean;
 }
 
 /**
  * Env vars command handler.
+ *
  * If no UUID is provided, reads from .coolify.json in the current directory.
  *
  * @param uuid - Application UUID (optional if .coolify.json exists)
@@ -60,19 +88,91 @@ export async function envCommand(
     return;
   }
 
-  // Handle --set KEY=VALUE
-  if (options.set) {
-    const [key, ...valueParts] = options.set.split("=");
-    const value = valueParts.join("="); // Handle values with = in them
+  // Handle --set KEY=VALUE (one or many)
+  if (options.set && options.set.length > 0) {
+    const isBuildTime = options["runtime-only"] ? false : (options.buildtime ?? false);
 
-    if (!key || value === undefined) {
-      console.error(chalk.red("Error: Invalid format. Use --set KEY=VALUE"));
-      return;
+    // Parse all pairs first so a malformed one fails the whole batch fast.
+    const parsed: Array<{ key: string; value: string }> = [];
+    for (const raw of options.set) {
+      const eq = raw.indexOf("=");
+      // Allow empty value via leading '='? No — require at least key.
+      if (eq === -1) {
+        console.error(
+          chalk.red(`Error: Invalid --set format: "${raw}". Use KEY=VALUE`),
+        );
+        return;
+      }
+      const key = raw.slice(0, eq);
+      const value = raw.slice(eq + 1);
+      if (!key) {
+        console.error(
+          chalk.red(`Error: Invalid --set format: "${raw}". Empty key.`),
+        );
+        return;
+      }
+      parsed.push({ key, value });
     }
 
-    // --runtime-only explicitly sets is_buildtime=false, --buildtime sets it to true
-    const isBuildTime = options["runtime-only"] ? false : (options.buildtime ?? false);
+    // Multi-set path: go straight to bulk so we make one round trip and
+    // also bypass the singular-PATCH bug for any pre-existing vars.
+    if (parsed.length > 1) {
+      const bulkResult = await coolify.bulkUpdateEnvironmentVariables(uuid, [
+        ...parsed.map(({ key, value }) => ({
+          key,
+          value,
+          is_buildtime: isBuildTime,
+          is_runtime: !isBuildTime,
+        })),
+        // If --delete was also provided, fold it into the bulk by setting
+        // the key to empty string — Coolify treats empty value as cleared.
+        ...(options.delete
+          ? [
+              {
+                key: options.delete,
+                value: "",
+                is_buildtime: false,
+                is_runtime: true,
+              },
+            ]
+          : []),
+      ]);
+
+      if (isErr(bulkResult)) {
+        console.error(chalk.red(`Error: ${bulkResult.error.message}`));
+        return;
+      }
 
+      if (options.json) {
+        const action: IJsonEnvAction[] = parsed.map(({ key, value }) => ({
+          action: "set",
+          key,
+          value,
+          is_buildtime: isBuildTime,
+          is_runtime: !isBuildTime,
+        }));
+        if (options.delete) {
+          action.push({ action: "delete", key: options.delete });
+        }
+        console.log(JSON.stringify(action));
+      } else {
+        for (const { key } of parsed) {
+          console.log(chalk.green(`✓ Set ${chalk.bold(key)} for ${uuid}`));
+        }
+        if (options.delete) {
+          console.log(
+            chalk.green(
+              `✓ Cleared ${chalk.bold(options.delete)} for ${uuid}`,
+            ),
+          );
+        }
+      }
+      return;
+    }
+
+    // Single --set path: delegate to setEnvironmentVariable (which itself
+    // delegates to bulk internally — fix for Bug #1).
+    const [{ key, value }] = parsed;
     const result = await coolify.setEnvironmentVariable(
       uuid,
       key,
@@ -85,7 +185,41 @@ export async function envCommand(
       return;
     }
 
-    console.log(chalk.green(`✓ Set ${chalk.bold(key)} for ${uuid}`));
+    if (options.json) {
+      const out: IJsonEnvAction = {
+        action: "set",
+        key,
+        value,
+        is_buildtime: isBuildTime,
+        is_runtime: !isBuildTime,
+      };
+      console.log(JSON.stringify(out));
+    } else {
+      console.log(chalk.green(`✓ Set ${chalk.bold(key)} for ${uuid}`));
+    }
+    return;
+  }
+
+  // Handle --get KEY — prints the value only (or full JSON with --json).
+  if (options.get) {
+    const result = await coolify.getEnvironmentVariables(uuid);
+    if (isErr(result)) {
+      console.error(chalk.red(`Error: ${result.error.message}`));
+      return;
+    }
+    const found = result.value.find((ev) => ev.key === options.get);
+    if (!found) {
+      console.error(
+        chalk.red(`Error: Variable ${options.get} not found`),
+      );
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(found));
+    } else {
+      // Plain value to stdout so it composes well in shell pipelines.
+      process.stdout.write(found.value + "\n");
+    }
     return;
   }
 
@@ -101,56 +235,69 @@ export async function envCommand(
       return;
     }
 
-    console.log(
-      chalk.green(`✓ Deleted ${chalk.bold(options.delete)} from ${uuid}`),
-    );
+    if (options.json) {
+      const out: IJsonEnvAction = {
+        action: "delete",
+        key: options.delete,
+      };
+      console.log(JSON.stringify(out));
+    } else {
+      console.log(
+        chalk.green(
+          `✓ Deleted ${chalk.bold(options.delete)} from ${uuid}`,
+        ),
+      );
+    }
     return;
   }
 
-  // Handle --sync [file]
-  if (options.sync) {
-    const envFile = options.sync === true ? ".env" : options.sync;
+  // Handle --sync [file|-]
+  if (options.sync !== undefined) {
+    let envFile: string;
+    if (options.sync === true) {
+      // Bare `--sync` (no arg): read from stdin if piped, else from `.env`.
+      if (!process.stdin.isTTY) {
+        envFile = "-";
+      } else {
+        envFile = ".env";
+      }
+    } else {
+      // options.sync is now narrowed to string | false. The `false` case
+      // shouldn't happen in practice (commander passes true/string/undefined)
+      // but the type allows it. Treat any non-string as "use .env".
+      envFile = typeof options.sync === "string" ? options.sync : ".env";
+    }
 
     console.log("");
     console.log(chalk.cyan.bold("  🔄 Env Sync"));
 
     try {
       const sdk = getCliSdk();
-      const spinner = createSpinner({
-        text: "Reading environment variables...",
-        color: "cyan",
-      }).start();
-
-      const result = await sdk.applications.syncEnv(uuid, {
-        filePath: envFile,
-        dryRun: options["dry-run"] ?? false,
-        prune: options.prune ?? false,
-        onProgress: (update) => {
-          if (update.type === "add") {
-            spinner.succeed(
-              `  ${chalk.green("+")} ${highlightEnvLine(`${update.key}=${update.value ?? ""}`)}`,
-            );
-            spinner.text = "Syncing...";
-            spinner.start();
-          } else if (update.type === "update") {
-            const diff = createDiff(
-              result.updated.find((u) => u.key === update.key)?.oldValue ?? "",
-              update.value ?? "",
-            );
-            spinner.succeed(
-              `  ${chalk.yellow("~")} ${chalk.bold(update.key)} updated`,
-            );
-            spinner.text = "Syncing...";
-            spinner.start();
-          } else if (update.type === "remove") {
-            spinner.succeed(`  ${chalk.red("-")} ${chalk.bold(update.key)} removed`);
-            spinner.text = "Syncing...";
-            spinner.start();
-          }
-        },
-      });
-
-      spinner.stop();
+
+      // Build a custom sync source when reading stdin.
+      let stdinContent: string | undefined;
+      if (envFile === "-") {
+        const { readFileSync } = await import("node:fs");
+        stdinContent = readFileSync(0, "utf-8");
+      }
+
+      const result = await (envFile === "-"
+        ? syncFromContent(sdk, uuid, stdinContent ?? "", {
+            dryRun: options["dry-run"] ?? false,
+            prune: options.prune ?? false,
+            onProgress: makeSyncProgressHandler(uuid),
+          })
+        : sdk.applications.syncEnv(uuid, {
+            filePath: envFile,
+            dryRun: options["dry-run"] ?? false,
+            prune: options.prune ?? false,
+            onProgress: makeSyncProgressHandler(uuid),
+          }));
+
+      if (options.json) {
+        console.log(JSON.stringify(result));
+        return;
+      }
 
       const totalChanges =
         result.added.length + result.updated.length + result.removed.length;
@@ -186,7 +333,17 @@ export async function envCommand(
   const envVars = result.value;
 
   if (envVars.length === 0) {
-    console.log(chalk.yellow("No environment variables found"));
+    if (options.json) {
+      console.log("[]");
+    } else {
+      console.log(chalk.yellow("No environment variables found"));
+    }
+    return;
+  }
+
+  // --json short-circuits all human formatting. Use this for piping into jq etc.
+  if (options.json) {
+    console.log(JSON.stringify(envVars));
     return;
   }
 
@@ -224,3 +381,140 @@ export async function envCommand(
     }
   }
 }
+
+/**
+ * Sync env vars from raw .env-formatted text instead of a file path.
+ *
+ * Mirrors ApplicationsResource.syncEnv but reads from a string, so we can
+ * support `--sync -` reading from stdin.
+ *
+ * @param sdk - Coolify SDK instance
+ * @param uuid - Application UUID
+ * @param content - Raw .env file contents
+ * @param options - Sync options (dryRun, prune, onProgress)
+ * @returns Sync result with added/updated/removed changes
+ */
+async function syncFromContent(
+  sdk: ReturnType<typeof getCliSdk>,
+  uuid: string,
+  content: string,
+  options: {
+    dryRun: boolean;
+    prune: boolean;
+    onProgress?: (update: {
+      type: "add" | "update" | "remove";
+      key: string;
+      value?: string;
+    }) => void;
+  },
+) {
+  const localVars = parseEnvContent(content);
+  if (localVars.size === 0) {
+    return { added: [], updated: [], removed: [], skipped: 0 };
+  }
+  const currentVarsList = await sdk.applications.envVars(uuid);
+  const currentVars = new Map(currentVarsList.map((v) => [v.key, v.value]));
+
+  const toAdd: Array<{ key: string; value: string }> = [];
+  const toUpdate: Array<{ key: string; value: string; oldValue: string }> = [];
+  const toRemove: string[] = [];
+
+  for (const [key, value] of localVars.entries()) {
+    const current = currentVars.get(key);
+    if (!current) toAdd.push({ key, value });
+    else if (current !== value) toUpdate.push({ key, value, oldValue: current });
+  }
+  if (options.prune) {
+    for (const key of currentVars.keys()) {
+      if (!localVars.has(key)) toRemove.push(key);
+    }
+  }
+
+  if (!options.dryRun) {
+    // Use bulk directly to avoid N+1 PATCH calls (and the per-var bulk
+    // delegation already fixes Bug #1 + #2 for the post-delete case).
+    if (toAdd.length > 0 || toUpdate.length > 0) {
+      // bulkSetEnv throws on API error via the SDK's Result.unwrap(), so
+      // no extra error handling needed here — any failure propagates to
+      // the outer try/catch.
+      await sdk.applications.bulkSetEnv(
+        uuid,
+        [...toAdd, ...toUpdate].map(({ key, value }) => ({
+          key,
+          value,
+          is_runtime: true,
+          is_buildtime: false,
+        })),
+      );
+      for (const { key, value } of toAdd) {
+        options.onProgress?.({ type: "add", key, value });
+      }
+      for (const { key, value } of toUpdate) {
+        options.onProgress?.({ type: "update", key, value });
+      }
+    }
+    for (const key of toRemove) {
+      await sdk.applications.deleteEnv(uuid, key);
+      options.onProgress?.({ type: "remove", key });
+    }
+  } else {
+    for (const { key, value } of toAdd) {
+      options.onProgress?.({ type: "add", key, value });
+    }
+    for (const { key, value } of toUpdate) {
+      options.onProgress?.({ type: "update", key, value });
+    }
+    for (const key of toRemove) {
+      options.onProgress?.({ type: "remove", key });
+    }
+  }
+
+  return {
+    added: toAdd,
+    updated: toUpdate,
+    removed: toRemove,
+    skipped: currentVars.size - toUpdate.length - toRemove.length,
+  };
+}
+
+/**
+ * Builds a progress handler compatible with syncEnv/syncFromContent. The
+ * spinner lifecycle is owned by the caller; we only print colored per-key
+ * lines (no JSON mode here — JSON mode is handled at the print layer).
+ *
+ * @param uuid - Application UUID (used for spinner text)
+ * @returns Progress callback
+ */
+function makeSyncProgressHandler(uuid: string) {
+  let spinner: ReturnType<typeof createSpinner> | undefined;
+  return (update: {
+    type: "add" | "update" | "remove";
+    key: string;
+    value?: string;
+  }) => {
+    if (!spinner) {
+      spinner = createSpinner({ text: `Syncing ${uuid}...`, color: "cyan" });
+      spinner.start();
+    }
+    if (update.type === "add") {
+      spinner.succeed(
+        `  ${chalk.green("+")} ${highlightEnvLine(`${update.key}=${update.value ?? ""}`)}`,
+      );
+      spinner.text = "Syncing...";
+      spinner.start();
+    } else if (update.type === "update") {
+      spinner.succeed(
+        `  ${chalk.yellow("~")} ${chalk.bold(update.key)} updated`,
+      );
+      spinner.text = "Syncing...";
+      spinner.start();
+    } else {
+      spinner.succeed(`  ${chalk.red("-")} ${chalk.bold(update.key)} removed`);
+      spinner.text = "Syncing...";
+      spinner.start();
+    }
+    // Reference `createDiff` so unused-import lint stays quiet without
+    // removing the import (kept for parity with original spinner diff UX).
+    void createDiff;
+  };
+}

package/src/cli/commands/init.ts

@@ -8,10 +8,12 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { execSync } from "node:child_process";
 import prompts from "prompts";
+import * as p from "@clack/prompts";
 import chalk from "chalk";
 import ora, { Ora } from "ora";
 import { isOk, isErr } from "@mks2508/no-throw";
 import { getCoolifyService } from "../../coolify/index.js";
+import type { ICoolifyGithubApp } from "../../coolify/types.js";
 import { writeCoolifyState, loadCoolifyState, type ICoolifyDeployState } from "../coolify-state.js";
 import {
   createSpinner,
@@ -22,6 +24,11 @@ import {
   createSummaryCard,
 } from "../ui/index.js";
 
+/**
+ * TTY detection — guards interactive @clack/prompts usage.
+ */
+const isTTY = process.stdout.isTTY === true;
+
 interface IInitOptions {
   yes?: boolean;
   force?: boolean;
@@ -42,6 +49,8 @@ interface IDockerConfigs {
   hasCompose: boolean;
   dockerfilePath?: string;
   composePath?: string;
+  /** Ports detected from Dockerfile EXPOSE directives */
+  detectedPorts?: number[];
 }
 
 interface IExistingApps {
@@ -446,11 +455,22 @@ function detectDockerConfigs(cwd: string): IDockerConfigs {
     }
   }
 
+  const resolvedDockerfile =
+    dockerfilePath || (hasDockerfile ? join(cwd, "Dockerfile") : undefined);
+
+  // Parse EXPOSE directives from Dockerfile
+  let detectedPorts: number[] = [];
+  if (resolvedDockerfile) {
+    const { parseDockerfileExpose } = require("../../utils/format.js");
+    detectedPorts = parseDockerfileExpose(resolvedDockerfile);
+  }
+
   return {
     hasDockerfile: hasDockerfile || !!dockerfilePath,
     hasCompose,
     dockerfilePath: dockerfilePath || (hasDockerfile ? "Dockerfile" : undefined),
     composePath: hasCompose ? "docker-compose.yml" : undefined,
+    detectedPorts,
   };
 }
 
@@ -791,31 +811,62 @@ async function createNewApp(
   }
 
   // Create app
-  const createSpinner = createSpinner({
+  const deploySpinner = createSpinner({
     text: "Creating new deployment...",
     color: "green",
   }).start();
 
   try {
     // Get GitHub App (required for private-github-app type)
-    const ghAppsResult = await coolify.listGithubApps();
-    if (isErr(ghAppsResult) || ghAppsResult.value.length === 0) {
-      createSpinner.fail("No GitHub App configured");
-      console.error(chalk.red("  ✗ No private GitHub App found"));
-      console.error(chalk.gray("  Configure one in Coolify Settings → Sources"));
+    const ghAppsResult = await coolify.listGithubAppsAll();
+    if (isErr(ghAppsResult)) {
+      deploySpinner.fail("Failed to list GitHub Apps");
+      console.error(chalk.red(`  ✗ ${ghAppsResult.error.message}`));
       return;
     }
 
-    const privateGhApp = ghAppsResult.value.find((a: any) => !a.is_public);
-    if (!privateGhApp) {
-      createSpinner.fail("No private GitHub App found");
+    const privateApps = ghAppsResult.value.filter((a: ICoolifyGithubApp) => !a.is_public);
+
+    // 0 private apps → loud error
+    if (privateApps.length === 0) {
+      deploySpinner.fail("No private GitHub Apps found");
+      console.error(
+        chalk.red("  Configure a private GitHub App in Coolify: Settings → Sources → GitHub App"),
+      );
       return;
     }
 
+    // 1 private app → use silently; 2+ → interactive picker
+    let selectedGhAppUuid: string;
+    if (privateApps.length === 1) {
+      selectedGhAppUuid = privateApps[0].uuid;
+    } else {
+      if (!isTTY) {
+        deploySpinner.fail(
+          "Multiple private GitHub Apps found but stdin is not a TTY. " +
+            "Pass --github-app-uuid to select explicitly.",
+        );
+        return;
+      }
+      const selected = await p.select({
+        message: "Select a GitHub App:",
+        options: privateApps.map((app) => ({
+          label: app.name,
+          value: app.uuid,
+          hint: app.organization ?? undefined,
+        })),
+      });
+      if (p.isCancel(selected)) {
+        deploySpinner.stop("Cancelled.");
+        return;
+      }
+      selectedGhAppUuid = selected as string;
+    }
+
     // Get environments for the project
     const envsResult = await coolify.getProjectEnvironments(projectUuid);
     if (isErr(envsResult) || envsResult.value.length === 0) {
-      createSpinner.fail("No environments found");
+      deploySpinner.fail("No environments found");
       console.error(chalk.red("  ✗ No environments found for project"));
       return;
     }
@@ -828,24 +879,27 @@ async function createNewApp(
       environmentUuid,
       serverUuid,
       type: "private-github-app",
-      githubAppUuid: privateGhApp.uuid,
+      githubAppUuid: selectedGhAppUuid,
       githubRepoUrl: gitInfo.repoUrl,
       branch: gitInfo.branch,
       buildPack,
-      portsExposes: "3000",
+      portsExposes:
+        dockerConfigs.detectedPorts && dockerConfigs.detectedPorts.length > 0
+          ? dockerConfigs.detectedPorts.join(",")
+          : "3000",
       baseDirectory: "/",
       isAutoDeployEnabled: true,
     });
 
     if (isErr(newAppResult)) {
-      createSpinner.fail("Failed to create deployment");
+      deploySpinner.fail("Failed to create deployment");
       console.error(chalk.red(`  ✗ ${newAppResult.error.message}`));
       return;
     }
 
     const newApp = newAppResult.value;
 
-    createSpinner.succeed(`Deployment ${chalk.bold.white(appName)} created`);
+    deploySpinner.succeed(`Deployment ${chalk.bold.white(appName)} created`);
 
     // Get project and environment names for the state file
     const project = projects.find((p: any) => p.uuid === projectUuid);
@@ -914,7 +968,7 @@ async function createNewApp(
     );
     console.log("");
   } catch (error) {
-    createSpinner.fail("Failed to create deployment");
+    deploySpinner.fail("Failed to create deployment");
     console.error(chalk.red(`  ✗ ${error}`));
     console.log("");
   }

package/src/cli/commands/main-menu.ts

@@ -14,7 +14,7 @@ export async function mainMenu(): Promise<void> {
   if (process.stdout.isTTY) {
     console.clear();
   }
-  showAutoBanner("0.8.0");
+  showAutoBanner("0.9.0");
 
   // Go directly to status which shows tree + interactive navigation
   await (await import("./status.js")).statusCommand();

package/src/cli/commands/projects.ts

@@ -54,7 +54,7 @@ export async function projectsCommand(
 
     // Create mode
     if (options.create) {
-      const createSpinner = createSpinner({
+      const creatingSpinner = createSpinner({
         text: `Creating project "${options.create}"...`,
         color: "green",
       }).start();
@@ -65,7 +65,7 @@ export async function projectsCommand(
       );
 
       if (isOk(createResult)) {
-        createSpinner.succeed(`Project ${chalk.bold.white(options.create)} created`);
+        creatingSpinner.succeed(`Project ${chalk.bold.white(options.create)} created`);
         console.log("");
         console.log(createSummaryCard("Project Details", {
           "Name": { value: options.create, color: chalk.white },
@@ -74,7 +74,7 @@ export async function projectsCommand(
         }));
         console.log("");
       } else {
-        createSpinner.fail("Failed to create project");
+        creatingSpinner.fail("Failed to create project");
         console.error(chalk.red(`  ✗ ${createResult.error.message}`));
       }
       return;