dockup-cli 1.0.2 → 1.2.0

package/bin/dockup

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/index.js');

package/dist/commands/agent.js

@@ -0,0 +1,432 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target2, all) => {
+  for (var name in all)
+    __defProp(target2, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_exports = {};
+__export(agent_exports, {
+  deployTrigger: () => deployTrigger,
+  deploymentsView: () => deploymentsView,
+  envImport: () => envImport,
+  envRemove: () => envRemove,
+  envSet: () => envSet,
+  envView: () => envView,
+  info: () => info,
+  logsView: () => logsView,
+  registryClear: () => registryClear,
+  registrySet: () => registrySet,
+  resourcesSet: () => resourcesSet,
+  resourcesView: () => resourcesView,
+  servicesList: () => servicesList,
+  statusView: () => statusView
+});
+module.exports = __toCommonJS(agent_exports);
+var import_chalk = __toESM(require("chalk"));
+var fs = __toESM(require("fs"));
+var import_config = require("../lib/config");
+var import_flags = require("../lib/flags");
+var import_output = require("../lib/output");
+var import_target = require("../lib/target");
+var import_api = require("../lib/api");
+function applyJson(opts) {
+  (0, import_flags.setJson)(!!opts?.json);
+}
+function requireAuth() {
+  if (!(0, import_config.isLoggedIn)()) (0, import_output.fail)("Not logged in. Run `dockup login` first.", { code: "not_logged_in" });
+}
+function target(arg) {
+  try {
+    return (0, import_target.resolveTarget)(arg);
+  } catch (e) {
+    return (0, import_output.fail)(e.message, { code: "no_target" });
+  }
+}
+function maskEnv(envVariables = []) {
+  return envVariables.map((e) => ({
+    key: e.key,
+    isSecret: !!e.isSecret,
+    value: e.isSecret ? null : e.value
+  }));
+}
+async function servicesList(opts) {
+  applyJson(opts);
+  requireAuth();
+  try {
+    const services = await import_api.api.getAllServices();
+    const slim = services.map((s) => ({
+      target: s.target,
+      name: s.name,
+      project: s.projectName,
+      status: s.status,
+      domain: s.domain || null,
+      branch: s.branch,
+      deploymentType: s.deploymentType,
+      countryCode: s.countryCode || null
+    }));
+    (0, import_output.emit)({ count: slim.length, services: slim }, () => {
+      console.log(import_chalk.default.cyan(`
+  ${slim.length} service(s)
+`));
+      for (const s of slim) {
+        const dot = s.status === "running" ? import_chalk.default.green("\u25CF") : s.status === "error" ? import_chalk.default.red("\u25CF") : import_chalk.default.yellow("\u25CF");
+        console.log(`  ${dot} ${import_chalk.default.bold(s.target.padEnd(40))} ${import_chalk.default.dim(s.status)}`);
+      }
+      console.log();
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function info(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  try {
+    const s = await import_api.api.getServiceStatus(t.projectSlug, t.serviceSlug);
+    const data = {
+      target: `${t.projectSlug}/${t.serviceSlug}`,
+      name: s.name,
+      status: s.status,
+      deploymentType: s.deploymentType,
+      repoUrl: s.repoUrl || null,
+      branch: s.branch || null,
+      domain: s.domain || null,
+      port: s.port ?? null,
+      exposedPort: s.exposedPort ?? null,
+      autoDeployEnabled: !!s.autoDeployEnabled,
+      prPreviewEnabled: !!s.prPreviewEnabled,
+      memoryLimit: s.memoryLimit ?? null,
+      cpuLimit: s.cpuLimit ?? null,
+      lastDeployedAt: s.lastDeployedAt || null,
+      lastError: s.lastError || null,
+      env: maskEnv(s.envVariables),
+      customDomains: (s.customDomains || []).map((d) => ({ domain: d.domain, status: d.status, ssl: !!d.sslEnabled })),
+      latestDeployment: (s.deployments || [])[0] || null
+    };
+    (0, import_output.emit)(data, () => {
+      console.log(import_chalk.default.cyan(`
+  ${import_chalk.default.bold(data.name)}  ${import_chalk.default.dim(data.target)}
+`));
+      console.log(`  ${import_chalk.default.dim("Status:")}     ${data.status}`);
+      console.log(`  ${import_chalk.default.dim("Repo:")}       ${data.repoUrl || "N/A"} @ ${data.branch || "main"}`);
+      console.log(`  ${import_chalk.default.dim("Domain:")}     ${data.domain || "N/A"}`);
+      console.log(`  ${import_chalk.default.dim("Type:")}       ${data.deploymentType}`);
+      console.log(`  ${import_chalk.default.dim("Auto-deploy:")} ${data.autoDeployEnabled}`);
+      console.log(`  ${import_chalk.default.dim("Env vars:")}   ${data.env.length}`);
+      console.log();
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function statusView(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  try {
+    const s = await import_api.api.getServiceStatus(t.projectSlug, t.serviceSlug);
+    const latest = (s.deployments || [])[0] || null;
+    const data = {
+      target: `${t.projectSlug}/${t.serviceSlug}`,
+      status: s.status,
+      domain: s.domain || null,
+      lastDeployedAt: s.lastDeployedAt || null,
+      lastError: s.lastError || null,
+      latestDeployment: latest && {
+        id: latest.id,
+        status: latest.status,
+        commitHash: latest.commitHash,
+        commitMessage: latest.commitMessage,
+        startedAt: latest.startedAt,
+        completedAt: latest.completedAt
+      }
+    };
+    (0, import_output.emit)(data, () => {
+      console.log(import_chalk.default.cyan(`
+  ${import_chalk.default.bold(data.target)}: ${data.status}
+`));
+      if (data.domain) console.log(`  ${import_chalk.default.dim("URL:")} https://${data.domain}`);
+      if (latest) console.log(`  ${import_chalk.default.dim("Last deploy:")} ${latest.status} (${(latest.commitHash || "").substring(0, 7)})`);
+      console.log();
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function deploymentsView(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  const limit = parseInt(opts?.number || "10", 10);
+  try {
+    const deployments = await import_api.api.getDeployments(t.projectSlug, t.serviceSlug, limit);
+    (0, import_output.emit)({ target: `${t.projectSlug}/${t.serviceSlug}`, count: deployments.length, deployments }, () => {
+      console.log(import_chalk.default.cyan(`
+  Deployment history \u2014 ${t.serviceSlug}
+`));
+      for (const d of deployments) {
+        const c = d.status === "success" ? import_chalk.default.green : d.status === "failed" ? import_chalk.default.red : import_chalk.default.yellow;
+        const when = d.createdAt ? new Date(d.createdAt).toLocaleString() : "";
+        console.log(`  ${c(d.status.padEnd(9))} ${(d.commitHash || "").substring(0, 7)}  ${import_chalk.default.dim(when)}  ${d.commitMessage || ""}`);
+      }
+      console.log();
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function logsView(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  const lines = parseInt(opts?.number || "200", 10);
+  try {
+    if (opts?.build) {
+      const res = await import_api.api.getBuildLogs(t.projectSlug, t.serviceSlug);
+      (0, import_output.emit)({ target: `${t.projectSlug}/${t.serviceSlug}`, type: "build", deployment: res.deployment, lastError: res.lastError, logs: res.logs }, () => {
+        console.log(res.logs);
+      });
+    } else {
+      const res = await import_api.api.getRuntimeLogs(t.projectSlug, t.serviceSlug, lines);
+      (0, import_output.emit)({ target: `${t.projectSlug}/${t.serviceSlug}`, type: res.type, logs: res.logs }, () => {
+        console.log(res.logs);
+      });
+    }
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function envView(opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(opts?.service);
+  try {
+    const s = await import_api.api.getServiceStatus(t.projectSlug, t.serviceSlug);
+    const env = maskEnv(s.envVariables);
+    (0, import_output.emit)({ target: `${t.projectSlug}/${t.serviceSlug}`, count: env.length, env }, () => {
+      for (const e of env) console.log(`  ${import_chalk.default.green(e.key)}=${e.isSecret ? import_chalk.default.dim("<secret>") : e.value}`);
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function envSet(keyValue, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(opts?.service);
+  const eq = keyValue.indexOf("=");
+  if (eq === -1) (0, import_output.fail)("Invalid format. Use KEY=value.", { code: "bad_format" });
+  const key = keyValue.substring(0, eq);
+  const value = keyValue.substring(eq + 1);
+  if (!key) (0, import_output.fail)("Key cannot be empty.", { code: "bad_format" });
+  try {
+    await import_api.api.setEnvVariable(t.projectSlug, t.serviceSlug, key, value, !!opts?.secret);
+    (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, key, secret: !!opts?.secret, hint: "redeploy to apply" }, () => {
+      console.log(import_chalk.default.green(`\u2713 set ${key}`) + import_chalk.default.dim("  (redeploy to apply)"));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function envRemove(key, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(opts?.service);
+  try {
+    await import_api.api.deleteEnvVariable(t.projectSlug, t.serviceSlug, key);
+    (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, key, removed: true, hint: "redeploy to apply" }, () => {
+      console.log(import_chalk.default.green(`\u2713 removed ${key}`) + import_chalk.default.dim("  (redeploy to apply)"));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function envImport(file, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(opts?.service);
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf-8");
+  } catch {
+    return (0, import_output.fail)(`Cannot read file: ${file}`, { code: "file_not_found" });
+  }
+  const entries = [];
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    let value = line.substring(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    entries.push({ key: line.substring(0, eq).trim(), value });
+  }
+  const done = [];
+  try {
+    for (const e of entries) {
+      await import_api.api.setEnvVariable(t.projectSlug, t.serviceSlug, e.key, e.value, !!opts?.secret);
+      done.push(e.key);
+    }
+    (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, imported: done.length, keys: done, hint: "redeploy to apply" }, () => {
+      console.log(import_chalk.default.green(`\u2713 imported ${done.length} variable(s)`) + import_chalk.default.dim("  (redeploy to apply)"));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message, { importedBeforeError: done });
+  }
+}
+async function registrySet(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  if (!opts?.url || !opts?.user || !opts?.token) {
+    return (0, import_output.fail)("--url, --user and --token are required", { code: "bad_args" });
+  }
+  try {
+    await import_api.api.setRegistry(t.projectSlug, t.serviceSlug, opts.url, opts.user, opts.token);
+    (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, registryUrl: opts.url, registryUsername: opts.user, hint: "redeploy to use the private base image" }, () => {
+      console.log(import_chalk.default.green(`\u2713 registry credentials saved for ${opts.url}`) + import_chalk.default.dim("  (redeploy to apply)"));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function registryClear(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  try {
+    await import_api.api.clearRegistry(t.projectSlug, t.serviceSlug);
+    (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, cleared: true }, () => {
+      console.log(import_chalk.default.green("\u2713 registry credentials cleared"));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+const CPU_PER_MONTH = 463e-6 * 43200;
+const MEM_PER_GB_PER_MONTH = 231e-6 * 43200;
+const monthlyCost = (cpu, memMB) => Math.round((cpu * CPU_PER_MONTH + memMB / 1024 * MEM_PER_GB_PER_MONTH) * 100) / 100;
+async function resourcesView(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  try {
+    let memMB, cpu, name, kind;
+    if (opts?.db) {
+      const d = await import_api.api.getDatabaseDetail(t.projectSlug, t.serviceSlug);
+      const s = d.settings || d.database || d;
+      memMB = s.memoryLimitMB ?? 1024;
+      cpu = s.cpuLimit ?? 1;
+      name = d.database?.name || s.name || t.serviceSlug;
+      kind = "database";
+    } else {
+      const s = await import_api.api.getServiceStatus(t.projectSlug, t.serviceSlug);
+      memMB = s.memoryLimit ?? 2048;
+      cpu = s.cpuLimit ?? 2;
+      name = s.name || t.serviceSlug;
+      kind = "service";
+    }
+    const data = {
+      target: `${t.projectSlug}/${t.serviceSlug}`,
+      kind,
+      name,
+      cpu,
+      memoryMB: memMB,
+      estMonthlyUsd: monthlyCost(cpu, memMB),
+      limits: { maxCpu: 24, maxMemMB: 24576 }
+    };
+    (0, import_output.emit)(data, () => {
+      console.log(import_chalk.default.cyan(`
+  ${import_chalk.default.bold(name)}  ${import_chalk.default.dim(data.target)}  ${import_chalk.default.dim("(" + kind + ")")}
+`));
+      console.log(`  ${import_chalk.default.dim("CPU:")}    ${cpu} vCPU`);
+      console.log(`  ${import_chalk.default.dim("RAM:")}    ${memMB >= 1024 ? memMB / 1024 + " GB" : memMB + " MB"}`);
+      console.log(`  ${import_chalk.default.dim("Est.:")}   $${data.estMonthlyUsd.toFixed(2)}/mo ${import_chalk.default.dim("+ disk")}`);
+      console.log();
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function resourcesSet(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  const cpu = opts?.cpu !== void 0 ? parseFloat(opts.cpu) : void 0;
+  const mem = opts?.memory !== void 0 ? parseInt(opts.memory, 10) : void 0;
+  if (cpu === void 0 && mem === void 0) {
+    return (0, import_output.fail)("Provide --cpu <vCPU> and/or --memory <MB>.", { code: "bad_args" });
+  }
+  if (cpu !== void 0 && (isNaN(cpu) || cpu <= 0)) return (0, import_output.fail)("--cpu must be a positive number (max 24).", { code: "bad_args" });
+  if (mem !== void 0 && (isNaN(mem) || mem <= 0)) return (0, import_output.fail)("--memory must be MB (e.g. 4096, max 24576).", { code: "bad_args" });
+  try {
+    if (opts?.db) {
+      const res = await import_api.api.setDatabaseResources(t.projectSlug, t.serviceSlug, mem ?? 1024, cpu ?? 1);
+      (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, kind: "database", memoryMB: res.memoryLimitMB, cpu: res.cpuLimit, applied: res.applied, estMonthlyUsd: monthlyCost(res.cpuLimit, res.memoryLimitMB) }, () => {
+        console.log(import_chalk.default.green(`\u2713 ${res.cpuLimit} vCPU / ${res.memoryLimitMB} MB`) + import_chalk.default.dim(`  ${res.applied ? "(applied)" : "(start db to apply)"}  ~$${monthlyCost(res.cpuLimit, res.memoryLimitMB).toFixed(2)}/mo`));
+      });
+    } else {
+      const res = await import_api.api.setServiceResources(t.projectSlug, t.serviceSlug, mem ?? 2048, cpu ?? 2);
+      (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, kind: "service", memoryMB: res.memoryLimit, cpu: res.cpuLimit, applied: res.applied, estMonthlyUsd: monthlyCost(res.cpuLimit, res.memoryLimit) }, () => {
+        console.log(import_chalk.default.green(`\u2713 ${res.cpuLimit} vCPU / ${res.memoryLimit} MB`) + import_chalk.default.dim(`  ${res.applied ? "(applied)" : "(redeploy to apply)"}  ~$${monthlyCost(res.cpuLimit, res.memoryLimit).toFixed(2)}/mo`));
+      });
+    }
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function deployTrigger(arg, opts) {
+  applyJson(opts);
+  requireAuth();
+  const t = target(arg);
+  try {
+    const result = await import_api.api.deploy(t.projectSlug, t.serviceSlug, opts?.branch ? { branch: opts.branch } : void 0);
+    (0, import_output.ok)({ target: `${t.projectSlug}/${t.serviceSlug}`, deploymentId: result?.deployment?.id || null, hint: "poll `dockup status` for progress" }, () => {
+      console.log(import_chalk.default.green("\u2713 deployment triggered") + import_chalk.default.dim(`  (${result?.deployment?.id || "n/a"})`));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deployTrigger,
+  deploymentsView,
+  envImport,
+  envRemove,
+  envSet,
+  envView,
+  info,
+  logsView,
+  registryClear,
+  registrySet,
+  resourcesSet,
+  resourcesView,
+  servicesList,
+  statusView
+});