@vibingview/cli 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibingview/cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "VibingView command-line interface and stdio MCP bridge: pair with browser approval, deploy apps, read logs, manage env vars and databases, and connect AI editors.",
   "license": "MIT",
   "type": "module",

package/src/cli.mjs

@@ -10,7 +10,7 @@ import { fileURLToPath } from "node:url";
 import { ensureGitignore, inferAppName, isIdenticalDeploy, packageProject, readProjectConfig, writeProjectConfig } from "./lib/project.mjs";
 import { defaultTransport, installMcpConfig, maskToken, maskedEntry, mcpConfigPath, MCP_CLIENTS, NPM_PACKAGE } from "./lib/mcp-install.mjs";
 
-export const VERSION = "0.1.3";
+export const VERSION = "0.2.0";
 /** Production control plane used when no --url, VIBINGVIEW_URL or saved login selects another. */
 export const DEFAULT_URL = "https://vibingview.com";
 const USAGE = `VibingView CLI ${VERSION}
@@ -47,14 +47,36 @@ One-click apps
   vibingview app create <slug> [--name <app>] [--workspace <id|name>] [--domain <suffix>] [--yes]
   vibingview app status [app]
 
+Servers (actions marked * need your approval in the browser; the link shows exactly what happens and its price)
+  vibingview server list | info [server] | plans [server]
+  vibingview server reboot|start|clean [server]
+  vibingview server shutdown [server]*
+  vibingview server upgrade <plan> [--server <s>] [--at "YYYY-MM-DD HH:MM"]*   upgrade cancel|now [--server <s>]
+  vibingview server renew* | billing <1|6|12>* | auto-renew on|off* | reinstall* | delete*   [--server <s>]
+
+Apps
+  vibingview apps [--workspace <id|name>]
+  vibingview app deployments [app] | rollback [app] --to <revision|id> | settings [app]
+  vibingview app set [app] [--port n] [--root-dir d] [--install-command c] [--build-command c] [--start-command c] [--output-dir d] [--technique 1-5] [--dockerfile <file>]
+  vibingview app delete [app]*
+  vibingview deploy --git <repository-url> [--branch main] --name <app> --port <n> [--workspace <s>]
+
+Domains
+  vibingview domains [app] | add <host> | check <host> | remove <host>*   [--app <app>]
+  vibingview domains owned | connect <domain> --app <app>* | disconnect <domain>*
+  vibingview nameservers [app] | connect <domain> | check <domain> | disconnect <domain>*   [--app <app>]
+
+Billing
+  vibingview balance | payments | topup <euros> [--method card|crypto]
+
 Other
-  vibingview workspaces | apps
+  vibingview workspaces | logs … --follow | logs … --json | db logs <db> | db reveal <db>* | db delete <db>* | env get --reveal*
 
 Control plane: --url <origin> on any command, else VIBINGVIEW_URL, else the instance you last logged in to,
 else ${DEFAULT_URL}. VIBINGVIEW_TOKEN overrides the saved token.`;
 
-const BOOLEAN_FLAGS = new Set(["force", "yes", "reveal", "show", "ai", "build", "runtime", "no-wait", "no-browser", "dry-run", "json", "help", "stdin", "local-bridge"]);
-const VALUE_FLAGS = new Set(["workspace", "name", "port", "domain", "app", "limit", "engine", "client", "transport", "timeout", "url", "token", "technique", "builder"]);
+const BOOLEAN_FLAGS = new Set(["force", "yes", "reveal", "show", "ai", "build", "runtime", "no-wait", "no-browser", "dry-run", "json", "help", "stdin", "local-bridge", "follow"]);
+const VALUE_FLAGS = new Set(["workspace", "server", "name", "port", "domain", "app", "limit", "engine", "client", "transport", "timeout", "url", "token", "technique", "builder", "to", "at", "method", "git", "branch", "root-dir", "install-command", "build-command", "start-command", "output-dir", "dockerfile"]);
 
 export function parseArgs(argv) {
   const positional = [];
@@ -122,11 +144,17 @@ function createClient(base, token) {
       response = await fetch(`${base}${route}`, { ...init, redirect: "error", signal: AbortSignal.timeout(init.timeout ?? 120000), headers: { ...(token ? { Authorization: `Bearer ${token}` } : {}), ...init.headers } });
     } catch (error) { throw new CliError(redact(`Could not reach ${base}: ${error.cause?.message ?? error.message}`)); }
     if (response.status === 204) return {};
-    const body = await response.json().catch(() => ({}));
+    let body = {}, unreadable = false;
+    const text = await response.text().catch(() => { unreadable = true; return ""; });
+    if (text) { try { body = JSON.parse(text); } catch { unreadable = true; } }
+    // A success whose body was cut off (e.g. the connection dropped) must not read as "empty": callers would treat an
+    // unread app list as "no apps" and create a duplicate.
+    if (response.ok && unreadable)
+      throw new CliError(`Could not read the server's answer to ${route.split("?")[0]}. Nothing was assumed; try again (after a deploy, check vibingview status first).`);
     if (!response.ok) {
       let message = typeof body.error === "string" ? body.error : body.error?.message ?? `HTTP ${response.status}`;
-      if (response.status === 401 && token) message += " — the token may be expired or revoked, or lacks the permission this command needs (database create/reveal need a token with the 'manage' permission). Run vibingview login or use an appropriately scoped VIBINGVIEW_TOKEN.";
-      throw Object.assign(new CliError(redact(message)), { status: response.status });
+      if (response.status === 401 && token) message += " — the token may be expired or revoked, or lacks the permission this command needs (sign in again with vibingview login). Run vibingview login or use an appropriately scoped VIBINGVIEW_TOKEN.";
+      throw Object.assign(new CliError(redact(message)), { status: response.status, code: typeof body.code === "string" ? body.code : undefined });
     }
     return body;
   };
