dockup-cli 1.1.0 → 1.3.0

package/dist/commands/agent.js

@@ -38,6 +38,8 @@ __export(agent_exports, {
   logsView: () => logsView,
   registryClear: () => registryClear,
   registrySet: () => registrySet,
+  resourcesSet: () => resourcesSet,
+  resourcesView: () => resourcesView,
   servicesList: () => servicesList,
   statusView: () => statusView
 });
@@ -326,6 +328,78 @@ async function registryClear(arg, opts) {
     (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();
@@ -351,6 +425,8 @@ async function deployTrigger(arg, opts) {
   logsView,
   registryClear,
   registrySet,
+  resourcesSet,
+  resourcesView,
   servicesList,
   statusView
 });

package/dist/commands/remote.js

@@ -0,0 +1,203 @@
+"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 = (target, all) => {
+  for (var name in all)
+    __defProp(target, 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, target) => (target = 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(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remote_exports = {};
+__export(remote_exports, {
+  serverAdd: () => serverAdd,
+  serverList: () => serverList,
+  serverRemove: () => serverRemove,
+  serverTest: () => serverTest,
+  taskAdd: () => taskAdd,
+  taskList: () => taskList,
+  taskRemove: () => taskRemove,
+  taskRun: () => taskRun
+});
+module.exports = __toCommonJS(remote_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_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" });
+}
+async function serverList(opts) {
+  applyJson(opts);
+  requireAuth();
+  try {
+    const servers = await import_api.api.listServers();
+    (0, import_output.emit)({ count: servers.length, servers }, () => {
+      console.log(import_chalk.default.cyan(`
+  ${servers.length} server(s)
+`));
+      for (const s of servers) {
+        console.log(`  ${import_chalk.default.bold(s.name.padEnd(20))} ${import_chalk.default.dim(s.username + "@" + s.host + ":" + s.port)}  ${import_chalk.default.dim(s.authType)}  ${import_chalk.default.dim(s.taskCount + " task(s)")}`);
+        console.log(`  ${import_chalk.default.dim("  id: " + s.id)}`);
+      }
+      console.log();
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function serverAdd(opts) {
+  applyJson(opts);
+  requireAuth();
+  if (!opts?.name || !opts?.host) return (0, import_output.fail)("--name and --host are required.", { code: "bad_args" });
+  let authType = "password";
+  let secret = opts?.password;
+  if (opts?.keyFile) {
+    authType = "key";
+    try {
+      secret = fs.readFileSync(opts.keyFile, "utf-8");
+    } catch {
+      return (0, import_output.fail)(`Cannot read key file: ${opts.keyFile}`, { code: "file_not_found" });
+    }
+  }
+  if (!secret) return (0, import_output.fail)("Provide --password or --key-file.", { code: "bad_args" });
+  try {
+    const server = await import_api.api.createServer({
+      name: opts.name,
+      host: opts.host,
+      port: opts.port ? parseInt(opts.port, 10) : 22,
+      username: opts.user || "root",
+      authType,
+      secret,
+      passphrase: opts.passphrase
+    });
+    (0, import_output.ok)({ id: server.id, name: server.name, host: server.host }, () => {
+      console.log(import_chalk.default.green(`\u2713 server added`) + import_chalk.default.dim(`  ${server.id}`));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function serverRemove(id, opts) {
+  applyJson(opts);
+  requireAuth();
+  try {
+    await import_api.api.deleteServer(id);
+    (0, import_output.ok)({ id, deleted: true }, () => console.log(import_chalk.default.green("\u2713 server removed")));
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function serverTest(id, opts) {
+  applyJson(opts);
+  requireAuth();
+  try {
+    const r = await import_api.api.testServer(id);
+    (0, import_output.emit)(r, () => {
+      if (r.ok) console.log(import_chalk.default.green("\u2713 connection ok") + import_chalk.default.dim(`
+${r.message}`));
+      else console.log(import_chalk.default.red("\u2717 connection failed") + import_chalk.default.dim(`
+${r.message}`));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function taskList(serverId, opts) {
+  applyJson(opts);
+  requireAuth();
+  try {
+    const tasks = await import_api.api.listTasks(serverId);
+    (0, import_output.emit)({ serverId, count: tasks.length, tasks }, () => {
+      console.log(import_chalk.default.cyan(`
+  ${tasks.length} task(s)
+`));
+      for (const t of tasks) {
+        console.log(`  ${import_chalk.default.bold(t.name)}  ${import_chalk.default.dim("id: " + t.id)}`);
+        for (const s of t.steps || []) console.log(`    ${import_chalk.default.dim("-")} ${s.cwd ? import_chalk.default.dim("(" + s.cwd + ") ") : ""}${s.command}`);
+      }
+      console.log();
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function taskAdd(serverId, opts) {
+  applyJson(opts);
+  requireAuth();
+  if (!opts?.name) return (0, import_output.fail)("--name is required.", { code: "bad_args" });
+  const raw = Array.isArray(opts?.step) ? opts.step : opts?.step ? [opts.step] : [];
+  if (!raw.length) return (0, import_output.fail)('Provide at least one --step "command" (use "cwd::command" to set a directory).', { code: "bad_args" });
+  const steps = raw.map((r) => {
+    const idx = r.indexOf("::");
+    return idx === -1 ? { command: r } : { cwd: r.slice(0, idx), command: r.slice(idx + 2) };
+  });
+  try {
+    const task = await import_api.api.createTask(serverId, opts.name, steps);
+    (0, import_output.ok)({ id: task.id, name: task.name, steps: task.steps }, () => {
+      console.log(import_chalk.default.green(`\u2713 task created`) + import_chalk.default.dim(`  ${task.id}`));
+    });
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function taskRemove(taskId, opts) {
+  applyJson(opts);
+  requireAuth();
+  try {
+    await import_api.api.deleteTask(taskId);
+    (0, import_output.ok)({ taskId, deleted: true }, () => console.log(import_chalk.default.green("\u2713 task removed")));
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+async function taskRun(taskId, opts) {
+  applyJson(opts);
+  requireAuth();
+  try {
+    const r = await import_api.api.runTask(taskId);
+    (0, import_output.emit)({ runId: r.runId, ok: r.ok, status: r.status, exitCode: r.exitCode, steps: r.steps, output: r.output }, () => {
+      console.log(r.output);
+      console.log(r.ok ? import_chalk.default.green(`
+\u2713 ${r.status}`) : import_chalk.default.red(`
+\u2717 ${r.status} (exit ${r.exitCode})`));
+    });
+    if (!r.ok) process.exitCode = 1;
+  } catch (e) {
+    (0, import_output.fail)(e.message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serverAdd,
+  serverList,
+  serverRemove,
+  serverTest,
+  taskAdd,
+  taskList,
+  taskRemove,
+  taskRun
+});

package/dist/index.js

@@ -31,8 +31,9 @@ var import_open = require("./commands/open");
 var import_agent = require("./commands/agent");
 var import_workspace = require("./commands/workspace");
 var import_database = require("./commands/database");
+var import_remote = require("./commands/remote");
 const program = new import_commander.Command();
-program.name("dockup").description("Dockup CLI - Deploy from your terminal").version("1.0.0");
+program.name("dockup").description("Dockup CLI - Deploy from your terminal").version("1.3.0");
 program.command("login").description("Authenticate with Dockup").option("-t, --token <token>", "Use API token directly").action(import_auth.login);
 program.command("logout").description("Log out from Dockup").action(import_auth.logout);
 program.command("whoami").description("Show current logged in user").action(import_auth.whoami);
@@ -52,6 +53,8 @@ program.command("deployments [project/service]").alias("history").description("D
 const registryCmd = program.command("registry").description("Private registry auth for a private FROM base image");
 registryCmd.command("set [project/service]").description("Set registry credentials (used at build time to pull a private base image)").requiredOption("--url <registry>", "Registry host, e.g. ghcr.io").requiredOption("--user <username>", "Registry username").requiredOption("--token <token>", "PAT / password").option("-j, --json", "Machine-readable JSON output").action(import_agent.registrySet);
 registryCmd.command("clear [project/service]").description("Remove registry credentials").option("-j, --json", "Machine-readable JSON output").action(import_agent.registryClear);
+const resourcesCmd = program.command("resources [project/target]").alias("res").description("View reserved CPU/RAM (use `resources set` to change; --db for databases)").option("--db", "Target a database instead of a service").option("-j, --json", "Machine-readable JSON output").action(import_agent.resourcesView);
+resourcesCmd.command("set [project/target]").description("Set reserved CPU/RAM \u2014 PRO (max 24 vCPU / 24576 MB)").option("--cpu <vcpu>", "vCPU to reserve, e.g. 2").option("--memory <mb>", "RAM in MB to reserve, e.g. 4096").option("--db", "Target a database instead of a service").option("-j, --json", "Machine-readable JSON output").action(import_agent.resourcesSet);
 program.command("deploy [project/service]").description("Trigger a deployment (no git push; use `push` for git+deploy)").option("-b, --branch <branch>", "Branch to deploy").option("-j, --json", "Machine-readable JSON output").action(import_agent.deployTrigger);
 program.command("open").description("Open service in browser").option("-d, --dashboard", "Open dashboard instead of live URL").action(import_open.open);
 const workspaceCmd = program.command("workspace").alias("ws").description("Manage workspaces");
@@ -68,6 +71,15 @@ dbCmd.command("rename [id]").description("Rename a database").action(import_data
 dbCmd.command("delete [id]").alias("rm").description("Delete a database").action(import_database.databaseDelete);
 dbCmd.command("credentials [id]").alias("creds").description("Get database credentials").action(import_database.databaseCredentials);
 dbCmd.command("info [id]").description("Get database details").action(import_database.databaseInfo);
+const serverCmd = program.command("server").alias("srv").description("Remote servers & deploy tasks over SSH");
+serverCmd.command("list").alias("ls").description("List remote servers").option("-j, --json", "Machine-readable JSON output").action(import_remote.serverList);
+serverCmd.command("add").description("Add a remote server (use --password or --key-file)").requiredOption("--name <name>", "Friendly name").requiredOption("--host <host>", "IP or hostname").option("--port <port>", "SSH port", "22").option("--user <user>", "SSH username", "root").option("--password <password>", "SSH password").option("--key-file <path>", "Path to a private key file (PEM)").option("--passphrase <passphrase>", "Passphrase for the key, if any").option("-j, --json", "Machine-readable JSON output").action(import_remote.serverAdd);
+serverCmd.command("remove <serverId>").alias("rm").description("Remove a remote server").option("-j, --json", "Machine-readable JSON output").action(import_remote.serverRemove);
+serverCmd.command("test <serverId>").description("Test the SSH connection to a server").option("-j, --json", "Machine-readable JSON output").action(import_remote.serverTest);
+serverCmd.command("tasks <serverId>").description("List deploy tasks on a server").option("-j, --json", "Machine-readable JSON output").action(import_remote.taskList);
+serverCmd.command("task-add <serverId>").description('Create a deploy task. Repeat --step; use "cwd::command" to set a directory').requiredOption("--name <name>", "Task name").option("--step <command>", 'A step. Repeat for multiple. "cwd::command" sets the working dir', (v, acc) => acc.concat([v]), []).option("-j, --json", "Machine-readable JSON output").action(import_remote.taskAdd);
+serverCmd.command("task-remove <taskId>").description("Delete a deploy task").option("-j, --json", "Machine-readable JSON output").action(import_remote.taskRemove);
+serverCmd.command("run <taskId>").description("Run a deploy task over SSH (stops at the first failing step)").option("-j, --json", "Machine-readable JSON output").action(import_remote.taskRun);
 program.parse();
 if (!process.argv.slice(2).length) {
   console.log(import_chalk.default.cyan(`

package/dist/lib/api.js

@@ -238,6 +238,48 @@ class ApiClient {
   async clearRegistry(projectSlug, serviceSlug) {
     return this.delete(`/projects/${projectSlug}/services/${serviceSlug}/registry`);
   }
+  // ==================== RESOURCES (reserved CPU/RAM) ====================
+  // Database detail (project-scoped) — includes memoryLimitMB / cpuLimit.
+  async getDatabaseDetail(projectSlug, dbSlug) {
+    return this.get(`/projects/${projectSlug}/databases/${dbSlug}`);
+  }
+  // Set reserved CPU/RAM for a service (PRO). Applied by recreating the container.
+  async setServiceResources(projectSlug, serviceSlug, memoryLimit, cpuLimit) {
+    return this.post(`/projects/${projectSlug}/services/${serviceSlug}/resources`, { memoryLimit, cpuLimit });
+  }
+  // Set reserved CPU/RAM for a database (PRO, main-server only).
+  async setDatabaseResources(projectSlug, dbSlug, memoryLimitMB, cpuLimit) {
+    return this.post(`/projects/${projectSlug}/databases/${dbSlug}/resources`, { memoryLimitMB, cpuLimit });
+  }
+  // ==================== REMOTE SERVERS (SSH deploy hooks) ====================
+  async listServers() {
+    const res = await this.get("/remote/servers");
+    return res.servers || [];
+  }
+  async createServer(body) {
+    const res = await this.post("/remote/servers", body);
+    return res.server;
+  }
+  async deleteServer(id) {
+    return this.delete(`/remote/servers/${id}`);
+  }
+  async testServer(id) {
+    return this.post(`/remote/servers/${id}/test`);
+  }
+  async listTasks(serverId) {
+    const res = await this.get(`/remote/servers/${serverId}/tasks`);
+    return res.tasks || [];
+  }
+  async createTask(serverId, name, steps) {
+    const res = await this.post(`/remote/servers/${serverId}/tasks`, { name, steps });
+    return res.task;
+  }
+  async deleteTask(taskId) {
+    return this.delete(`/remote/tasks/${taskId}`);
+  }
+  async runTask(taskId) {
+    return this.post(`/remote/tasks/${taskId}/run`);
+  }
 }
 const api = new ApiClient();
 // Annotate the CommonJS export names for ESM import in node:

package/dockupcli.md

@@ -135,6 +135,61 @@ dockup registry clear my-project/my-api --json
 - `dockup info --json` shows `registryUrl`, `registryUsername` and
   `hasRegistryAuth` (the password is never exposed).
 
+### Resources (reserved CPU & RAM — PRO)
+
+Pick how much CPU and RAM a service or database reserves. Billing follows the
+allocation (≈ $20/vCPU + $10/GB per month + disk). Max **24 vCPU / 24576 MB**.
+
+```bash
+# View current allocation + estimated monthly cost
+dockup resources my-project/my-api --json
+# → {"target","kind":"service","name","cpu","memoryMB","estMonthlyUsd","limits":{"maxCpu":24,"maxMemMB":24576}}
+
+# Set (service). Applied live by recreating the container (no rebuild; data persists).
+dockup resources set my-project/my-api --cpu 2 --memory 4096 --json
+# → {"ok":true,"target","kind":"service","cpu","memoryMB","applied","estMonthlyUsd"}
+
+# Databases: add --db (main-server databases only; recreates the container, volume kept)
+dockup resources my-project/my-db --db --json
+dockup resources set my-project/my-db --db --cpu 1 --memory 2048 --json
+```
+
+- `--cpu` is vCPU (e.g. `0.5`, `2`, `8`); `--memory` is MB (e.g. `512`, `4096`).
+- Values out of range are clamped to `[0.5 vCPU, 512 MB] … [24 vCPU, 24576 MB]`.
+- PRO only — non-PRO accounts get `403 Upgrade required`.
+- `applied:true` means a running container was recreated immediately; otherwise
+  it applies on the next deploy (service) / start (database).
+- `dockup info --json` also surfaces a service's current `memoryLimit`/`cpuLimit`.
+
+### Remote servers (SSH deploy hooks)
+
+Run deploy steps on **your own** servers over SSH — `git pull`, `npm run build`,
+`pm2 restart`, `plesk ext git --deploy`. Credentials are stored encrypted.
+
+```bash
+# Register a server (password or --key-file)
+dockup server add --name "plesk-prod" --host 94.130.67.75 --user root --password "$PW" --json
+dockup server add --name "prod" --host 1.2.3.4 --key-file ~/.ssh/id_ed25519 --json
+dockup server list --json
+dockup server test <serverId> --json        # opens an SSH connection and runs whoami
+
+# Create a deploy task — each --step is a command; "cwd::command" sets the directory
+dockup server task-add <serverId> --name "Deploy frontend" \
+  --step "plesk ext git --deploy -domain new.dockup.ai -name deploy-new-frontend.git" \
+  --step "/var/www/vhosts/dockup.ai/new.dockup.ai::npm install && npm run build && pm2 restart doknew" \
+  --json
+dockup server tasks <serverId> --json
+
+# Run it (executes steps in order, stops at the first failing step)
+dockup server run <taskId> --json
+# → {"runId","ok":true,"status":"success","exitCode":0,"steps":[...],"output":"...full log..."}
+```
+
+- Steps run via `bash -lc` so `npm`/`pm2`/`plesk` are on PATH; `cwd` fixes the
+  "ran in /root" problem — set it per step.
+- `run` stops at the first non-zero exit and returns the combined output.
+- Manage the same servers/tasks visually in the dashboard → **Servers**.
+
 ---
 
 ## Agent recipes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dockup-cli",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Dockup CLI - deploy, env, logs, registry & more from your terminal (agent-friendly --json)",
   "main": "dist/index.js",
   "bin": {