deploysapp-cli 0.1.0

package/README.md

@@ -0,0 +1,163 @@
+# deploysapp-cli
+
+Command-line interface for [DeploysApp](https://deploysapp.com) — deploy, manage, and monitor your services from the terminal.
+
+```
+npm install -g deploysapp-cli
+```
+
+Requires **Node >= 20**.
+
+Binary names: `deploysapp` and `dsa` (short alias).
+
+---
+
+## Quick start
+
+```sh
+deploysapp login          # authenticate this device (opens browser)
+deploysapp link           # bind the current directory to a service
+deploysapp deploy         # redeploy from git and stream the build log
+```
+
+---
+
+## Authentication
+
+### Interactive (recommended for local dev)
+
+```sh
+deploysapp login
+```
+
+Opens a browser-based device-code flow. Credentials are saved to `~/.deploysapp/config.json` (mode 0600).
+
+```sh
+deploysapp logout         # remove stored credentials
+deploysapp whoami         # print the authenticated account
+```
+
+### CI / headless environments
+
+Skip `login` entirely — set env vars instead:
+
+```sh
+export DEPLOYSAPP_API_KEY=dsa_xxxxxxxxxxxx
+# optional: point at a self-hosted API
+export DEPLOYSAPP_API_URL=https://api.your-instance.example.com
+```
+
+`DEPLOYSAPP_API_KEY` takes precedence over the stored config file.
+
+---
+
+## The `.deploysapp.json` link file
+
+Running `deploysapp link` (or `dsa link`) writes a `.deploysapp.json` file in the current directory that records the service (and project) id:
+
+```json
+{
+  "serviceId": "svc_abc123",
+  "projectId": "proj_xyz789"
+}
+```
+
+All commands that operate on a specific service read this file automatically. You can override it at any time with the `--service <id>` flag.
+
+---
+
+## Command reference
+
+### Auth
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `login [--no-open]` | Authenticate this device via browser | `dsa login` |
+| `logout` | Remove stored credentials | `dsa logout` |
+| `whoami` | Print the currently authenticated account | `dsa whoami` |
+
+### Linking
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `link [--service <id>]` | Bind the current directory to a service (writes `.deploysapp.json`) | `dsa link` |
+
+### Deployment
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `deploy [--service <id>]` | Trigger a redeploy from git and stream the build log | `dsa deploy --service svc_abc123` |
+
+### Logs
+
+```
+logs [--service <id>] [-f] [--build | --runtime] [--tail <n>]
+```
+
+| Flag | Description |
+|------|-------------|
+| `--service <id>` | Target service (overrides `.deploysapp.json`) |
+| `--build` | Show the latest build log |
+| `--runtime` | Show runtime logs (default) |
+| `-f, --follow` | Follow (stream) runtime logs |
+| `--tail <n>` | Lines of history to show (default: 200) |
+
+Examples:
+
+```sh
+dsa logs                        # last 200 lines of runtime logs
+dsa logs --build                # latest build log
+dsa logs -f                     # follow runtime logs live
+dsa logs -f --tail 50           # follow, starting from last 50 lines
+```
+
+### Service lifecycle
+
+All service commands accept `--service <id>` to override `.deploysapp.json`.
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `ps` | List all services and their current status | `dsa ps` |
+| `restart [--service <id>]` | Restart a service | `dsa restart` |
+| `stop [--service <id>]` | Stop a service | `dsa stop --service svc_abc123` |
+| `start [--service <id>]` | Start a stopped service | `dsa start` |
+| `open [--service <id>]` | Open the service URL in the browser | `dsa open` |
+| `scale --replicas <n> [--service <id>]` | Set the replica count | `dsa scale --replicas 3` |
+
+### Environment variables
+
+All `env` subcommands accept `--service <id>`.
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `env list` | List all env vars for a service | `dsa env list` |
+| `env get <key>` | Print the value of a single env var | `dsa env get DATABASE_URL` |
+| `env set <KEY=VALUE> [--restart]` | Set an env var (optionally restart) | `dsa env set PORT=3000 --restart` |
+| `env rm <key> [--restart]` | Delete an env var (optionally restart) | `dsa env rm OLD_VAR --restart` |
+
+### Secrets
+
+Project-scoped secrets can be attached to a service as an env var.
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `secret list [--project <id>]` | List secrets for a project | `dsa secret list` |
+| `secret attach <name> --as <ENV_KEY> [--project <id>] [--service <id>]` | Expose a secret to a service as an env var | `dsa secret attach db-password --as DATABASE_PASSWORD` |
+
+---
+
+## Configuration reference
+
+| Source | Key | Default |
+|--------|-----|---------|
+| Env var | `DEPLOYSAPP_API_KEY` | — |
+| Env var | `DEPLOYSAPP_API_URL` | `https://api.deploysapp.com` |
+| File | `~/.deploysapp/config.json` | written by `login` |
+
+Environment variables always take precedence over the config file.
+
+---
+
+## License
+
+ISC

package/bin/deploysapp.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { whoami, login, logout } from "../src/commands/auth.js";
+import { link } from "../src/commands/link.js";
+import { deploy } from "../src/commands/deploy.js";
+import { logs } from "../src/commands/logs.js";
+import { ps, restart, stop, start, scale, open } from "../src/commands/service.js";
+import { envList, envGet, envSet, envRm } from "../src/commands/env.js";
+import { secretList, secretAttach } from "../src/commands/secret.js";
+import { printErr } from "../src/output.js";
+
+const program = new Command();
+program.name("deploysapp").description("DeploysApp CLI").version("0.1.0");
+
+function wrap(fn) {
+  return async (...args) => { try { await fn(...args); } catch (e) { printErr(e); } };
+}
+
+program.command("whoami").description("Show the authenticated account").action(wrap(whoami));
+
+program.command("login").description("Authenticate this device")
+  .option("--no-open", "don't auto-open the browser")
+  .action(wrap((opts) => login({ open: opts.open })));
+program.command("logout").description("Remove stored credentials").action(wrap(logout));
+
+program.command("link").description("Bind the current directory to a service")
+  .option("--service <id>", "service id (skip the prompt)")
+  .action(wrap((opts) => link({ service: opts.service })));
+
+program.command("deploy").description("Trigger a redeploy from git and stream the build log")
+  .option("--service <id>", "service id")
+  .action(wrap((opts) => deploy({ service: opts.service })));
+
+program.command("logs").description("Show build or runtime logs")
+  .option("--service <id>", "service id")
+  .option("-f, --follow", "follow runtime logs")
+  .option("--build", "show the latest build log instead of runtime")
+  .option("--runtime", "show runtime logs (default)")
+  .option("--tail <n>", "lines of runtime history", "200")
+  .action(wrap((opts) => logs({ service: opts.service, follow: opts.follow, build: opts.build, runtime: opts.runtime, tail: opts.tail })));
+
+program.command("ps").description("List services and their status").action(wrap(() => ps()));
+
+const svcOpt = (c) => c.option("--service <id>", "service id");
+svcOpt(program.command("restart").description("Restart a service")).action(wrap((o) => restart(o)));
+svcOpt(program.command("stop").description("Stop a service")).action(wrap((o) => stop(o)));
+svcOpt(program.command("start").description("Start a service")).action(wrap((o) => start(o)));
+svcOpt(program.command("open").description("Open the service URL")).action(wrap((o) => open(o)));
+svcOpt(program.command("scale").description("Set the replica count"))
+  .requiredOption("--replicas <n>", "number of replicas")
+  .action(wrap((o) => scale(o)));
+
+const env = program.command("env").description("Manage environment variables");
+env.command("list").option("--service <id>").action(wrap((o) => envList(o)));
+env.command("get <key>").option("--service <id>").action(wrap((key, o) => envGet({ ...o, key })));
+env.command("set <pair>").option("--service <id>").option("--restart", "restart after setting")
+  .action(wrap((pair, o) => envSet({ ...o, pair })));
+env.command("rm <key>").option("--service <id>").option("--restart", "restart after removing")
+  .action(wrap((key, o) => envRm({ ...o, key })));
+
+const secret = program.command("secret").description("Manage project secrets");
+secret.command("list")
+  .description("List secrets for a project")
+  .option("--project <id>", "project id")
+  .action(wrap((o) => secretList(o)));
+secret.command("attach <name>")
+  .description("Expose a project secret to a service as an env var")
+  .requiredOption("--as <ENV_KEY>", "environment variable name")
+  .option("--project <id>", "project id")
+  .option("--service <id>", "service id")
+  .action(wrap((name, o) => secretAttach({ ...o, name })));
+
+program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "deploysapp-cli",
+  "version": "0.1.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "vitest run"
+  },
+  "keywords": [
+    "deploysapp",
+    "cli",
+    "hosting",
+    "deployment"
+  ],
+  "author": "",
+  "license": "MIT",
+  "description": "Command-line client for the DeploysApp hosting platform — deploy, logs, env, and service control from your terminal.",
+  "type": "module",
+  "bin": {
+    "deploysapp": "bin/deploysapp.js",
+    "dsa": "bin/deploysapp.js"
+  },
+  "dependencies": {
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.9"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ]
+}