@@ -315,7 +343,7 @@ export async function main(argv = process.argv.slice(2)) {
   // ----- lookups -------------------------------------------------------------
   const cwd = process.cwd();
   const project = await readProjectConfig(cwd);
-  const workspacesList = async () => (await call("/api/workspaces")).workspaces ?? [];
+  const workspacesList = async () => { const { workspaces } = await call("/api/workspaces"); if (!Array.isArray(workspaces)) throw new CliError("The server did not send the list of workspaces. Nothing was changed; try again."); return workspaces; };
   const isRunning = workspace => String(workspace.status).toUpperCase() === "RUNNING";
   async function resolveWorkspace(reference, { running = true } = {}) {
     const all = await workspacesList();
@@ -345,6 +373,41 @@ export async function main(argv = process.argv.slice(2)) {
     return matches[0];
   }
 
+  async function resolveDatabase(reference) {
+    const workspaces = flags.workspace || flags.server || project.workspaceId ? [await resolveWorkspace(flags.workspace ?? flags.server, { running: false })] : await workspacesList();
+    const found = [];
+    for (const workspace of workspaces) {
+      const { databases = [] } = await call(`/api/workspaces/${encodeURIComponent(workspace.id)}/databases`);
+      for (const item of databases) if (item.id === reference || item.name === reference) found.push({ ...item, workspaceId: workspace.id, workspace: workspace.name });
+    }
+    if (!found.length) throw new CliError(`Database ${reference} not found`);
+    if (found.length > 1) throw new CliError(`Several databases are named ${reference}; pass --workspace or the database ID.`);
+    return found[0];
+  }
+  const euros = cents => `€${(Number(cents) / 100).toFixed(2)}`;
+  /**
+   * Server actions go through /api/cli/actions. Everyday ones run at once; paying, deleting and revealing secrets
+   * answer with a link the account owner approves in the browser (it shows exactly what happens and the price).
+   */
+  async function approvedAction(action, params) {
+    const answer = await call("/api/cli/actions", json("POST", { action, params }));
+    if (answer.status === "done") return answer.result ?? {};
+    const price = answer.summary && "chargeCents" in answer.summary ? ` It costs ${euros(answer.summary.chargeCents)}.` : "";
+    out(`Approval needed: open this link and click Approve (it shows exactly what will happen).${price}\n  ${answer.approveUrl}`);
+    if (!flags["no-browser"] && new URL(answer.approveUrl).origin === new URL(base).origin) openBrowser(answer.approveUrl);
+    out("Waiting for your approval in the browser (up to 10 minutes)…");
+    const deadline = Date.parse(answer.expiresAt) || Date.now() + 600000;
+    while (Date.now() < deadline + 5000) {
+      await sleep(3000);
+      const state = await call(`/api/cli/actions/${encodeURIComponent(answer.id)}`).catch(error => { if (error.status === 404) throw error; return { status: "pending" }; });
+      if (state.status === "done") return state.result ?? {};
+      if (state.status === "denied") throw new CliError("Denied in the browser. Nothing was changed.");
+      if (state.status === "expired") throw new CliError("The approval request expired. Run the command again.");
+      if (state.status === "failed") throw new CliError(`It did not work: ${state.error ?? "unknown error"}`);
+    }
+    throw new CliError("The approval request expired. Run the command again.");
+  }
+
   // ----- listing ---------------------------------------------------------------
   if (command === "workspaces") {
     const rows = await workspacesList();
@@ -352,12 +415,24 @@ export async function main(argv = process.argv.slice(2)) {
     return 0;
   }
   if (command === "apps") {
-    const { applications = [] } = await call("/api/apps");
+    const filter = flags.workspace ?? flags.server ? await resolveWorkspace(flags.workspace ?? flags.server, { running: false }) : null;
+    const { applications: all = [] } = await call("/api/apps");
+    const applications = filter ? all.filter(app => app.workspaceId === filter.id) : all;
     if (flags.json) out(JSON.stringify(applications, null, 2)); else table(applications, [["id", "ID"], ["name", "NAME"], ["status", "STATUS"], ["url", "URL"]]);
     return 0;
   }
 
   // ----- deploy ----------------------------------------------------------------
+  if (command === "deploy" && typeof flags.git === "string") {
+    // A new app built from a Git repository (later pushes redeploy it once the repository is linked in the dashboard).
+    if (!flags.name) throw new CliError("Usage: vibingview deploy --git <repository-url> --name <app> --port <n> [--branch main] [--workspace <s>]");
+    const port = Number(flags.port ?? 3000);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new CliError("--port must be 1-65535");
+    const workspace = await resolveWorkspace(flags.workspace ?? flags.server);
+    const { application } = await call("/api/apps", json("POST", { workspaceId: workspace.id, name: flags.name, gitUrl: flags.git, branch: flags.branch ?? "main", port }));
+    out(`${application.name} (${application.id}) is building from ${flags.git}${application.url ? ` → ${application.url}` : ""}.\nFollow it with vibingview logs ${application.name} --build or vibingview status ${application.name}.`);
+    return 0;
+  }
   if (command === "deploy") {
     if (args.length === 3 && args[2].toLowerCase().endsWith(".zip")) return legacyDeploy(call, args);
     const directory = path.resolve(args[0] ?? ".");
@@ -371,9 +446,22 @@ export async function main(argv = process.argv.slice(2)) {
     reportNotableSkips(pkg.notable ?? []);
     if (isIdenticalDeploy(linked, pkg.sha256, flags.force)) { out("No changes since the last deploy. Use --force to redeploy anyway."); return 0; }
 
-    const { applications = [] } = await call("/api/apps");
-    let app = linked.applicationId && (!flags.name || flags.name === linked.name) ? applications.find(item => item.id === linked.applicationId) : undefined;
-    if (linked.applicationId && !app && !flags.name) warn("The linked application no longer exists; creating a new one.");
+    if (linked.controlPlane && linked.controlPlane !== base) warn(`This folder was deployed to ${linked.controlPlane}; you are now using ${base}.`);
+    const appList = async () => { const { applications } = await call("/api/apps"); if (!Array.isArray(applications)) throw new CliError("The server did not send the list of applications. Nothing was changed; try again."); return applications; };
+    if (linked.applicationId && flags.name && flags.name !== linked.name && !flags.force) throw new CliError(`This folder is linked to the application "${linked.name}", but --name says "${flags.name}". Drop --name to redeploy it, use --force to create another app, or remove .vibingview/config.json.`);
+    const useLinked = linked.applicationId && (!flags.name || flags.name === linked.name);
+    let app = useLinked ? (await appList()).find(item => item.id === linked.applicationId) : undefined;
+    if (useLinked && !app) {
+      // One answer without the app must never create a duplicate: ask for the app itself before assuming it was deleted.
+      const deleted = await call(`/api/apps/${encodeURIComponent(linked.applicationId)}/settings`).then(() => false, error => {
+        if (error.status === 404 || error.code === "apps.not_found") return true;
+        throw new CliError(`Could not confirm that the linked application ${linked.name ?? linked.applicationId} was deleted (${error.message}). Nothing was created; try again.`);
+      });
+      if (!deleted) {
+        app = (await appList()).find(item => item.id === linked.applicationId);
+        if (!app) throw new CliError(`The linked application ${linked.name ?? linked.applicationId} exists but was missing from the server's list. Nothing was created; try again in a moment.`);
+      } else warn("The linked application was deleted; creating a new one.");
+    }
     const catalog = await call("/api/catalog");
     const suffixes = catalog.domains ?? [];
     let suffix = linked.domainSuffix;
@@ -416,7 +504,8 @@ export async function main(argv = process.argv.slice(2)) {
       if (port !== undefined) form.set("port", String(port));
       if (builder) form.set("builder", builder);
       form.set("file", new Blob([pkg.archive], { type: "application/zip" }), `${name}.zip`);
-      app = (await call("/api/apps", { method: "POST", body: form })).application;
+      // A large upload must not time out client-side while the server finishes creating the app (that made a second app on retry).
+      app = (await call("/api/apps", { method: "POST", body: form, timeout: 120000 + Math.ceil(pkg.archive.length / 1_000_000) * 4000 })).application;
       deploymentId = app.lastDeploymentId;
     }
     const state = { controlPlane: base, workspaceId, applicationId: app.id, name: app.name, url: app.url, domainSuffix: suffix, customDomain: customDomain ?? linked.customDomain, lastHash: linked.lastHash, deployedAt: new Date().toISOString() };
@@ -460,6 +549,19 @@ export async function main(argv = process.argv.slice(2)) {
     const kind = flags.build || legacyKind === "build" || args[0] === "build" ? "build" : "runtime";
     const max = Math.min(1000, Math.max(1, Number(flags.limit ?? 200) || 200));
     const { logs = [] } = await call(`/api/apps/${encodeURIComponent(app.id)}/logs?kind=${kind}&limit=${max}`);
+    if (flags.json) { out(JSON.stringify(logs, null, 2)); return 0; }
+    if (flags.follow) {
+      // Prints new lines every 3 seconds until Ctrl+C (lines are matched on time and text, so restarts are handled).
+      const key = line => `${line.recorded_at ?? ""}|${line.message}`;
+      let seen = new Set(logs.map(key));
+      for (const line of logs) out(clean(line.message));
+      for (;;) {
+        await sleep(3000);
+        const { logs: next = [] } = await call(`/api/apps/${encodeURIComponent(app.id)}/logs?kind=${kind}&limit=200`).catch(() => ({ logs: [] }));
+        for (const line of next) if (!seen.has(key(line))) out(clean(line.message));
+        seen = new Set([...seen, ...next.map(key)].slice(-5000));
+      }
+    }
     if (flags.ai) {
       out(`## VibingView ${kind} logs: ${app.name}\n\n- Application: ${app.name} (${app.id})\n- Status: ${app.status}\n- URL: ${app.url ?? "private"}\n- Lines: last ${logs.length}\n\n\`\`\`text`);
       for (const line of logs) out(`${line.recorded_at ? new Date(line.recorded_at).toISOString() + " " : ""}${line.stream ? `[${line.stream}] ` : ""}${clean(line.message)}`);
@@ -493,10 +595,11 @@ export async function main(argv = process.argv.slice(2)) {
     if (sub === "get" || sub === "list") {
       const wanted = args[1];
       if (flags.reveal) {
-        warn("Revealing secret values. This is recorded in your account audit log; keep the output private.");
-        const { variables = [] } = await call(`/api/apps/${encodeURIComponent(app.id)}/settings`, json("POST", { action: "reveal" }));
+        warn("Showing secret values needs your approval in the browser. Keep the output private.");
+        const { variables = [] } = await approvedAction("env.reveal", { applicationId: app.id }) ?? {};
         const selected = variables.filter(variable => !wanted || variable.name === wanted);
         if (wanted && !selected.length) throw new CliError(`${wanted} is not set`);
+        if (!selected.length) warn("No environment variables.");
         for (const variable of selected) out(`${variable.name}=${variable.value}`);
         return 0;
       }
@@ -515,8 +618,20 @@ export async function main(argv = process.argv.slice(2)) {
       const environment = {};
       const pairs = args.slice(1);
       if (flags.stdin) {
-        if (pairs.length !== 1) throw new CliError("Usage: vibingview env set NAME --stdin");
-        environment[pairs[0]] = await readStdin();
+        // One name: the whole input is its value. No name: one NAME=value per line (.env style), so secrets never sit in argv.
+        if (pairs.length > 1) throw new CliError("Usage: vibingview env set NAME --stdin, or env set --stdin with NAME=value lines on stdin");
+        const input = await readStdin();
+        if (pairs.length === 1) environment[pairs[0]] = input;
+        else for (const line of input.split(/\r?\n/)) {
+          const text = line.trim();
+          if (!text || text.startsWith("#")) continue;
+          const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(text);
+          if (!match) throw new CliError(`Not a NAME=value line: ${text.slice(0, 40)}`);
+          let value = match[2];
+          if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) value = value.slice(1, -1);
+          environment[match[1]] = value;
+        }
+        if (!Object.keys(environment).length) throw new CliError("No NAME=value lines were read from stdin.");
       } else {
         if (!pairs.length) throw new CliError("Usage: vibingview env set NAME=value [NAME=value…] or NAME --stdin");
         for (const pair of pairs) {
@@ -559,9 +674,9 @@ export async function main(argv = process.argv.slice(2)) {
         for (const item of databases) rows.push({ ...item, workspace: workspace.name, workspaceId: workspace.id });
       }
       if (flags.reveal) {
-        warn("Revealing connection strings. Each reveal is audited; keep the output private. Requires a token with the 'manage' permission.");
+        warn("Showing a connection string needs your approval in the browser, one database at a time. Keep the output private.");
         for (const row of rows) {
-          const { connectionString } = await call(`/api/workspaces/${encodeURIComponent(row.workspaceId)}/databases`, json("PATCH", { databaseId: row.id, action: "reveal" }));
+          const { connectionString } = await approvedAction("db.reveal", { workspaceId: row.workspaceId, databaseId: row.id }) ?? {};
           out(`${row.name} (${row.engine}, ${row.status}): ${connectionString}`);
         }
         return 0;
@@ -593,7 +708,246 @@ export async function main(argv = process.argv.slice(2)) {
       out(`${sub === "link" ? `Linked database to ${app.name} as DATABASE_URL` : `Unlinked database from ${app.name}`}. ${queuedNote(result)}`);
       return 0;
     }
-    throw new CliError("Usage: vibingview db list|create|link|unlink");
+    if (sub === "reveal" || sub === "delete" || sub === "logs") {
+      if (!args[1]) throw new CliError(`Usage: vibingview db ${sub} <database-id|name> [--workspace <id|name>]`);
+      const found = await resolveDatabase(args[1]);
+      if (sub === "logs") {
+        const { logs = [] } = await call(`/api/workspaces/${encodeURIComponent(found.workspaceId)}/databases?logs=${encodeURIComponent(found.id)}`);
+        if (flags.json) out(JSON.stringify(logs, null, 2)); else for (const line of logs) out(clean(line.message));
+        if (!logs.length) warn("No database logs yet.");
+        return 0;
+      }
+      if (sub === "reveal") { const { connectionString } = await approvedAction("db.reveal", { workspaceId: found.workspaceId, databaseId: found.id }) ?? {}; out(connectionString); return 0; }
+      await approvedAction("db.delete", { workspaceId: found.workspaceId, databaseId: found.id });
+      out(`Deleting ${found.name}. Its data is erased once the server confirms.`);
+      return 0;
+    }
+    throw new CliError("Usage: vibingview db list|create|link|unlink|logs|reveal|delete");
+  }
+
+  // ----- servers -------------------------------------------------------------------
+  if (command === "server" || command === "servers") {
+    const sub = command === "servers" ? "list" : (args[0] ?? "list");
+    const serverRef = flags.server ?? flags.workspace;
+    if (sub === "list") {
+      const rows = await workspacesList();
+      if (flags.json) out(JSON.stringify(rows, null, 2)); else table(rows, [["id", "ID"], ["name", "NAME"], ["status", "STATUS"], ["planId", "PLAN"], ["publicIp", "IP"]]);
+      return 0;
+    }
+    const server = await resolveWorkspace(serverRef ?? (["info", "plans", "reboot", "start", "clean", "shutdown", "renew", "reinstall", "delete"].includes(sub) ? args[1] : undefined), { running: false });
+    const id = encodeURIComponent(server.id);
+    if (sub === "info") {
+      const [life, metrics] = await Promise.all([call(`/api/workspaces/${id}/lifecycle`), call(`/api/workspaces/${id}/metrics`).catch(() => ({}))]);
+      const last = (metrics.metrics ?? []).at(-1);
+      if (flags.json) { out(JSON.stringify({ server, lifecycle: life, latestMetrics: last ?? null, agentLastSeenAt: metrics.agentLastSeenAt ?? null }, null, 2)); return 0; }
+      const gb = bytes => `${(Number(bytes) / 1e9).toFixed(1)} GB`;
+      out(`${server.name} (${server.id})\n  Status:     ${String(life.status ?? server.status).toLowerCase()}\n  Plan:       ${server.planId} · ${euros(life.monthlyPriceCents ?? 0)}/month, billed every ${life.billingMonths ?? 1} month(s)\n  IP:         ${server.publicIp ?? "(pending)"}\n  Renews:     ${life.renewsAt ? new Date(life.renewsAt).toISOString().slice(0, 16).replace("T", " ") + " UTC" : "—"} (auto-renew ${life.autoRenew ? "on" : "off"})`);
+      if (life.bandwidth) out(`  Traffic:    ${gb(life.bandwidth.usedBytes)} of ${gb(life.bandwidth.quotaBytes)} this period`);
+      if (last) out(`  Now:        CPU ${Number(last.cpu_percent).toFixed(1)}% · RAM ${gb(last.memory_used_bytes)} · disk ${gb(last.disk_used_bytes)}`);
+      if (metrics.agentLastSeenAt) out(`  Agent seen: ${new Date(metrics.agentLastSeenAt).toISOString().slice(0, 19).replace("T", " ")} UTC`);
+      if (life.upgrade && ["scheduled", "resizing", "needs_review"].includes(life.upgrade.status)) out(`  Upgrade:    to ${life.upgrade.toPlanName}, ${life.upgrade.status}${life.upgrade.status === "scheduled" ? ` for ${new Date(life.upgrade.scheduledFor).toISOString().slice(0, 16).replace("T", " ")} UTC` : ""}`);
+      for (const task of life.pendingTasks ?? []) out(`  Task:       ${task.label} (${task.status})`);
+      return 0;
+    }
+    if (sub === "plans") {
+      const plans = await call("/api/plans");
+      const current = (Array.isArray(plans) ? plans : []).find(plan => plan.id === server.planId);
+      const rows = (Array.isArray(plans) ? plans : []).map(plan => ({ ...plan, price: `${euros(plan.monthlyPriceCents)}/mo`, size: `${plan.cpu} vCPU · ${plan.ramGb} GB RAM · ${plan.storageGb} GB disk · ${plan.trafficTb} TB`, current: plan.id === server.planId ? "current" : current && plan.ramGb > current.ramGb ? "upgrade" : "" }));
+      if (flags.json) out(JSON.stringify(rows, null, 2)); else table(rows, [["id", "PLAN"], ["name", "NAME"], ["size", "SIZE"], ["price", "PRICE"], ["current", ""]]);
+      out("Upgrade with: vibingview server upgrade <plan> --server " + server.name + " (the exact charge is shown when you approve).");
+      return 0;
+    }
+    const simple = { reboot: "server.reboot", start: "server.start", clean: "server.clean", shutdown: "server.shutdown", renew: "server.renew", reinstall: "server.reinstall", delete: "server.delete" };
+    if (simple[sub]) {
+      const result = await approvedAction(simple[sub], { workspaceId: server.id });
+      out(result?.message ?? `${sub} requested for ${server.name}.`);
+      return 0;
+    }
+    if (sub === "billing") {
+      const months = Number(args[1]);
+      if (![1, 6, 12].includes(months)) throw new CliError("Usage: vibingview server billing <1|6|12> [--server <s>]");
+      const result = await approvedAction("server.billing", { workspaceId: server.id, months });
+      out(result?.message ?? `${server.name} is now billed every ${months} month(s) from the next renewal.`);
+      return 0;
+    }
+    if (sub === "auto-renew") {
+      if (!["on", "off"].includes(args[1])) throw new CliError("Usage: vibingview server auto-renew on|off [--server <s>]");
+      await approvedAction("server.auto_renew", { workspaceId: server.id, enabled: args[1] === "on" });
+      out(`Automatic renewal is ${args[1]} for ${server.name}.`);
+      return 0;
+    }
+    if (sub === "upgrade") {
+      if (args[1] === "cancel" || args[1] === "now") {
+        const result = await approvedAction(args[1] === "cancel" ? "server.upgrade_cancel" : "server.upgrade_now", { workspaceId: server.id });
+        out(result?.message ?? "Done.");
+        return 0;
+      }
+      if (!args[1]) throw new CliError("Usage: vibingview server upgrade <plan> [--server <s>] [--at \"YYYY-MM-DD HH:MM\"] (see vibingview server plans)");
+      const plans = await call("/api/plans");
+      const plan = (Array.isArray(plans) ? plans : []).find(item => item.id === args[1] || item.name.toLowerCase() === args[1].toLowerCase());
+      if (!plan) throw new CliError(`Unknown plan ${args[1]}. Run vibingview server plans.`);
+      let scheduledFor;
+      if (flags.at) {
+        // Local time of this computer, like the dashboard's picker.
+        const at = new Date(String(flags.at).replace(" ", "T"));
+        if (Number.isNaN(at.getTime())) throw new CliError('--at must look like "2026-11-02 03:00" (your local time)');
+        scheduledFor = at.toISOString();
+      }
+      const result = await approvedAction("server.upgrade", { workspaceId: server.id, planId: plan.id, when: scheduledFor ? "scheduled" : "now", ...(scheduledFor ? { scheduledFor } : {}) });
+      out(result?.message ?? `Upgrade of ${server.name} to ${plan.name} ${scheduledFor ? "scheduled" : "started"}.`);
+      out("Follow it with vibingview server info " + server.name);
+      return 0;
+    }
+    throw new CliError("Usage: vibingview server list|info|plans|reboot|start|clean|shutdown|upgrade|renew|billing|auto-renew|reinstall|delete");
+  }
+
+  // ----- app management ---------------------------------------------------------------
+  if (command === "app" && ["deployments", "rollback", "settings", "set", "delete"].includes(args[0])) {
+    const sub = args[0];
+    const app = await resolveApp(args[1]);
+    const id = encodeURIComponent(app.id);
+    if (sub === "deployments") {
+      const { deployments = [] } = await call(`/api/apps/${id}/deployments`);
+      if (flags.json) out(JSON.stringify(deployments, null, 2)); else table(deployments.map(d => ({ ...d, finished: d.finished_at ?? "" })), [["revision", "REV"], ["status", "STATUS"], ["trigger", "TRIGGER"], ["created_at", "CREATED"], ["finished", "FINISHED"], ["id", "ID"]]);
+      return 0;
+    }
+    if (sub === "rollback") {
+      if (!flags.to) throw new CliError("Usage: vibingview app rollback [app] --to <revision|deployment-id> (see vibingview app deployments)");
+      const { deployments = [] } = await call(`/api/apps/${id}/deployments`);
+      const target = deployments.find(d => d.id === flags.to || String(d.revision) === String(flags.to));
+      if (!target) throw new CliError(`Deployment ${flags.to} not found for ${app.name}`);
+      if (target.status !== "succeeded") throw new CliError(`Revision ${target.revision} did not succeed; choose a working one.`);
+      if (!(await confirm(`Roll ${app.name} back to revision ${target.revision}? The database and settings are not rolled back.`, flags))) return 1;
+      const result = await call(`/api/apps/${id}/actions`, json("POST", { action: "rollback", deploymentId: target.id }));
+      out(`Rollback to revision ${target.revision} queued${result.deploymentId ? ` (deployment ${result.deploymentId})` : ""}. Check vibingview status ${app.name}.`);
+      return 0;
+    }
+    if (sub === "settings") {
+      const current = await call(`/api/apps/${id}/settings`);
+      const settings = current.application?.build_settings ?? {};
+      if (flags.json) { out(JSON.stringify(settings, null, 2)); return 0; }
+      for (const [key, value] of Object.entries(settings)) if (key !== "dockerfile") out(`${key}: ${value === "" ? "(automatic)" : value}`);
+      if (settings.dockerfile) out("dockerfile: (custom, set)");
+      return 0;
+    }
+    if (sub === "set") {
+      const current = await call(`/api/apps/${id}/settings`);
+      const settings = { ...(current.application?.build_settings ?? {}) };
+      const map = { "root-dir": "rootDirectory", "install-command": "installCommand", "build-command": "buildCommand", "start-command": "startCommand", "output-dir": "outputDirectory" };
+      let changed = 0;
+      for (const [flag, key] of Object.entries(map)) if (typeof flags[flag] === "string") { settings[key] = flags[flag]; changed++; }
+      if (flags.port !== undefined) { const port = Number(flags.port); if (!Number.isInteger(port) || port < 1 || port > 65535) throw new CliError("--port must be 1-65535"); settings.port = port; changed++; }
+      if (flags.technique !== undefined) { const t = String(flags.technique); if (!["1", "2", "3", "4", "5"].includes(t)) throw new CliError("--technique must be 1, 2, 3, 4 or 5"); settings.builder = t === "1" ? "auto" : `technique-${t}`; changed++; }
+      if (typeof flags.dockerfile === "string") { settings.dockerfile = flags.dockerfile === "auto" ? "" : await readFile(path.resolve(flags.dockerfile), "utf8"); changed++; }
+      if (!changed) throw new CliError("Nothing to change. Pass --root-dir, --install-command, --build-command, --start-command, --output-dir, --port, --technique or --dockerfile <file|auto>.");
+      const result = await call(`/api/apps/${id}/settings`, json("PATCH", { settings }));
+      out(`Settings saved for ${app.name}. ${queuedNote(result)}`);
+      return 0;
+    }
+    await approvedAction("app.delete", { applicationId: app.id });
+    out(`${app.name} is being deleted.`);
+    return 0;
+  }
+
+  // ----- domains ---------------------------------------------------------------------
+  if (command === "domains" || command === "domain") {
+    const sub = args[0];
+    if (sub === "owned") {
+      const { domains = [] } = await call("/api/domains");
+      if (flags.json) out(JSON.stringify(domains, null, 2)); else table(domains, [["name", "DOMAIN"], ["status", "STATUS"], ["expiresAt", "EXPIRES"], ["autoRenew", "AUTO-RENEW"], ["id", "ID"]]);
+      return 0;
+    }
+    if (sub === "connect" || sub === "disconnect") {
+      if (!args[1]) throw new CliError(`Usage: vibingview domains ${sub} <domain>${sub === "connect" ? " --app <app>" : ""}`);
+      const { domains = [] } = await call("/api/domains");
+      const owned = domains.find(item => item.id === args[1] || item.name === args[1].toLowerCase());
+      if (!owned) throw new CliError(`${args[1]} is not one of your bought domains (vibingview domains owned)`);
+      if (sub === "connect") { const app = await resolveApp(); await approvedAction("domain.connect", { domainId: owned.id, applicationId: app.id }); out(`${owned.name} now points to ${app.name}. HTTPS is ready in a few minutes.`); }
+      else { await approvedAction("domain.disconnect", { domainId: owned.id }); out(`${owned.name} is disconnected.`); }
+      return 0;
+    }
+    const app = await resolveApp(sub === undefined || sub === "list" ? args[1] : undefined);
+    const id = encodeURIComponent(app.id);
+    const { domains = [] } = await call(`/api/apps/${id}/domains`);
+    const find = host => { const found = domains.find(item => item.hostname === String(host).toLowerCase() || item.id === host); if (!found) throw new CliError(`${host} is not a domain of ${app.name} (vibingview domains)`); return found; };
+    if (sub === undefined || sub === "list") {
+      if (flags.json) out(JSON.stringify(domains, null, 2)); else table(domains.map(d => ({ ...d, verified: d.verified_at ? "yes" : "waiting", https: d.certificate_status })), [["hostname", "DOMAIN"], ["type", "TYPE"], ["verified", "VERIFIED"], ["https", "HTTPS"]]);
+      return 0;
+    }
+    if (sub === "add") {
+      if (!args[1]) throw new CliError("Usage: vibingview domains add <hostname> [--app <app>]");
+      const result = await call(`/api/apps/${id}/domains`, json("POST", { hostname: args[1] }));
+      const added = new Set((result.domains ?? []).map(item => item.hostname));
+      const { domains: now = [] } = await call(`/api/apps/${id}/domains`);
+      out(`Added ${[...added].join(" and ") || args[1]} to ${app.name}. Create these DNS records at your registrar (VibingView then connects the domain by itself within minutes; vibingview domains check ${args[1]} checks now):`);
+      for (const item of now.filter(item => added.has(item.hostname))) for (const record of item.records ?? []) out(`  ${record.type ?? ""} ${record.name ?? record.host ?? ""} → ${record.value ?? ""}`);
+      return 0;
+    }
+    if (sub === "check") {
+      const result = await call(`/api/apps/${id}/domains`, json("PATCH", { domainId: find(args[1]).id }));
+      out(result.verified ? `${args[1]} is connected. HTTPS is issued automatically within minutes.` : result.message ?? `${args[1]} is not ready yet.`);
+      return result.verified ? 0 : 1;
+    }
+    if (sub === "remove") {
+      await approvedAction("domain.remove", { applicationId: app.id, domainId: find(args[1]).id });
+      out(`${args[1]} was removed from ${app.name}.`);
+      return 0;
+    }
+    throw new CliError("Usage: vibingview domains [list|add|check|remove|owned|connect|disconnect]");
+  }
+
+  if (command === "nameservers") {
+    const sub = args[0];
+    const app = await resolveApp(sub === undefined || sub === "list" ? args[1] : undefined);
+    const id = encodeURIComponent(app.id);
+    const { zones = [] } = await call(`/api/apps/${id}/nameservers`);
+    const find = domain => { const found = zones.find(zone => zone.domain === String(domain).toLowerCase().replace(/^www\./, "") || zone.id === domain); if (!found) throw new CliError(`${domain} is not connected with nameservers on ${app.name}`); return found; };
+    if (sub === undefined || sub === "list") {
+      if (flags.json) out(JSON.stringify(zones, null, 2)); else table(zones.map(zone => ({ ...zone, ns: zone.nameservers.join(", ") })), [["domain", "DOMAIN"], ["status", "STATUS"], ["ns", "NAMESERVERS"]]);
+      return 0;
+    }
+    if (sub === "connect") {
+      if (!args[1]) throw new CliError("Usage: vibingview nameservers connect <domain> [--app <app>]");
+      const result = await call(`/api/apps/${id}/nameservers`, json("POST", { domain: args[1] }));
+      const zone = result.zone ?? result;
+      out(`Set these nameservers at your registrar for ${zone.domain ?? args[1]}:\n${(zone.nameservers ?? []).map(ns => `  ${ns}`).join("\n")}\nVibingView checks automatically; run vibingview nameservers check ${args[1]} to check now.`);
+      return 0;
+    }
+    if (sub === "check") {
+      const result = await call(`/api/apps/${id}/nameservers`, json("PATCH", { zoneId: find(args[1]).id, action: "check" }));
+      const status = typeof result.status === "string" ? result.status : result.status?.status ?? result.zone?.status ?? "checked";
+      out(`${args[1]}: ${status}`);
+      return 0;
+    }
+    if (sub === "disconnect") {
+      await approvedAction("nameservers.disconnect", { applicationId: app.id, zoneId: find(args[1]).id });
+      out(`${args[1]} was disconnected. Set your nameservers back at your registrar.`);
+      return 0;
+    }
+    throw new CliError("Usage: vibingview nameservers [list|connect|check|disconnect]");
+  }
+
+  // ----- billing ---------------------------------------------------------------------
+  if (command === "balance") {
+    const { balanceCents = 0 } = await call("/api/account/balance");
+    if (flags.json) out(JSON.stringify({ balanceCents }, null, 2)); else out(`Wallet balance: ${euros(balanceCents)}`);
+    return 0;
+  }
+  if (command === "payments") {
+    const { payments = [], entries = [] } = await call("/api/payments/activity");
+    if (flags.json) { out(JSON.stringify({ payments, entries }, null, 2)); return 0; }
+    table(payments.map(p => ({ ...p, amount: euros(p.amount_cents), date: String(p.created_at).slice(0, 10) })), [["date", "DATE"], ["amount", "AMOUNT"], ["provider", "METHOD"], ["status", "STATUS"]]);
+    return 0;
+  }
+  if (command === "topup") {
+    const amount = Number(String(args[0] ?? "").replace(",", "."));
+    if (!(amount >= 5 && amount <= 1000)) throw new CliError("Usage: vibingview topup <euros 5-1000> [--method card|crypto]");
+    const method = flags.method ?? "card";
+    if (!["card", "crypto"].includes(method)) throw new CliError("--method must be card or crypto");
+    const result = await approvedAction("wallet.topup", { amountCents: Math.round(amount * 100), method });
+    out(`Pay here (the wallet is credited when the payment is confirmed):\n  ${result.checkoutUrl}`);
+    if (!flags["no-browser"]) openBrowser(result.checkoutUrl);
+    return 0;
   }
 
   // ----- catalog apps ------------------------------------------------------------

package/src/mcp.mjs

@@ -46,7 +46,7 @@ async function handle(message) {
   const params = message.params && typeof message.params === "object" && !Array.isArray(message.params) ? message.params : {};
   if (message.method === "initialize") {
     const protocolVersion = SUPPORTED_VERSIONS.includes(params.protocolVersion) ? params.protocolVersion : SUPPORTED_VERSIONS[0];
-    return { protocolVersion, capabilities: { tools: { listChanged: false } }, serverInfo: { name: "vibingview", version: "0.1.3" }, instructions: INSTRUCTIONS };
+    return { protocolVersion, capabilities: { tools: { listChanged: false } }, serverInfo: { name: "vibingview", version: "0.2.0" }, instructions: INSTRUCTIONS };
   }
   if (message.method === "ping") return {};
   if (message.method === "tools/list") {