deploro 0.5.1 → 0.6.0

package/dist/index.js

@@ -148,6 +148,88 @@ async function logoutCommand() {
   console.log("\u2713 Logged out \u2014 local credentials cleared");
 }
 
+// src/commands/export.ts
+import { createWriteStream, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+function authHeaders(config) {
+  return {
+    Authorization: `Bearer ${config.accessToken}`,
+    "x-project-id": config.projectId
+  };
+}
+async function throwOnError(res) {
+  if (res.ok) return;
+  const body = await res.json().catch(() => ({ error: res.statusText }));
+  throw new Error(`${res.status} ${body.error ?? res.statusText}`);
+}
+async function exportCommand(opts) {
+  const config = requireProject();
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const outPath = opts.out ?? `deploro-export-${stamp}.ndjson`;
+  const url = new URL(`${config.baseUrl}/api/projects/${config.projectId}/export`);
+  if (opts.skipStorage) url.searchParams.set("storage", "false");
+  console.log(`Exporting to ${outPath} \u2026`);
+  const res = await fetch(url, { headers: authHeaders(config) });
+  await throwOnError(res);
+  if (!res.body) throw new Error("Export returned an empty response");
+  mkdirSync2(dirname2(outPath) || ".", { recursive: true });
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(outPath));
+  const { readFileSync: readFileSync4 } = await import("fs");
+  const lines = readFileSync4(outPath, "utf8").split("\n").filter(Boolean);
+  const last = lines.length ? JSON.parse(lines[lines.length - 1]) : null;
+  if (!last || last.type !== "end") {
+    throw new Error(
+      `Export did not finish cleanly \u2014 ${outPath} is incomplete (last record: ${last?.type ?? "none"}). Re-run it.`
+    );
+  }
+  console.log(`Wrote ${outPath}: ${last.rows ?? 0} rows across ${last.tables ?? 0} tables`);
+  if (last.errors?.length) {
+    console.log("\nSome parts could not be exported:");
+    for (const err of last.errors) console.log(`  - ${err}`);
+  }
+  if (!opts.storage) {
+    const objects = lines.filter((l) => l.includes('"type":"storage"')).length;
+    if (objects > 0) {
+      console.log(
+        `
+${objects} stored file(s) are listed by key only. Re-run with --storage <dir> to download their contents.`
+      );
+    }
+    return;
+  }
+  const keys = lines.map((l) => JSON.parse(l)).filter((r) => r.type === "storage");
+  if (keys.length === 0) {
+    console.log("\nNo stored files to download.");
+    return;
+  }
+  console.log(`
+Downloading ${keys.length} file(s) to ${opts.storage} \u2026`);
+  let downloaded = 0;
+  const failures = [];
+  for (const object of keys) {
+    const target = join2(opts.storage, object.key);
+    try {
+      const fileRes = await fetch(
+        `${config.baseUrl}/api/projects/${config.projectId}/storage/download?key=${encodeURIComponent(object.key)}`,
+        { headers: authHeaders(config) }
+      );
+      if (!fileRes.ok) throw new Error(`${fileRes.status} ${fileRes.statusText}`);
+      mkdirSync2(dirname2(target), { recursive: true });
+      writeFileSync2(target, Buffer.from(await fileRes.arrayBuffer()));
+      downloaded++;
+    } catch (err) {
+      failures.push(`${object.key}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  console.log(`Downloaded ${downloaded}/${keys.length} file(s).`);
+  if (failures.length) {
+    console.log("\nFailed:");
+    for (const failure of failures) console.log(`  - ${failure}`);
+  }
+}
+
 // src/lib/api.ts
 function errorMessage(status, body, statusText) {
   const parts = [body.error ?? statusText];
@@ -805,12 +887,12 @@ async function resolveDomainId(projectId, idOrHostname) {
 }
 
 // src/commands/storage.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { basename } from "path";
-function authHeaders(config) {
+function authHeaders2(config) {
   return { Authorization: `Bearer ${config.accessToken}` };
 }
-async function throwOnError(res) {
+async function throwOnError2(res) {
   if (res.ok) return;
   const body = await res.json().catch(() => ({ error: res.statusText }));
   throw new Error(`${res.status} ${body.error ?? res.statusText}`);
@@ -818,9 +900,9 @@ async function throwOnError(res) {
 async function storageListCommand() {
   const config = requireProject();
   const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage`, {
-    headers: authHeaders(config)
+    headers: authHeaders2(config)
   });
-  await throwOnError(res);
+  await throwOnError2(res);
   const data = await res.json();
   table(
     data.objects.map((o) => ({
@@ -838,12 +920,13 @@ async function storageUploadCommand(filePath, opts) {
   const filename = opts.key ?? basename(filePath);
   const form = new FormData();
   form.append("file", new Blob([bytes]), filename);
+  if (opts.bucket) form.append("bucket", opts.bucket);
   const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage/upload`, {
     method: "POST",
-    headers: authHeaders(config),
+    headers: authHeaders2(config),
     body: form
   });
-  await throwOnError(res);
+  await throwOnError2(res);
   const data = await res.json();
   console.log(`\u2713 Uploaded as ${data.key} (${data.size} bytes, ${data.contentType})`);
 }
@@ -851,12 +934,12 @@ async function storageDownloadCommand(key, opts) {
   const config = requireProject();
   const res = await fetch(
     `${config.baseUrl}/api/projects/${config.projectId}/storage/download?key=${encodeURIComponent(key)}`,
-    { headers: authHeaders(config) }
+    { headers: authHeaders2(config) }
   );
-  await throwOnError(res);
+  await throwOnError2(res);
   const bytes = new Uint8Array(await res.arrayBuffer());
   const outPath = opts.out ?? basename(key);
-  writeFileSync2(outPath, bytes);
+  writeFileSync3(outPath, bytes);
   console.log(`\u2713 Saved to ${outPath} (${bytes.length} bytes)`);
 }
 async function storageDeleteCommand(key, opts) {
@@ -864,11 +947,124 @@ async function storageDeleteCommand(key, opts) {
   await confirmOrDie(`Delete "${key}" from storage?`, opts.yes);
   const res = await fetch(
     `${config.baseUrl}/api/projects/${config.projectId}/storage?key=${encodeURIComponent(key)}`,
-    { method: "DELETE", headers: authHeaders(config) }
+    { method: "DELETE", headers: authHeaders2(config) }
   );
-  await throwOnError(res);
+  await throwOnError2(res);
   console.log(`\u2713 Deleted ${key}`);
 }
+async function storagePublicCommand(mode, opts) {
+  const config = requireProject();
+  const normalized = mode.toLowerCase();
+  if (!["on", "off", "status"].includes(normalized)) {
+    throw new Error(`Expected "on", "off", or "status" \u2014 got "${mode}"`);
+  }
+  const projectRes = await fetch(`${config.baseUrl}/api/projects/${config.projectId}`, {
+    headers: authHeaders2(config)
+  });
+  await throwOnError2(projectRes);
+  const project = await projectRes.json();
+  const enabled = Boolean(project.public_storage_enabled);
+  const publicBase = `${config.baseUrl}/files/${project.slug}/`;
+  if (normalized === "status") {
+    console.log(enabled ? `Public read is ON \u2014 ${publicBase}<key>` : "Public read is OFF");
+    return;
+  }
+  const target = normalized === "on";
+  if (target === enabled) {
+    console.log(`Public read is already ${target ? "on" : "off"} \u2014 nothing to do.`);
+    return;
+  }
+  if (target) {
+    await confirmOrDie(
+      `Make every file in "${project.slug}" readable by anyone who knows its key (no login)?`,
+      opts.yes
+    );
+  }
+  const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}`, {
+    method: "PATCH",
+    headers: { ...authHeaders2(config), "Content-Type": "application/json" },
+    body: JSON.stringify({ public_storage_enabled: target })
+  });
+  await throwOnError2(res);
+  console.log(target ? `\u2713 Public read ON \u2014 ${publicBase}<key>` : "\u2713 Public read OFF");
+}
+async function storageBucketsListCommand() {
+  const config = requireProject();
+  const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage/buckets`, {
+    headers: authHeaders2(config)
+  });
+  await throwOnError2(res);
+  const data = await res.json();
+  if (!data.buckets.length) {
+    console.log("No buckets yet \u2014 files without a --bucket are stored at the project root.");
+    return;
+  }
+  table(
+    data.buckets.map((b) => ({
+      name: b.name,
+      access: b.public ? "public" : "private",
+      created: new Date(b.created_at).toLocaleString()
+    }))
+  );
+}
+async function storageBucketsCreateCommand(name, opts) {
+  const config = requireProject();
+  const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage/buckets`, {
+    method: "POST",
+    headers: { ...authHeaders2(config), "Content-Type": "application/json" },
+    body: JSON.stringify({ name, public: Boolean(opts.public) })
+  });
+  await throwOnError2(res);
+  const data = await res.json();
+  console.log(`\u2713 Created bucket "${data.name}" (${data.public ? "public" : "private"}) \u2014 upload with --bucket ${data.name}`);
+}
+async function storageBucketsSetPublicCommand(name, mode, opts) {
+  const config = requireProject();
+  const normalized = mode.toLowerCase();
+  if (!["on", "off"].includes(normalized)) throw new Error(`Expected "on" or "off" \u2014 got "${mode}"`);
+  const target = normalized === "on";
+  if (target) {
+    await confirmOrDie(`Make every file in bucket "${name}" readable by anyone who knows its key (no login)?`, opts.yes);
+  }
+  const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage/buckets/${encodeURIComponent(name)}`, {
+    method: "PATCH",
+    headers: { ...authHeaders2(config), "Content-Type": "application/json" },
+    body: JSON.stringify({ public: target })
+  });
+  await throwOnError2(res);
+  console.log(target ? `\u2713 Bucket "${name}" is now public` : `\u2713 Bucket "${name}" is now private`);
+}
+async function storageBucketsDeleteCommand(name, opts) {
+  const config = requireProject();
+  await confirmOrDie(`Remove bucket "${name}"? (files already stored under it are kept, only the access policy is removed)`, opts.yes);
+  const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage/buckets/${encodeURIComponent(name)}`, {
+    method: "DELETE",
+    headers: authHeaders2(config)
+  });
+  await throwOnError2(res);
+  console.log(`\u2713 Removed bucket "${name}"`);
+}
+function parseDuration(input) {
+  const match = /^(\d+)([smhd])?$/.exec(input.trim());
+  if (!match) throw new Error(`Invalid duration "${input}" \u2014 expected e.g. "3600", "30m", "1h", "7d"`);
+  const n = Number(match[1]);
+  const unit = match[2] ?? "s";
+  const mult = { s: 1, m: 60, h: 3600, d: 86400 }[unit] ?? 1;
+  return n * mult;
+}
+async function storageSignCommand(key, opts) {
+  const config = requireProject();
+  const expiresIn = opts.expires ? parseDuration(opts.expires) : void 0;
+  const res = await fetch(`${config.baseUrl}/api/projects/${config.projectId}/storage/signed-url`, {
+    method: "POST",
+    headers: { ...authHeaders2(config), "Content-Type": "application/json" },
+    body: JSON.stringify({ key, expiresIn })
+  });
+  await throwOnError2(res);
+  const data = await res.json();
+  console.log(data.url);
+  console.log(`(expires ${new Date(data.expiresAt).toLocaleString()})`);
+}
 
 // src/commands/webhooks.ts
 var KNOWN_EVENTS = [
@@ -1512,6 +1708,51 @@ async function vpsStatusCommand() {
   );
   console.log("");
 }
+async function vpsRestartCommand(service) {
+  const config = requireProject();
+  const data = await apiRequest(`/api/projects/${config.projectId}/vps/restart`, {
+    method: "POST",
+    body: JSON.stringify({ service })
+  });
+  console.log(`\u2713 Restarted ${data.restarted}`);
+}
+async function vpsServiceMetricsCommand() {
+  const config = requireProject();
+  const data = await apiRequest(`/api/projects/${config.projectId}/vps/service-metrics`);
+  if (!data.services.length) {
+    console.log("(no services found \u2014 deploy first, or check that raw Postgres/Redis are provisioned)");
+    return;
+  }
+  console.log("\n\u2500\u2500 SERVICE METRICS \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const s of data.services) {
+    const restarts = s.restartCount ? ` \xB7 ${s.restartCount} restart${s.restartCount === 1 ? "" : "s"}` : "";
+    const health = s.health ? ` \xB7 health: ${s.health}` : "";
+    console.log(`  ${s.state === "running" ? "\u25CF" : "\u25CB"} ${s.service} (${s.kind})`);
+    console.log(`      cpu: ${s.cpuPercent ?? "?"}%  mem: ${s.memUsage ?? "?"} (${s.memPercent ?? "?"}%)  net: ${s.netIO ?? "?"}${restarts}${health}`);
+  }
+  console.log("");
+}
+async function vpsWebMetricsCommand(opts) {
+  const config = requireProject();
+  const minutes = Math.min(Math.max(parseInt(opts.minutes ?? "15", 10) || 15, 1), 1440);
+  const data = await apiRequest(`/api/projects/${config.projectId}/vps/web-metrics?minutes=${minutes}`);
+  console.log(`
+\u2500\u2500 WEB REQUESTS (last ${data.windowMinutes}m) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  if (data.note) {
+    console.log(`  ${data.note}`);
+  } else if (data.requests === 0) {
+    console.log("  No requests in this window.");
+  } else {
+    const statusLine = Object.entries(data.byStatusClass).sort(([a], [b]) => a.localeCompare(b)).map(([cls, n]) => `${cls}: ${n}`).join("  ");
+    console.log(`  ${data.requests} requests  \xB7  avg ${data.avgResponseMs}ms  \xB7  p95 ${data.p95ResponseMs}ms`);
+    console.log(`  ${statusLine}`);
+    if (data.recentErrors?.length) {
+      console.log("\n  Recent 5xx:");
+      for (const e of data.recentErrors) console.log(`    ${e.time}  ${e.status}  ${e.method} ${e.uri}  (${e.responseMs}ms)`);
+    }
+  }
+  console.log("");
+}
 async function vpsLogsCommand(service, opts) {
   const config = requireProject();
   const tail = Math.min(Math.max(parseInt(opts.tail ?? "200", 10) || 200, 1), 5e3);
@@ -1531,6 +1772,7 @@ program.command("projects").description("List projects").action(projectsListComm
 program.command("create <name>").description("Create a new project (and set it active)").option("--slug <slug>", "Project slug (derived from name if omitted)").option("--repo <url>", "Public repo URL to link for deployments (no embedded tokens/credentials \u2014 for a private repo or auto-deploy on push, use 'deploro github connect' + 'deploro repo link' instead)").option("--branch <branch>", "Git branch to deploy from").action(projectsCreateCommand);
 program.command("use <project>").description("Set the active project (accepts id, slug, or name)").action(useProjectCommand);
 program.command("delete <project>").description("Delete a project and its database (accepts id, slug, or name)").option("-y, --yes", "Skip confirmation prompt").action(projectsDeleteCommand);
+program.command("export").description("Export the active project's database and storage manifest (NDJSON)").option("--out <file>", "Where to write the export (default: deploro-export-<date>.ndjson)").option("--storage <dir>", "Also download stored files into this directory").option("--skip-storage", "Skip the object-storage listing entirely").action(exportCommand);
 var db = program.command("db").description("Database commands");
 db.command("create").description("Provision the active project's database (idempotent)").action(dbCreateCommand);
 db.command("info").description("Show database status and how to reach it from a deployed app").action(dbInfoCommand);
@@ -1598,6 +1840,9 @@ vps.command("deployments").description("List VPS deploy history").action(vpsDepl
 vps.command("deploy-status [deployment-id]").description("Show a VPS deployment's status and logs (defaults to latest)").action(vpsDeployStatusCommand);
 vps.command("status").description("Show running compute services + raw Postgres/Redis container status").action(vpsStatusCommand);
 vps.command("logs [service]").description("Tail logs for a compute service (or 'postgres'/'redis')").option("--tail <n>", "Number of lines", "200").action(vpsLogsCommand);
+vps.command("restart <service>").description("Restart one compute service (or 'postgres'/'redis') without a full redeploy").action(vpsRestartCommand);
+vps.command("service-metrics").description("Per-container CPU/memory/health/restart count for every compute service").action(vpsServiceMetricsCommand);
+vps.command("web-metrics").description("Request count, status breakdown, and response-time stats for the public web service").option("--minutes <n>", "Time window", "15").action(vpsWebMetricsCommand);
 var github = program.command("github").description("GitHub account connection (OAuth)");
 github.command("status").description("Show whether your GitHub account is connected").action(githubStatusCommand);
 github.command("connect").description("Print the URL to open in a browser to connect GitHub").action(githubConnectCommand);
@@ -1616,9 +1861,16 @@ domains.command("status <id-or-hostname>").description("Poll domain verification
 domains.command("remove <id-or-hostname>").description("Remove a domain").option("-y, --yes", "Skip confirmation prompt").action(domainsRemoveCommand);
 var storage = program.command("storage").description("R2 file storage for the active project");
 storage.command("list").description("List stored files").action(storageListCommand);
-storage.command("upload <file>").description("Upload a local file").option("--key <name>", "Stored file name (defaults to the local file's name)").action(storageUploadCommand);
+storage.command("upload <file>").description("Upload a local file").option("--key <name>", "Stored file name (defaults to the local file's name)").option("--bucket <name>", "Upload into an existing bucket instead of the project root").action(storageUploadCommand);
 storage.command("download <key>").description("Download a stored file").option("--out <path>", "Local path to save to (defaults to the file's name)").action(storageDownloadCommand);
 storage.command("delete <key>").description("Delete a stored file").option("-y, --yes", "Skip confirmation prompt").action(storageDeleteCommand);
+storage.command("public <mode>").description("Turn unauthenticated read access on|off, or show status").option("-y, --yes", "Skip confirmation prompt").action(storagePublicCommand);
+storage.command("sign <key>").description("Generate a time-limited public URL for one file").option("--expires <duration>", "e.g. 1h, 30m, 7d (default 1h)").action(storageSignCommand);
+var buckets = storage.command("buckets").description("Named, independently-public storage groupings within this project");
+buckets.command("list").description("List buckets").action(storageBucketsListCommand);
+buckets.command("create <name>").description("Create a bucket").option("--public", "Make it public read on creation").action(storageBucketsCreateCommand);
+buckets.command("set-public <name> <mode>").description("Turn a bucket's unauthenticated read access on|off").option("-y, --yes", "Skip confirmation prompt").action(storageBucketsSetPublicCommand);
+buckets.command("delete <name>").description("Remove a bucket's access policy (keeps its files)").option("-y, --yes", "Skip confirmation prompt").action(storageBucketsDeleteCommand);
 var webhooks = program.command("webhooks").description("Outbound webhooks for the active project");
 webhooks.command("list").description("List webhooks").action(webhooksListCommand);
 webhooks.command("create <url>").description("Create a webhook").option("--events <list>", "Comma-separated event names (default: test)").option("--secret <secret>", "HMAC signing secret").action(webhooksCreateCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deploro",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Command-line interface for the Deploro developer platform — manage projects, databases, deployments, and hosting from your terminal.",
   "type": "module",
   "bin": {