package/src/client.js

@@ -0,0 +1,128 @@
+const DEFAULT_BASE_URL = "https://api.deploysapp.com";
+
+const ERROR_CODES = {
+  UNAUTHORIZED: { retryable: false },
+  PERMISSION_DENIED: { retryable: false },
+  NOT_FOUND: { retryable: false },
+  VALIDATION_ERROR: { retryable: false },
+  CONFLICT: { retryable: false },
+  RATE_LIMITED: { retryable: true },
+  SERVER_ERROR: { retryable: true },
+  NETWORK_ERROR: { retryable: true },
+  INVALID_CONFIG: { retryable: false },
+  UNKNOWN_ERROR: { retryable: false },
+};
+
+function codeForStatus(status) {
+  if (status === 401) return "UNAUTHORIZED";
+  if (status === 403) return "PERMISSION_DENIED";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "CONFLICT";
+  if (status === 400 || status === 422) return "VALIDATION_ERROR";
+  if (status === 429) return "RATE_LIMITED";
+  if (status >= 500) return "SERVER_ERROR";
+  return "UNKNOWN_ERROR";
+}
+
+export class DeploysAppError extends Error {
+  constructor({ code, message, status, retryAfter, details }) {
+    super(message);
+    this.name = "DeploysAppError";
+    this.code = code;
+    this.status = status ?? null;
+    this.retryable = ERROR_CODES[code]?.retryable ?? false;
+    this.retryAfter = retryAfter ?? null;
+    this.details = details ?? null;
+  }
+
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        status: this.status,
+        retryable: this.retryable,
+        ...(this.retryAfter ? { retry_after_seconds: this.retryAfter } : {}),
+        ...(this.details ? { details: this.details } : {}),
+      },
+    };
+  }
+}
+
+export class DeploysAppClient {
+  constructor({ apiKey, baseUrl } = {}) {
+    this.apiKey = apiKey || process.env.DEPLOYSAPP_API_KEY;
+    this.baseUrl = (baseUrl || process.env.DEPLOYSAPP_API_URL || DEFAULT_BASE_URL).replace(/\/$/, "");
+    if (!this.apiKey) {
+      throw new DeploysAppError({
+        code: "INVALID_CONFIG",
+        message: "Missing DEPLOYSAPP_API_KEY environment variable. Generate one at https://dashboard.deploysapp.com/dashboard/account → API Keys.",
+      });
+    }
+    if (!/^dsa_/.test(this.apiKey)) {
+      throw new DeploysAppError({
+        code: "INVALID_CONFIG",
+        message: "DEPLOYSAPP_API_KEY must start with 'dsa_' — looks like an invalid key.",
+      });
+    }
+  }
+
+  async request(method, path, { body, query } = {}) {
+    let url = `${this.baseUrl}${path}`;
+    if (query && Object.keys(query).length > 0) {
+      const qs = new URLSearchParams(query).toString();
+      url += `?${qs}`;
+    }
+
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Accept": "application/json",
+      "User-Agent": "deploysapp-mcp/0.6.1",
+    };
+    if (body !== undefined) headers["Content-Type"] = "application/json";
+
+    let res;
+    try {
+      res = await fetch(url, {
+        method,
+        headers,
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+      });
+    } catch (cause) {
+      throw new DeploysAppError({
+        code: "NETWORK_ERROR",
+        message: `Network error contacting DeploysApp API at ${this.baseUrl}: ${cause?.message || cause}`,
+        details: { cause: cause?.message || String(cause) },
+      });
+    }
+
+    const text = await res.text();
+    let data;
+    try { data = text ? JSON.parse(text) : null; } catch { data = text; }
+
+    if (!res.ok) {
+      const code = codeForStatus(res.status);
+      const apiMessage =
+        (data && typeof data === "object" && (data.message || data.error)) ||
+        (typeof data === "string" && data) ||
+        res.statusText ||
+        "Unknown error";
+      const retryAfterHeader = res.headers.get("retry-after");
+      const retryAfter = retryAfterHeader ? Number(retryAfterHeader) : null;
+      throw new DeploysAppError({
+        code,
+        message: `${method} ${path} → ${res.status} ${code}: ${apiMessage}`,
+        status: res.status,
+        retryAfter: Number.isFinite(retryAfter) ? retryAfter : null,
+        details: typeof data === "object" ? data : { raw: data },
+      });
+    }
+
+    return data;
+  }
+
+  get(path, query) { return this.request("GET", path, { query }); }
+  post(path, body) { return this.request("POST", path, { body }); }
+  patch(path, body) { return this.request("PATCH", path, { body }); }
+  delete(path) { return this.request("DELETE", path); }
+}

