dockup-cli 1.2.0 → 1.3.1

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.2.0");
+program.name("dockup").description("Dockup CLI - Deploy from your terminal").version("1.3.1");
 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);
@@ -70,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

@@ -61,7 +61,10 @@ class ApiClient {
     const response = await (0, import_node_fetch.default)(url, {
       method: "POST",
       headers: this.getHeaders(),
-      body: body ? JSON.stringify(body) : void 0
+      // getHeaders() always sets Content-Type: application/json, so the body
+      // must be valid JSON even for no-body POSTs (test/run) — else Fastify
+      // rejects the empty body with 400.
+      body: JSON.stringify(body ?? {})
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({}));
@@ -251,6 +254,35 @@ class ApiClient {
   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

@@ -161,6 +161,35 @@ dockup resources set my-project/my-db --db --cpu 1 --memory 2048 --json
   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.2.0",
+  "version": "1.3.1",
   "description": "Dockup CLI - deploy, env, logs, registry & more from your terminal (agent-friendly --json)",
   "main": "dist/index.js",
   "bin": {