package/src/commands/auth.js

@@ -0,0 +1,90 @@
+// src/commands/auth.js
+import { execFile } from "child_process";
+import { makeClient, saveConfig, clearConfig, loadConfig } from "../config.js";
+
+export async function whoami() {
+  const client = makeClient();
+  const me = await client.get("/me");
+  const email = me?.user?.email || me?.email || "(unknown)";
+  console.log(email);
+}
+
+const API_URL = () => loadConfig().apiUrl;
+
+export function pollForToken(fetchFn, { intervalMs = 5000, maxMs = 600000 } = {}) {
+  const deadline = Date.now() + maxMs;
+  return new Promise((resolve, reject) => {
+    const tick = async () => {
+      let r;
+      try {
+        r = await fetchFn();
+      } catch (e) {
+        // Transient network error mid-poll — retry until the deadline instead of
+        // failing the whole login on a single blip.
+        if (Date.now() > deadline) {
+          const err = new Error("Login timed out.");
+          err.exitCode = 3;
+          return reject(err);
+        }
+        return setTimeout(tick, intervalMs);
+      }
+      if (r.status === 200 && r.body?.api_key) return resolve(r.body.api_key);
+      const err = r.body?.error;
+      if (err === "authorization_pending") {
+        if (Date.now() > deadline) {
+          const e = new Error("Login timed out.");
+          e.exitCode = 3;
+          return reject(e);
+        }
+        return setTimeout(tick, intervalMs);
+      }
+      if (err === "expired_token") {
+        const e = new Error("Code expired — run `deploysapp login` again.");
+        e.exitCode = 3;
+        return reject(e);
+      }
+      if (err === "access_denied") return reject(new Error("Login was denied."));
+      return reject(new Error(err || "Login failed."));
+    };
+    tick();
+  });
+}
+
+function openBrowser(url) {
+  if (process.platform === "darwin") return execFile("open", [url], () => {});
+  if (process.platform === "win32") return execFile("cmd", ["/c", "start", "", url], () => {});
+  return execFile("xdg-open", [url], () => {});
+}
+
+export async function login({ open = true } = {}) {
+  const base = API_URL();
+  const startRes = await fetch(`${base}/cli/device/code`, { method: "POST" });
+  if (!startRes.ok) {
+    const err = new Error(`Could not start login (server returned ${startRes.status}). Try again later.`);
+    err.exitCode = 3;
+    throw err;
+  }
+  const start = await startRes.json();
+  console.log(`\n  To authorize this device, visit:\n    ${start.verification_uri}\n  and enter the code:\n\n    ${start.user_code}\n`);
+  if (open) openBrowser(start.verification_uri);
+
+  const apiKey = await pollForToken(
+    async () => {
+      const res = await fetch(`${base}/cli/device/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code: start.device_code }),
+      });
+      return { status: res.status, body: await res.json().catch(() => ({})) };
+    },
+    { intervalMs: (start.interval || 5) * 1000, maxMs: (start.expires_in || 600) * 1000 }
+  );
+
+  saveConfig({ apiKey });
+  console.log("✓ Logged in.");
+}
+
+export async function logout() {
+  clearConfig();
+  console.log("✓ Logged out.");
+}

package/src/commands/deploy.js

@@ -0,0 +1,33 @@
+// src/commands/deploy.js
+import { makeClient } from "../config.js";
+import { resolveServiceId } from "../project.js";
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export async function streamBuild(client, buildId, { sleep = (ms) => wait(ms), onLine = (l) => console.log(l), maxMs = 3600000, now = () => Date.now() } = {}) {
+  let cursor = 0;
+  const deadline = now() + maxMs;
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const page = await client.get(`/builds/${encodeURIComponent(buildId)}/logs?since=${cursor}`);
+    for (const line of page.lines || []) onLine(line);
+    if (typeof page.nextCursor === "number") cursor = page.nextCursor;
+    if (page.done) return page.build?.status || "unknown";
+    if (now() > deadline) {
+      onLine("[deploy] Stopped tailing after timeout; the build may still be running. Check the dashboard.");
+      return "timeout";
+    }
+    await sleep(2000);
+  }
+}
+
+export async function deploy({ service } = {}) {
+  const client = makeClient();
+  const serviceId = resolveServiceId({ flag: service });
+  const { build } = await client.post(`/services/${encodeURIComponent(serviceId)}/redeploy`);
+  if (!build?.id) { const e = new Error("Redeploy did not return a build. Check the service has a connected git repo."); e.exitCode = 3; throw e; }
+  console.log(`Build ${build.id} queued. Streaming logs…\n`);
+  const status = await streamBuild(client, build.id);
+  if (status === "success") { console.log("\n✓ Deploy succeeded."); }
+  else { console.error(`\n✗ Deploy ${status}.`); process.exitCode = 1; }
+}

package/src/commands/env.js

@@ -0,0 +1,54 @@
+// src/commands/env.js
+import { makeClient } from "../config.js";
+import { resolveServiceId } from "../project.js";
+
+export function parseKeyValue(pair) {
+  const idx = (pair || "").indexOf("=");
+  if (idx <= 0) { const e = new Error("Expected KEY=VALUE."); e.exitCode = 2; throw e; }
+  return { key: pair.slice(0, idx), value: pair.slice(idx + 1) };
+}
+
+async function fetchEnv(client, id) {
+  const data = await client.get(`/services/${encodeURIComponent(id)}/env`);
+  return data.env || data.envVars || (Array.isArray(data) ? data : []);
+}
+
+export async function envList({ service } = {}) {
+  const client = makeClient();
+  const id = resolveServiceId({ flag: service });
+  const env = await fetchEnv(client, id);
+  if (!env.length) { console.log("No env vars set."); return; }
+  for (const e of env) console.log(`${e.key}=${e.value}`);
+}
+
+export async function envGet({ service, key } = {}) {
+  const client = makeClient();
+  const id = resolveServiceId({ flag: service });
+  const env = await fetchEnv(client, id);
+  const hit = env.find((e) => e.key === key);
+  if (!hit) { const e = new Error(`No env var named ${key}.`); e.exitCode = 2; throw e; }
+  console.log(hit.value);
+}
+
+export async function envSet({ service, pair, restart } = {}) {
+  const client = makeClient();
+  const id = resolveServiceId({ flag: service });
+  const { key, value } = parseKeyValue(pair);
+  const env = await fetchEnv(client, id);
+  const existing = env.find((e) => e.key === key);
+  const q = restart ? "?restart=true" : "";
+  if (existing) await client.patch(`/services/${encodeURIComponent(id)}/env/${existing.id}${q}`, { key, value });
+  else await client.post(`/services/${encodeURIComponent(id)}/env${q}`, { key, value });
+  console.log(`✓ Set ${key}${restart ? " (restarted)" : ""}.`);
+}
+
+export async function envRm({ service, key, restart } = {}) {
+  const client = makeClient();
+  const id = resolveServiceId({ flag: service });
+  const env = await fetchEnv(client, id);
+  const existing = env.find((e) => e.key === key);
+  if (!existing) { const e = new Error(`No env var named ${key}.`); e.exitCode = 2; throw e; }
+  const q = restart ? "?restart=true" : "";
+  await client.delete(`/services/${encodeURIComponent(id)}/env/${existing.id}${q}`);
+  console.log(`✓ Removed ${key}.`);
+}

package/src/commands/link.js

@@ -0,0 +1,24 @@
+import { createInterface } from "readline/promises";
+import { makeClient } from "../config.js";
+import { saveProject } from "../project.js";
+
+export async function link({ service } = {}) {
+  const client = makeClient();
+  const { services } = await client.get("/services");
+  if (!services?.length) { console.log("No services found. Create one in the dashboard first."); return; }
+
+  let chosen;
+  if (service) {
+    chosen = services.find((s) => s.id === service);
+    if (!chosen) { const e = new Error(`Service ${service} not found.`); e.exitCode = 2; throw e; }
+  } else {
+    services.forEach((s, i) => console.log(`  [${i + 1}] ${s.name}  (${s.id})  ${s.host || ""}`));
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question("Select a service: ");
+    rl.close();
+    chosen = services[Number(answer) - 1];
+    if (!chosen) { const e = new Error("Invalid selection."); e.exitCode = 2; throw e; }
+  }
+  saveProject({ serviceId: chosen.id, projectId: chosen.projectId });
+  console.log(`✓ Linked to ${chosen.name} (${chosen.id}). Wrote .deploysapp.json`);
+}

package/src/commands/logs.js

@@ -0,0 +1,34 @@
+// src/commands/logs.js
+import { makeClient } from "../config.js";
+import { resolveServiceId } from "../project.js";
+import { streamBuild } from "./deploy.js";
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export async function tailRuntime(client, serviceId, { follow = false, tail = 200, sleep = (ms) => wait(ms), onLine = (l) => console.log(l) } = {}) {
+  let since = 0;
+  const first = await client.get(`/services/${encodeURIComponent(serviceId)}/logs?tail=${tail}`);
+  for (const l of first.lines || []) onLine(l);
+  since = first.ts ?? since;
+  if (!follow) return;
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    await sleep(2000);
+    const page = await client.get(`/services/${encodeURIComponent(serviceId)}/logs?since=${since}`);
+    for (const l of page.lines || []) onLine(l);
+    since = page.ts ?? since;
+  }
+}
+
+export async function logs({ service, follow, build, runtime, tail } = {}) {
+  const client = makeClient();
+  const serviceId = resolveServiceId({ flag: service });
+  const wantBuild = build && !runtime;
+  if (wantBuild) {
+    const { builds } = await client.get(`/services/${encodeURIComponent(serviceId)}/builds`);
+    if (!builds?.length) { console.log("No builds yet."); return; }
+    await streamBuild(client, builds[0].id);
+    return;
+  }
+  await tailRuntime(client, serviceId, { follow: !!follow, tail: Number(tail) || 200 });
+}

package/src/commands/secret.js

@@ -0,0 +1,43 @@
+// src/commands/secret.js
+import { makeClient } from "../config.js";
+import { resolveServiceId, loadProject } from "../project.js";
+
+export function resolveProjectId({ flag } = {}) {
+  if (flag) return flag;
+  const p = loadProject();
+  if (p?.projectId) return p.projectId;
+  const err = new Error("No project selected. Pass --project <id> or run `deploysapp link`.");
+  err.exitCode = 2;
+  throw err;
+}
+
+async function fetchSecrets(client, projectId) {
+  const data = await client.get(`/projects/${encodeURIComponent(projectId)}/secrets`);
+  return data.secrets || (Array.isArray(data) ? data : []);
+}
+
+export async function secretList({ project } = {}) {
+  const client = makeClient();
+  const projectId = resolveProjectId({ flag: project });
+  const secrets = await fetchSecrets(client, projectId);
+  if (!secrets.length) { console.log("No secrets."); return; }
+  for (const s of secrets) console.log(`${s.name}  ${s.id}`);
+}
+
+export async function secretAttach({ project, service, name, as: envKey } = {}) {
+  const client = makeClient();
+  const projectId = resolveProjectId({ flag: project });
+  const serviceId = resolveServiceId({ flag: service });
+  const secrets = await fetchSecrets(client, projectId);
+  const secret = secrets.find((s) => s.name === name || s.id === name);
+  if (!secret) {
+    const err = new Error(`No secret named or with id "${name}".`);
+    err.exitCode = 2;
+    throw err;
+  }
+  await client.post(`/services/${encodeURIComponent(serviceId)}/secret-refs`, {
+    secretId: secret.id,
+    envKey,
+  });
+  console.log(`✓ Attached secret "${secret.name}" as ${envKey}.`);
+}

package/src/commands/service.js

@@ -0,0 +1,49 @@
+// src/commands/service.js
+import { execFile } from "child_process";
+import { makeClient } from "../config.js";
+import { resolveServiceId } from "../project.js";
+
+export function formatServicesTable(services) {
+  if (!services?.length) return "No services found.";
+  const rows = services.map((s) => [s.name || "", s.status || "", s.host || ""]);
+  const widths = [0, 1, 2].map((c) => Math.max(...rows.map((r) => r[c].length), ["NAME", "STATUS", "HOST"][c].length));
+  const fmt = (r) => r.map((v, c) => v.padEnd(widths[c])).join("  ");
+  return [fmt(["NAME", "STATUS", "HOST"]), ...rows.map(fmt)].join("\n");
+}
+
+export async function ps() {
+  const client = makeClient();
+  const { services } = await client.get("/services");
+  console.log(formatServicesTable(services));
+}
+
+async function lifecycle(action, service) {
+  const client = makeClient();
+  const id = resolveServiceId({ flag: service });
+  await client.post(`/services/${encodeURIComponent(id)}/${action}`);
+  console.log(`✓ ${action} requested for ${id}.`);
+}
+export const restart = ({ service } = {}) => lifecycle("restart", service);
+export const stop = ({ service } = {}) => lifecycle("stop", service);
+export const start = ({ service } = {}) => lifecycle("start", service);
+
+export async function scale({ service, replicas } = {}) {
+  const client = makeClient();
+  const id = resolveServiceId({ flag: service });
+  const n = Number(replicas);
+  if (!Number.isInteger(n) || n < 1 || n > 10) { const e = new Error("--replicas must be 1-10."); e.exitCode = 2; throw e; }
+  await client.patch(`/services/${encodeURIComponent(id)}/scale`, { replicas: n });
+  console.log(`✓ Scaled ${id} to ${n} replica(s).`);
+}
+
+export async function open({ service } = {}) {
+  const client = makeClient();
+  const id = resolveServiceId({ flag: service });
+  const { service: svc } = await client.get(`/services/${encodeURIComponent(id)}`);
+  const url = svc?.host ? `https://${svc.host}` : null;
+  if (!url) { const e = new Error("Service has no public host."); e.exitCode = 2; throw e; }
+  console.log(url);
+  if (process.platform === "darwin") return execFile("open", [url], () => {});
+  if (process.platform === "win32") return execFile("cmd", ["/c", "start", "", url], () => {});
+  return execFile("xdg-open", [url], () => {});
+}

package/src/config.js

@@ -0,0 +1,41 @@
+// src/config.js
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, readFileSync, writeFileSync, chmodSync, rmSync, existsSync } from "fs";
+import { DeploysAppClient } from "./client.js";
+
+function configHome() {
+  return process.env.DEPLOYSAPP_CONFIG_HOME || join(homedir(), ".deploysapp");
+}
+function configPath() { return join(configHome(), "config.json"); }
+
+export function saveConfig({ apiKey }) {
+  mkdirSync(configHome(), { recursive: true });
+  writeFileSync(configPath(), JSON.stringify({ apiKey }, null, 2), { mode: 0o600 });
+  chmodSync(configPath(), 0o600);
+}
+
+export function loadConfig() {
+  const fileKey = (() => {
+    try { return JSON.parse(readFileSync(configPath(), "utf8")).apiKey || null; }
+    catch { return null; }
+  })();
+  return {
+    apiKey: process.env.DEPLOYSAPP_API_KEY || fileKey,
+    apiUrl: process.env.DEPLOYSAPP_API_URL || "https://api.deploysapp.com",
+  };
+}
+
+export function clearConfig() {
+  if (existsSync(configPath())) rmSync(configPath());
+}
+
+export function makeClient() {
+  const { apiKey, apiUrl } = loadConfig();
+  if (!apiKey) {
+    const err = new Error("Not logged in. Run `deploysapp login`.");
+    err.exitCode = 1;
+    throw err;
+  }
+  return new DeploysAppClient({ apiKey, baseUrl: apiUrl });
+}

package/src/output.js

@@ -0,0 +1,7 @@
+// src/output.js
+export function printJson(obj) { console.log(JSON.stringify(obj, null, 2)); }
+export function printErr(err) {
+  const code = err?.exitCode ?? (err?.code === "UNAUTHORIZED" ? 1 : err?.retryable ? 3 : 2);
+  console.error(`error: ${err?.message || err}`);
+  process.exitCode = code;
+}

package/src/project.js

@@ -0,0 +1,20 @@
+import { join } from "path";
+import { readFileSync, writeFileSync } from "fs";
+
+const FILE = ".deploysapp.json";
+function path() { return join(process.cwd(), FILE); }
+
+export function saveProject({ serviceId, projectId }) {
+  writeFileSync(path(), JSON.stringify({ serviceId, projectId }, null, 2));
+}
+export function loadProject() {
+  try { return JSON.parse(readFileSync(path(), "utf8")); } catch { return null; }
+}
+export function resolveServiceId({ flag } = {}) {
+  if (flag) return flag;
+  const p = loadProject();
+  if (p?.serviceId) return p.serviceId;
+  const err = new Error("No service selected. Pass --service <id> or run `deploysapp link`.");
+  err.exitCode = 2;
+  throw err;
+}