@vibingview/cli 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VibingView
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# @vibingview/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Command-line interface and stdio MCP bridge for [VibingView](https://vibingview.com): pair your terminal with browser approval, deploy a project directory to your VPS workspace, follow builds, read logs, manage environment variables and databases, and connect AI editors through MCP.
+
+- Node.js 18 or newer. No runtime dependencies.
+- Commands: `vibingview` and `vibingview-mcp`.
+
+```bash
+npx @vibingview/cli login
+npx @vibingview/cli deploy
+npx @vibingview/cli mcp install
+```
+
+Or install it globally: `npm install -g @vibingview/cli`, then run `vibingview …`.
+
+## Choosing the control plane
+
+By default the CLI talks to `https://vibingview.com`. To use another VibingView instance, pass `--url <origin>` (any command) or set `VIBINGVIEW_URL`. `login` stores the origin together with its token, so later commands use the instance you logged in to. Plain `http://` is accepted only for `localhost`.
+
+## Sign in
+
+```bash
+vibingview login            # prints a verification link and pairing code, opens your browser
+vibingview login --no-browser
+vibingview whoami           # account and token permissions
+vibingview logout           # revokes the token on the server and forgets it locally
+```
+
+`login` uses device pairing: it shows a link and a short code, and nothing is authorized until you open the link while signed in, check that the code matches, and explicitly approve it. The token itself is never printed. `vibingview token` shows a masked token; `--show` prints it in full with a warning.
+
+## Deploy
+
+```bash
+vibingview deploy [dir] [--workspace <id|name>] [--name <app>] [--port <n>] [--domain <suffix|hostname>] [--force] [--yes]
+vibingview status [app]
+vibingview logs [app] [--build|--runtime] [--limit <n>] [--ai]
+vibingview restart [app]
+vibingview rebuild [app]
+vibingview workspaces
+vibingview apps
+```
+
+`deploy` packages the directory in memory, excluding `.git`, `node_modules`, build output, virtualenvs, caches, `.env*` files, credentials, private keys, archives, binaries, local databases and large media, and refusing symlinks that escape the project. It skips an unchanged project unless `--force`, uploads it, follows the build until it succeeds or fails, and links the directory in `.vibingview/config.json` (added to `.gitignore`; it never contains your token).
+
+## Environment variables, ports, databases and catalog apps
+
+```bash
+vibingview env get [NAME] [--reveal]        # names only unless --reveal (audited)
+vibingview env set NAME=value [...]         # or: vibingview env set NAME --stdin
+vibingview env remove NAME [...]
+vibingview port set 8080
+vibingview db list [--reveal]
+vibingview db create <name> --engine postgres|mysql|redis|mongodb
+vibingview db link <database-id|name>
+vibingview db unlink
+vibingview app list
+vibingview app create <slug> [--name <app>]
+vibingview app status [app]
+```
+
+`--app <app>` selects an application; otherwise the linked project in the current directory is used.
+
+## MCP for AI editors
+
+```bash
+vibingview mcp install [--client cursor|vscode|claude-code|claude-desktop] [--transport http|stdio] [--dry-run]
+```
+
+`mcp install` merges a `vibingview` server entry into your user-level client configuration, keeps your other servers, backs up the existing file and writes it with owner-only permissions. Cursor, VS Code and Claude Code connect to the remote HTTP endpoint (`<origin>/api/mcp`). Claude Desktop's configuration file only launches local servers, so it gets a stdio entry that runs:
+
+```bash
+npx -y @vibingview/cli mcp
+```
+
+`vibingview mcp` (also available as `vibingview-mcp`) is a thin stdio bridge: it forwards tool calls to the same remote endpoint, so both transports expose identical tools and server-side permission checks. It reads `VIBINGVIEW_URL` and `VIBINGVIEW_TOKEN`; when they are not set, `vibingview mcp` uses the instance and token saved by `vibingview login`.
+
+Your AI client acts with the token's permissions. The CLI token can request restarts/rebuilds and change environment variables and database links. For read-only access, create a read-only token in account settings and set `VIBINGVIEW_MCP_TOKEN` before running `mcp install`. Mutating tools are queued, not completed instantly, and no tool returns secret values.
+
+## Security notes
+
+- The token is stored in `~/.vibingview/config.json` (directory `0700`, file `0600`). `VIBINGVIEW_TOKEN` overrides it.
+- `login` issues a revocable 90-day token with `read`, `deploy` and `apps:manage`. `db create` and `db list --reveal` need a token with `manage`.
+- MCP client configuration files contain your token. Keep them in your user profile, never in a shared repository.
+- Secret values are printed only with `--reveal`, and every reveal is recorded in your account audit log.
+- Requests do not follow redirects, and errors redact the token.
+
+## License
+
+MIT

package/bin/vibingview-mcp.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// Standalone stdio MCP bridge; equivalent to `vibingview mcp` but configured only through
+// VIBINGVIEW_URL / VIBINGVIEW_TOKEN environment variables.
+import "../src/mcp.mjs";

package/bin/vibingview.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from "../src/cli.mjs";
+run();

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@vibingview/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.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",
+  "bin": {
+    "vibingview": "./bin/vibingview.mjs",
+    "vibingview-mcp": "./bin/vibingview-mcp.mjs"
+  },
+  "exports": {
+    ".": "./src/cli.mjs",
+    "./mcp": "./src/mcp.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "vibingview",
+    "cli",
+    "deploy",
+    "hosting",
+    "vps",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "homepage": "https://vibingview.com",
+  "bugs": {
+    "url": "https://vibingview.com/dashboard/support",
+    "email": "support@vibingview.com"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/cli.mjs

@@ -0,0 +1,660 @@
+// VibingView CLI (@vibingview/cli). Zero runtime dependencies; Node.js 18 or newer.
+// Entry points: packages/cli/bin/vibingview.mjs (npm) and the repository's
+// bin/vibingview.mjs / legacy bin/launchdeck.mjs wrappers all call run().
+import { chmod, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+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.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}
+
+Account
+  vibingview login [--url <origin>] [--no-browser]   Pair this terminal through browser approval
+  vibingview login --token <key> [--url <origin>]    Sign in with the account key from your dashboard
+  vibingview logout                                  Revoke the current token and forget it locally
+  vibingview whoami                                  Show the signed-in account and token permissions
+  vibingview token [--show]                          Show the masked token (--show prints it in full)
+  vibingview mcp install [--client ${MCP_CLIENTS.join("|")}] [--transport http|stdio] [--local-bridge] [--dry-run]
+  vibingview mcp                                     Run the stdio MCP bridge (used by AI clients)
+
+Deploy
+  vibingview deploy [dir] [--workspace <id|name>] [--name <app>] [--port <n>] [--domain <suffix|hostname>] [--force] [--yes] [--no-wait] [--timeout <s>]
+  vibingview status [app]                            Application status and recent deployments
+  vibingview logs [app] [--build|--runtime] [--limit <n>] [--ai]
+  vibingview restart|rebuild [app]
+
+Configuration (app defaults to the linked project in .vibingview/config.json)
+  vibingview env get [NAME] [--app <app>] [--reveal]   Names only unless --reveal
+  vibingview env set NAME=value [...] [--app <app>]    or: env set NAME --stdin
+  vibingview env remove NAME [...] [--app <app>]
+  vibingview port set <port> [--app <app>]
+
+Databases
+  vibingview db list [--workspace <id|name>] [--reveal]
+  vibingview db create <name> --engine postgres|mysql|redis|mongodb [--workspace <id|name>]
+  vibingview db link <database-id|name> [--app <app>]
+  vibingview db unlink [--app <app>] [--yes]
+
+One-click apps
+  vibingview app list                                 Catalog recipes
+  vibingview app create <slug> [--name <app>] [--workspace <id|name>] [--domain <suffix>] [--yes]
+  vibingview app status [app]
+
+Other
+  vibingview workspaces | apps
+
+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"]);
+
+export function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") { positional.push(...argv.slice(i + 1)); break; }
+    if (arg === "-y") { flags.yes = true; continue; }
+    if (arg === "-h") { flags.help = true; continue; }
+    if (arg.startsWith("--")) {
+      const [key, inline] = arg.slice(2).split(/=(.*)/s, 2);
+      if (BOOLEAN_FLAGS.has(key)) { flags[key] = true; continue; }
+      if (!VALUE_FLAGS.has(key)) throw new Error(`Unknown option --${key}`);
+      const value = inline ?? argv[++i];
+      if (value === undefined || (inline === undefined && value.startsWith("--"))) throw new Error(`--${key} requires a value`);
+      flags[key] = value;
+      continue;
+    }
+    positional.push(arg);
+  }
+  return { positional, flags };
+}
+
+// ---------------------------------------------------------------------------
+// Credentials
+// ---------------------------------------------------------------------------
+const home = () => os.homedir();
+const configDir = () => path.join(home(), ".vibingview");
+const configFile = () => path.join(configDir(), "config.json");
+const legacyFiles = () => [path.join(home(), ".config", "vibingview", "credentials.json"), path.join(home(), ".config", "launchdeck", "credentials.json")];
+
+async function readJson(file) {
+  try { const value = JSON.parse(await readFile(file, "utf8")); return value && typeof value === "object" && !Array.isArray(value) ? value : {}; } catch { return {}; }
+}
+async function loadConfig() {
+  const config = await readJson(configFile());
+  return { defaultUrl: typeof config.defaultUrl === "string" ? config.defaultUrl : undefined, servers: config.servers && typeof config.servers === "object" ? config.servers : {} };
+}
+async function saveConfig(config) {
+  await mkdir(configDir(), { recursive: true, mode: 0o700 });
+  await chmod(configDir(), 0o700).catch(() => {});
+  const temporary = `${configFile()}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+  await chmod(temporary, 0o600);
+  await rename(temporary, configFile());
+}
+function validBase(value) {
+  let url;
+  try { url = new URL(value); } catch { return false; }
+  if (url.username || url.password || url.search || url.hash || (url.pathname !== "/" && url.pathname !== "")) return false;
+  return url.protocol === "https:" || (url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname));
+}
+
+// ---------------------------------------------------------------------------
+// HTTP
+// ---------------------------------------------------------------------------
+class CliError extends Error {}
+function createClient(base, token) {
+  const redact = text => (token ? String(text).split(token).join("[REDACTED]") : String(text));
+  return async function call(route, init = {}) {
+    let response;
+    try {
+      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(() => ({}));
+    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 });
+    }
+    return body;
+  };
+}
+const json = (method, body) => ({ method, headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+
+// ---------------------------------------------------------------------------
+// Output helpers
+// ---------------------------------------------------------------------------
+const out = text => process.stdout.write(`${text}\n`);
+const warn = text => process.stderr.write(`${text}\n`);
+function table(rows, columns) {
+  if (!rows.length) return out("(none)");
+  const widths = columns.map(([key, label]) => Math.min(60, Math.max(label.length, ...rows.map(row => String(row[key] ?? "").length))));
+  out(columns.map(([, label], i) => label.padEnd(widths[i])).join("  "));
+  for (const row of rows) out(columns.map(([key], i) => String(row[key] ?? "").slice(0, 60).padEnd(widths[i])).join("  "));
+}
+async function confirm(question, flags) {
+  if (flags.yes) return true;
+  if (!process.stdin.isTTY) throw new CliError(`${question} Re-run with --yes to confirm non-interactively.`);
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try { return /^y(es)?$/i.test((await rl.question(`${question} [y/N] `)).trim()); } finally { rl.close(); }
+}
+async function choose(label, items, describe) {
+  if (!process.stdin.isTTY) throw new CliError(`Several ${label}s are available; choose one with --${label}:\n${items.map(item => `  ${describe(item)}`).join("\n")}`);
+  items.forEach((item, index) => warn(`  ${index + 1}) ${describe(item)}`));
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = Number((await rl.question(`Choose a ${label} [1-${items.length}]: `)).trim());
+    if (!Number.isInteger(answer) || answer < 1 || answer > items.length) throw new CliError("No selection made");
+    return items[answer - 1];
+  } finally { rl.close(); }
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8").replace(/\r?\n$/, "");
+}
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+export async function main(argv = process.argv.slice(2)) {
+  const [command, ...rest] = argv;
+  if (!command || ["help", "--help", "-h"].includes(command)) { out(USAGE); return 0; }
+  if (command === "--version" || command === "version") { out(VERSION); return 0; }
+  const { positional: args, flags } = parseArgs(rest);
+  if (flags.help) { out(USAGE); return 0; }
+
+  const config = await loadConfig();
+  const base = (flags.url ?? process.env.VIBINGVIEW_URL ?? process.env.LAUNCHDECK_URL ?? config.defaultUrl ?? DEFAULT_URL).replace(/\/$/, "");
+  if (!validBase(base)) throw new CliError("Use an HTTPS control-plane origin (http is allowed only for localhost), without a path, query or credentials.");
+  const legacy = {};
+  for (const file of legacyFiles().reverse()) Object.assign(legacy, await readJson(file));
+  const envToken = process.env.VIBINGVIEW_TOKEN || process.env.LAUNCHDECK_TOKEN || "";
+  const savedToken = typeof config.servers[base]?.token === "string" ? config.servers[base].token : typeof legacy[base] === "string" ? legacy[base] : "";
+  const token = envToken || savedToken;
+  const tokenSource = envToken ? "environment variable" : config.servers[base]?.token ? configFile() : savedToken ? "legacy credentials file" : "";
+  const call = createClient(base, token);
+  const requireToken = () => { if (!token) throw new CliError("Not signed in. Run vibingview login or set VIBINGVIEW_TOKEN."); };
+
+  // ----- account -------------------------------------------------------------
+  if (command === "login") {
+    // --token: save the account key shown in the dashboard instead of pairing through the browser.
+    if (typeof flags.token === "string") {
+      if (!/^ld_[A-Za-z0-9_-]{32,}$/.test(flags.token)) throw new CliError("That does not look like a VibingView key (it starts with ld_).");
+      const info = await createClient(base, flags.token)("/api/cli/session");
+      config.servers[base] = { url: base, token: flags.token, savedAt: new Date().toISOString() };
+      config.defaultUrl = base;
+      await saveConfig(config);
+      out(`Signed in as ${info.user?.email ?? "your account"} on ${base}. Key saved to ${configFile()} (owner-only permissions).`);
+      return 0;
+    }
+    const session = await createClient(base, "")("/api/cli/authorize", json("POST", { action: "start" }));
+    const verification = new URL(session.verificationUri);
+    out(`Open ${session.verificationUri}\nConfirm this pairing code in the browser: ${session.userCode}\nWaiting for your explicit browser approval…`);
+    if (!flags["no-browser"] && verification.origin === new URL(base).origin) openBrowser(verification.toString());
+    const deadline = Date.now() + session.expiresIn * 1000;
+    while (Date.now() < deadline) {
+      await sleep(Math.max(1, session.interval) * 1000);
+      const result = await createClient(base, "")("/api/cli/authorize", json("POST", { action: "poll", deviceCode: session.deviceCode }));
+      if (result.status === "authorized") {
+        // The origin is stored with its token and becomes the default, so later commands use this instance.
+        config.servers[base] = { url: base, token: result.token, savedAt: new Date().toISOString() };
+        config.defaultUrl = base;
+        await saveConfig(config);
+        out(`Authorized for ${base}. Token saved to ${configFile()} (owner-only permissions). Revoke it with vibingview logout or in account settings.`);
+        return 0;
+      }
+      if (["denied", "expired", "consumed"].includes(result.status)) throw new CliError(`Authorization ${result.status}`);
+    }
+    throw new CliError("Authorization expired");
+  }
+
+  if (command === "logout") {
+    if (!token) { out("Not signed in."); return 0; }
+    try {
+      const result = await call("/api/cli/session", { method: "DELETE" });
+      out(result.revoked === false ? "Your account key stays active for your other tools. Rotate it in the dashboard (Connectivity) if it may be exposed." : "Token revoked on the control plane.");
+    }
+    catch (error) { if (error.status === 401) out("The token was already invalid or revoked."); else throw error; }
+    if (config.servers[base]) { delete config.servers[base]; await saveConfig(config); }
+    for (const file of legacyFiles()) {
+      const values = await readJson(file);
+      if (values[base]) { delete values[base]; await writeFile(file, JSON.stringify(values), { mode: 0o600 }); }
+    }
+    if (envToken) warn("The token came from VIBINGVIEW_TOKEN; remove it from your environment too.");
+    out("Signed out.");
+    return 0;
+  }
+
+  if (command === "whoami") {
+    requireToken();
+    const info = await call("/api/cli/session");
+    if (flags.json) { out(JSON.stringify(info, null, 2)); return 0; }
+    out(`${info.user.displayName} <${info.user.email}>${info.user.emailVerified ? "" : " (email not verified)"}`);
+    out(`Control plane: ${base}`);
+    out(`Token: ${info.token.name} (${info.token.prefix}…) permissions: ${info.token.scopes.join(", ")}${info.token.expiresAt ? `; expires ${new Date(info.token.expiresAt).toISOString().slice(0, 10)}` : ""}`);
+    return 0;
+  }
+
+  if (command === "token") {
+    requireToken();
+    if (flags.show) {
+      warn("Warning: the full token grants account access. Do not paste it into chats, issues, logs or shared files.");
+      out(token);
+      return 0;
+    }
+    out(`Token: ${maskToken(token)} (from ${tokenSource})`);
+    try {
+      const info = await call("/api/cli/session");
+      out(`Name: ${info.token.name}\nPermissions: ${info.token.scopes.join(", ")}\nExpires: ${info.token.expiresAt ?? "never"}\nLast used: ${info.token.lastUsedAt ?? "never"}`);
+    } catch (error) { out(`Status: ${error.message}`); }
+    out("Use --show to print the full token.");
+    return 0;
+  }
+
+  if (command === "mcp" && (args[0] === undefined || args[0] === "serve")) {
+    // stdio bridge for AI clients: stdout carries JSON-RPC only, so nothing is printed here.
+    // Explicit environment wins; otherwise use the instance and token from `vibingview login`.
+    process.env.VIBINGVIEW_URL = base;
+    if (!process.env.VIBINGVIEW_TOKEN && !process.env.LAUNCHDECK_TOKEN) process.env.VIBINGVIEW_TOKEN = process.env.VIBINGVIEW_MCP_TOKEN || token;
+    await import("./mcp.mjs");
+    return 0;
+  }
+
+  if (command === "mcp") {
+    if (args[0] !== "install") throw new CliError("Usage: vibingview mcp [install [--client <client>] [--transport http|stdio] [--local-bridge] [--dry-run]]");
+    const mcpToken = process.env.VIBINGVIEW_MCP_TOKEN || token;
+    if (!mcpToken) throw new CliError("Not signed in. Run vibingview login (or set VIBINGVIEW_MCP_TOKEN to a dedicated token) first.");
+    let clients;
+    if (flags.client) {
+      if (!MCP_CLIENTS.includes(flags.client)) throw new CliError(`--client must be one of ${MCP_CLIENTS.join(", ")}`);
+      clients = [flags.client];
+    } else {
+      clients = [];
+      for (const client of MCP_CLIENTS) {
+        const file = mcpConfigPath(client, { home: home() });
+        if (await stat(client === "claude-code" ? file : path.dirname(file)).then(() => true, () => false)) clients.push(client);
+      }
+      if (!clients.length) throw new CliError(`No supported AI client configuration was found. Choose one with --client ${MCP_CLIENTS.join("|")}.`);
+    }
+    try {
+      const info = await createClient(base, mcpToken)("/api/cli/session");
+      warn(`Your AI client will act with this token's permissions: ${info.token.scopes.join(", ")}. ${info.token.scopes.some(scope => scope !== "read") ? "It can request restarts/rebuilds" + (info.token.scopes.some(scope => scope === "apps:manage" || scope === "manage") ? " and change app environment variables/database links" : "") + ". For read-only access, create a read-only token in account settings and set VIBINGVIEW_MCP_TOKEN before running this command." : "Read-only."}`);
+    } catch (error) { warn(`Could not confirm token permissions: ${error.message}`); }
+    // stdio entries launch the published package (`npx -y @vibingview/cli mcp`). --local-bridge instead
+    // points at this installation's bridge file, for unpublished/development checkouts.
+    const scriptPath = flags["local-bridge"] ? path.join(path.dirname(fileURLToPath(import.meta.url)), "mcp.mjs") : undefined;
+    for (const client of clients) {
+      const transport = flags.transport ?? defaultTransport(client);
+      const result = await installMcpConfig(client, { home: home(), transport, origin: base, token: mcpToken, scriptPath, nodePath: process.execPath, dryRun: Boolean(flags["dry-run"]) });
+      if (transport === "stdio" && !scriptPath) warn(`The stdio entry runs npx -y ${NPM_PACKAGE} mcp, which requires ${NPM_PACKAGE} to be published to npm. From an unpublished checkout, add --local-bridge.`);
+      out(`${flags["dry-run"] ? "Would write" : "Wrote"} ${client} (${transport}) → ${result.file}${result.backup ? ` (backup: ${result.backup})` : ""}`);
+      out(JSON.stringify({ vibingview: maskedEntry(result.entry, mcpToken) }, null, 2));
+    }
+    if (!flags["dry-run"]) out("Restart or reload the client, then review the VibingView tools before approving any action.");
+    return 0;
+  }
+
+  requireToken();
+
+  // ----- lookups -------------------------------------------------------------
+  const cwd = process.cwd();
+  const project = await readProjectConfig(cwd);
+  const workspacesList = async () => (await call("/api/workspaces")).workspaces ?? [];
+  const isRunning = workspace => String(workspace.status).toUpperCase() === "RUNNING";
+  async function resolveWorkspace(reference, { running = true } = {}) {
+    const all = await workspacesList();
+    const pool = running ? all.filter(isRunning) : all;
+    const ref = reference ?? project.workspaceId;
+    if (ref) {
+      const found = all.find(workspace => workspace.id === ref || workspace.name === ref);
+      if (!found) throw new CliError(`Workspace ${ref} not found`);
+      if (running && !isRunning(found)) throw new CliError(`Workspace ${found.name} is ${String(found.status).toLowerCase()}, not running`);
+      return found;
+    }
+    if (!pool.length) throw new CliError(running ? "No running workspace. Order or start one in the dashboard first." : "No workspaces found.");
+    if (pool.length === 1) return pool[0];
+    return choose("workspace", pool, workspace => `${workspace.name} (${workspace.id})`);
+  }
+  async function resolveApp(reference) {
+    const ref = reference ?? flags.app ?? project.applicationId;
+    if (!ref) throw new CliError("No application specified. Pass an app ID/name (or --app), or run inside a deployed project directory.");
+    const { applications = [] } = await call("/api/apps");
+    let matches = applications.filter(app => app.id === ref || app.name === ref);
+    if (matches.length > 1) {
+      const workspace = flags.workspace ?? project.workspaceId;
+      matches = matches.filter(app => !workspace || app.workspaceId === workspace);
+    }
+    if (!matches.length) throw new CliError(`Application ${ref} not found`);
+    if (matches.length > 1) throw new CliError(`Several applications are named ${ref}; pass --workspace or the application ID.`);
+    return matches[0];
+  }
+
+  // ----- listing ---------------------------------------------------------------
+  if (command === "workspaces") {
+    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;
+  }
+  if (command === "apps") {
+    const { applications = [] } = await call("/api/apps");
+    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") {
+    if (args.length === 3 && args[2].toLowerCase().endsWith(".zip")) return legacyDeploy(call, args);
+    const directory = path.resolve(args[0] ?? ".");
+    const linked = await readProjectConfig(directory);
+    let packageName;
+    try { packageName = JSON.parse(await readFile(path.join(directory, "package.json"), "utf8")).name; } catch {}
+    await ensureGitignore(directory);
+    const pkg = await packageProject(directory);
+    out(`Packaged ${pkg.files.length} files (${(pkg.archive.length / 1024).toFixed(1)} KB, sha256 ${pkg.sha256.slice(0, 12)}…); excluded ${pkg.skipped.length} paths.`);
+    for (const message of pkg.warnings) warn(message);
+    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.");
+    const catalog = await call("/api/catalog");
+    const suffixes = catalog.domains ?? [];
+    let suffix = linked.domainSuffix;
+    let customDomain;
+    if (flags.domain) {
+      const value = flags.domain.toLowerCase().replace(/^\.+/, "");
+      if (suffixes.includes(value)) suffix = value;
+      else if (/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/.test(value)) customDomain = value;
+      else throw new CliError(`--domain must be one of ${suffixes.join(", ")} or a custom hostname`);
+    }
+    if (!suffix || !suffixes.includes(suffix)) suffix = suffixes[0];
+    const port = flags.port === undefined ? undefined : Number(flags.port);
+    if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535)) throw new CliError("--port must be 1-65535");
+
+    let deploymentId;
+    let workspaceId;
+    if (app) {
+      workspaceId = app.workspaceId;
+      if (port !== undefined && port !== app.internalPort) warn(`The port is unchanged by redeploys; run vibingview port set ${port} to change it.`);
+      if (!(await confirm(`Redeploy ${app.name} (${app.url ?? app.id}) with this source?`, flags))) return 1;
+      const form = new FormData();
+      form.set("file", new Blob([pkg.archive], { type: "application/zip" }), `${app.name}.zip`);
+      deploymentId = (await call(`/api/apps/${encodeURIComponent(app.id)}/settings`, { method: "PATCH", body: form })).deploymentId;
+    } else {
+      const workspace = await resolveWorkspace(flags.workspace);
+      workspaceId = workspace.id;
+      const name = flags.name ?? linked.name ?? inferAppName(packageName, path.basename(directory));
+      if (!name || !/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/.test(name)) throw new CliError("Choose an application name with --name (3-40 lowercase letters, numbers or hyphens).");
+      if (!(await confirm(`Create ${name} on workspace ${workspace.name} (*.${suffix})${port ? ` listening on port ${port}` : ""}?`, flags))) return 1;
+      const form = new FormData();
+      form.set("workspaceId", workspace.id);
+      form.set("name", name);
+      if (suffix) form.set("domainSuffix", suffix);
+      if (port !== undefined) form.set("port", String(port));
+      form.set("file", new Blob([pkg.archive], { type: "application/zip" }), `${name}.zip`);
+      app = (await call("/api/apps", { method: "POST", body: form })).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() };
+    await writeProjectConfig(directory, state);
+    out(`Uploaded. Application ${app.name} (${app.id})${app.url ? ` → ${app.url}` : ""}`);
+
+    if (customDomain && customDomain !== linked.customDomain) {
+      try {
+        const result = await call(`/api/apps/${encodeURIComponent(app.id)}/domains`, json("POST", { hostname: customDomain }));
+        out(`Custom domain ${customDomain} added. Prove ownership and route traffic with DNS:\n  CNAME ${result.instructions.cname.name} → ${result.instructions.cname.value}\n  or TXT ${result.instructions.txt.name} = ${result.instructions.txt.value}\nThen verify it in the dashboard. HTTPS is issued only after verification.`);
+      } catch (error) { warn(`Could not add custom domain: ${error.message}`); }
+    }
+
+    if (flags["no-wait"]) { await writeProjectConfig(directory, { ...state, lastHash: pkg.sha256 }); out("Build queued. Follow it with vibingview logs --build."); return 0; }
+    const result = await waitForDeployment(call, app.id, deploymentId, Number(flags.timeout ?? 300) * 1000);
+    if (result === "succeeded") {
+      await writeProjectConfig(directory, { ...state, lastHash: pkg.sha256 });
+      out(`Deployment succeeded and passed its startup check.${app.url ? ` Live at ${app.url}` : ""}`);
+      return 0;
+    }
+    if (result === "failed") { warn("Deployment failed. Inspect it with vibingview logs --build, fix the issue and deploy again."); return 1; }
+    warn("Still building after the timeout. Check progress with vibingview status or vibingview logs --build.");
+    return 1;
+  }
+
+  // ----- status / logs -----------------------------------------------------------
+  if (command === "status" || (command === "app" && args[0] === "status")) {
+    const app = await resolveApp(command === "app" ? args[1] : args[0]);
+    const { deployments = [] } = await call(`/api/apps/${encodeURIComponent(app.id)}/deployments`).catch(() => ({ deployments: [] }));
+    if (flags.json) { out(JSON.stringify({ application: app, deployments: deployments.slice(0, 5) }, null, 2)); return 0; }
+    out(`${app.name} (${app.id})\n  Status:    ${app.status}\n  URL:       ${app.url ?? "(private)"}\n  Workspace: ${app.workspaceId}\n  Port:      ${app.internalPort}\n  Source:    ${app.source}`);
+    if (deployments.length) { out("Recent deployments:"); table(deployments.slice(0, 5).map(d => ({ ...d, finished: d.finished_at ?? "" })), [["revision", "REV"], ["status", "STATUS"], ["created_at", "CREATED"], ["finished", "FINISHED"]]); }
+    return 0;
+  }
+
+  if (command === "logs") {
+    const legacyKind = ["build", "runtime"].includes(args[1]) ? args[1] : undefined;
+    const app = await resolveApp(args[0] && !["build", "runtime"].includes(args[0]) ? args[0] : undefined);
+    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.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}] ` : ""}${line.message}`);
+      out("```\n\nSecrets are redacted by the workspace agent before storage, but review the output before sharing it.");
+    } else for (const line of logs) out(line.message);
+    if (!logs.length) warn(`No ${kind} logs yet.`);
+    return 0;
+  }
+
+  if (command === "restart" || command === "rebuild") {
+    const app = await resolveApp(args[0]);
+    if (!(await confirm(`${command === "restart" ? "Restart" : "Rebuild"} ${app.name}? Traffic may be briefly interrupted.`, flags))) return 1;
+    const result = await call(`/api/apps/${encodeURIComponent(app.id)}/actions`, json("POST", { action: command }));
+    out(`${command === "restart" ? "Restart" : "Rebuild"} queued${result.deploymentId ? ` (deployment ${result.deploymentId})` : ""}. Queued is not completed; check vibingview status.`);
+    return 0;
+  }
+
+  // ----- environment -------------------------------------------------------------
+  if (command === "env") {
+    const sub = args[0];
+    if (!["get", "list", "set", "remove", "rm", "unset"].includes(sub)) {
+      // Legacy form: env <app-id> <NAME> <value>
+      const [id, name, value] = args;
+      if (!id || !name || value === undefined) throw new CliError("Usage: vibingview env get|set|remove … (see vibingview help)");
+      warn("Deprecated: use vibingview env set NAME=value --app <app>. Values passed as arguments may be kept in shell history.");
+      const result = await call(`/api/apps/${encodeURIComponent(id)}/environment`, json("POST", { name, value }));
+      out(`Set ${name}. Redeploy queued (deployment ${result.deploymentId}).`);
+      return 0;
+    }
+    const app = await resolveApp();
+    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" }));
+        const selected = variables.filter(variable => !wanted || variable.name === wanted);
+        if (wanted && !selected.length) throw new CliError(`${wanted} is not set`);
+        for (const variable of selected) out(`${variable.name}=${variable.value}`);
+        return 0;
+      }
+      const { variables = [] } = await call(`/api/apps/${encodeURIComponent(app.id)}/environment`);
+      if (wanted) {
+        if (!variables.some(variable => variable.name === wanted)) throw new CliError(`${wanted} is not set`);
+        out(`${wanted} is set (value hidden; add --reveal to print it).`);
+      } else {
+        for (const variable of variables) out(variable.name);
+        if (!variables.length) warn("No environment variables.");
+        else warn("Values hidden; add --reveal to print them.");
+      }
+      return 0;
+    }
+    if (sub === "set") {
+      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();
+      } else {
+        if (!pairs.length) throw new CliError("Usage: vibingview env set NAME=value [NAME=value…] or NAME --stdin");
+        for (const pair of pairs) {
+          const index = pair.indexOf("=");
+          if (index < 1) throw new CliError(`Expected NAME=value, got ${pair.split("=")[0]}`);
+          environment[pair.slice(0, index)] = pair.slice(index + 1);
+        }
+      }
+      for (const name of Object.keys(environment)) if (!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(name)) throw new CliError(`Invalid variable name ${name}`);
+      const result = await call(`/api/apps/${encodeURIComponent(app.id)}/settings`, json("PATCH", { environment }));
+      out(`Set ${Object.keys(environment).join(", ")} on ${app.name}. Values stored encrypted. Redeploy queued (deployment ${result.deploymentId}).`);
+      return 0;
+    }
+    const names = args.slice(1);
+    if (!names.length) throw new CliError("Usage: vibingview env remove NAME [NAME…]");
+    const result = await call(`/api/apps/${encodeURIComponent(app.id)}/settings`, json("PATCH", { deleteVariables: names }));
+    out(`Removed ${names.join(", ")} from ${app.name}. Redeploy queued (deployment ${result.deploymentId}).`);
+    return 0;
+  }
+
+  if (command === "port") {
+    if (args[0] !== "set" || !args[1]) throw new CliError("Usage: vibingview port set <port> [--app <app>]");
+    const port = Number(args[1]);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new CliError("Port must be 1-65535");
+    const app = await resolveApp();
+    const current = await call(`/api/apps/${encodeURIComponent(app.id)}/settings`);
+    const result = await call(`/api/apps/${encodeURIComponent(app.id)}/settings`, json("PATCH", { settings: { ...(current.application?.build_settings ?? {}), port } }));
+    out(`${app.name} now expects port ${port}. Redeploy queued (deployment ${result.deploymentId}).`);
+    return 0;
+  }
+
+  // ----- databases ---------------------------------------------------------------
+  if (command === "db") {
+    const sub = args[0];
+    if (sub === "list") {
+      const workspaces = flags.workspace || project.workspaceId ? [await resolveWorkspace(flags.workspace, { running: false })] : await workspacesList();
+      const rows = [];
+      for (const workspace of workspaces) {
+        const { databases = [] } = await call(`/api/workspaces/${encodeURIComponent(workspace.id)}/databases`);
+        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.");
+        for (const row of rows) {
+          const { connectionString } = await call(`/api/workspaces/${encodeURIComponent(row.workspaceId)}/databases`, json("PATCH", { databaseId: row.id, action: "reveal" }));
+          out(`${row.name} (${row.engine}, ${row.status}): ${connectionString}`);
+        }
+        return 0;
+      }
+      if (flags.json) out(JSON.stringify(rows, null, 2)); else table(rows, [["id", "ID"], ["name", "NAME"], ["engine", "ENGINE"], ["version", "VERSION"], ["status", "STATUS"], ["linked_apps", "APPS"], ["workspace", "WORKSPACE"]]);
+      return 0;
+    }
+    if (sub === "create") {
+      const name = args[1];
+      const engine = flags.engine ?? "postgres";
+      if (!name) throw new CliError("Usage: vibingview db create <name> --engine postgres|mysql|redis|mongodb");
+      if (!["postgres", "mysql", "redis", "mongodb"].includes(engine)) throw new CliError("--engine must be postgres, mysql, redis or mongodb");
+      const workspace = await resolveWorkspace(flags.workspace);
+      const result = await call(`/api/workspaces/${encodeURIComponent(workspace.id)}/databases`, json("POST", { name, engine }));
+      out(`Database ${result.database.name} (${result.database.engine} ${result.database.version}) is ${result.database.status} on ${workspace.name}. ID ${result.database.id}\nLink it with vibingview db link ${result.database.name}.`);
+      return 0;
+    }
+    if (sub === "link" || sub === "unlink") {
+      const app = await resolveApp();
+      let databaseId = null;
+      if (sub === "link") {
+        if (!args[1]) throw new CliError("Usage: vibingview db link <database-id|name> [--app <app>]");
+        const { databases = [] } = await call(`/api/workspaces/${encodeURIComponent(app.workspaceId)}/databases`);
+        const found = databases.find(item => item.id === args[1] || item.name === args[1]);
+        if (!found) throw new CliError(`Database ${args[1]} not found on the application's workspace`);
+        databaseId = found.id;
+      } else if (!(await confirm(`Unlink the database from ${app.name}? DATABASE_URL will be removed and the app redeployed.`, flags))) return 1;
+      const result = await call(`/api/apps/${encodeURIComponent(app.id)}/settings`, json("PATCH", { databaseId }));
+      out(`${sub === "link" ? `Linked database to ${app.name} as DATABASE_URL` : `Unlinked database from ${app.name}`}. Redeploy queued (deployment ${result.deploymentId}).`);
+      return 0;
+    }
+    throw new CliError("Usage: vibingview db list|create|link|unlink");
+  }
+
+  // ----- catalog apps ------------------------------------------------------------
+  if (command === "app") {
+    const sub = args[0];
+    if (sub === "list") {
+      const { apps = [] } = await call("/api/catalog");
+      if (flags.json) out(JSON.stringify(apps, null, 2)); else table(apps.map(app => ({ ...app, available: app.available ? "yes" : "operator image required" })), [["slug", "SLUG"], ["name", "NAME"], ["category", "CATEGORY"], ["available", "AVAILABLE"]]);
+      return 0;
+    }
+    if (sub === "create") {
+      const slug = args[1];
+      if (!slug) throw new CliError("Usage: vibingview app create <slug> [--name <app>] [--workspace <id|name>]");
+      const catalog = await call("/api/catalog");
+      const recipe = (catalog.apps ?? []).find(app => app.slug === slug);
+      if (!recipe) throw new CliError(`Unknown catalog app ${slug}. Run vibingview app list.`);
+      if (!recipe.available) throw new CliError(`${recipe.name} needs an operator-configured image on this control plane.`);
+      const suffixes = catalog.domains ?? [];
+      const suffix = flags.domain ? flags.domain.toLowerCase().replace(/^\.+/, "") : suffixes[0];
+      if (!suffixes.includes(suffix)) throw new CliError(`--domain must be one of ${suffixes.join(", ")}`);
+      const workspace = await resolveWorkspace(flags.workspace);
+      const name = flags.name ?? slug;
+      if (!(await confirm(`Create ${recipe.name} as ${name} on ${workspace.name}${recipe.database ? ` (also creates a private ${recipe.database} database)` : ""}?`, flags))) return 1;
+      const { application } = await call("/api/apps", json("POST", { workspaceId: workspace.id, name, template: slug, domainSuffix: suffix }));
+      out(`${recipe.name} is deploying as ${application.name} (${application.id})${application.url ? ` → ${application.url}` : ""}.\n${recipe.setup}\nSetup access and generated secrets are available in the dashboard. Check progress with vibingview app status ${application.id}.`);
+      return 0;
+    }
+    throw new CliError("Usage: vibingview app list|create|status");
+  }
+
+  throw new CliError(`Unknown command: ${command}\n\n${USAGE}`);
+}
+
+async function legacyDeploy(call, [workspaceId, name, file]) {
+  warn("Deprecated form. Prefer: vibingview deploy [dir] --workspace <id> --name <app>");
+  const form = new FormData();
+  form.set("workspaceId", workspaceId);
+  form.set("name", name);
+  form.set("file", new Blob([await readFile(file)], { type: "application/zip" }), path.basename(file));
+  const { application } = await call("/api/apps", { method: "POST", body: form });
+  out(`Uploaded ${application.name} (${application.id}). Follow the build with vibingview logs ${application.id} --build.`);
+  return 0;
+}
+
+async function waitForDeployment(call, applicationId, deploymentId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let printed = 0;
+  let lastStatus = "";
+  while (Date.now() < deadline) {
+    const [{ deployments = [] }, { logs = [] }] = await Promise.all([
+      call(`/api/apps/${encodeURIComponent(applicationId)}/deployments`).catch(() => ({})),
+      call(`/api/apps/${encodeURIComponent(applicationId)}/logs?kind=build&limit=1000`).catch(() => ({})),
+    ]);
+    const deployment = deployments.find(item => item.id === deploymentId) ?? deployments[0];
+    if (deployment && deployment.id === deploymentId) {
+      for (const line of logs.slice(printed)) out(`  ${line.message}`);
+      printed = Math.max(printed, logs.length);
+    }
+    const status = deployment?.status ?? "queued";
+    if (status !== lastStatus) { out(`… ${status}`); lastStatus = status; }
+    if (status === "succeeded" || status === "failed") return status;
+    await sleep(2500);
+  }
+  return "timeout";
+}
+
+function openBrowser(url) {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try { execFile(command, args, { stdio: "ignore" }, () => {}).unref?.(); } catch {}
+}
+
+/** Run the CLI as a process: sets the exit code and prints errors without stack traces or tokens. */
+export function run(argv = process.argv.slice(2)) {
+  return main(argv).then(code => { process.exitCode = code ?? 0; }, error => {
+    process.stderr.write(`${error instanceof CliError ? error.message : `Unexpected error: ${error.message ?? error}`}\n`);
+    process.exitCode = 1;
+  });
+}

package/src/lib/mcp-install.mjs

@@ -0,0 +1,98 @@
+// Writes VibingView MCP entries into user-level AI client configuration files.
+// Existing servers and settings are preserved; files are backed up first and
+// written with owner-only permissions because the entry contains a token.
+import { chmod, copyFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+export const MCP_CLIENTS = ["vscode", "cursor", "claude-code", "claude-desktop"];
+export const SERVER_NAME = "vibingview";
+/** npm package whose `mcp` subcommand runs the stdio bridge. */
+export const NPM_PACKAGE = "@vibingview/cli";
+/** Command + args that launch the stdio bridge from the published package (no local paths). */
+export const NPX_BRIDGE = { command: "npx", args: ["-y", NPM_PACKAGE, "mcp"] };
+
+/** Mask a bearer token for display: keeps a short prefix and the last four characters. */
+export function maskToken(token) {
+  if (typeof token !== "string" || token.length < 12) return "••••";
+  return `${token.slice(0, 6)}…${token.slice(-4)}`;
+}
+
+/** User-level configuration path for a client. */
+export function mcpConfigPath(client, { home, platform = process.platform, env = process.env }) {
+  const appData = env.APPDATA || path.join(home, "AppData", "Roaming");
+  const xdg = env.XDG_CONFIG_HOME || path.join(home, ".config");
+  const userData = platform === "darwin" ? path.join(home, "Library", "Application Support") : platform === "win32" ? appData : xdg;
+  switch (client) {
+    case "cursor": return path.join(home, ".cursor", "mcp.json");
+    case "vscode": return path.join(userData, "Code", "User", "mcp.json");
+    case "claude-code": return path.join(home, ".claude.json");
+    case "claude-desktop": return path.join(userData, "Claude", "claude_desktop_config.json");
+    default: throw new Error(`Unsupported client ${client}. Use one of: ${MCP_CLIENTS.join(", ")}`);
+  }
+}
+
+/** Claude Desktop's config file only launches local (stdio) servers. */
+export function defaultTransport(client) {
+  return client === "claude-desktop" ? "stdio" : "http";
+}
+
+/** The server entry for one client. */
+export function mcpServerEntry(client, { transport = defaultTransport(client), origin, token, scriptPath, nodePath = "node" }) {
+  if (!MCP_CLIENTS.includes(client)) throw new Error(`Unsupported client ${client}`);
+  if (!token) throw new Error("A VibingView token is required");
+  if (transport === "http") {
+    if (client === "claude-desktop") throw new Error("Claude Desktop's config file supports local stdio servers only; use --transport stdio or add the remote URL as a custom connector in Claude Desktop settings.");
+    const url = `${origin.replace(/\/$/, "")}/api/mcp`;
+    const headers = { Authorization: `Bearer ${token}` };
+    return client === "cursor" ? { url, headers } : { type: "http", url, headers };
+  }
+  if (transport !== "stdio") throw new Error("Transport must be http or stdio");
+  // Default: the published package via npx. An explicit absolute scriptPath (--local-bridge) runs a local bridge file.
+  if (scriptPath !== undefined && !path.isAbsolute(scriptPath)) throw new Error("The stdio connector needs an absolute script path");
+  const launch = scriptPath ? { command: nodePath, args: [scriptPath] } : { command: NPX_BRIDGE.command, args: [...NPX_BRIDGE.args] };
+  const entry = { ...launch, env: { VIBINGVIEW_URL: origin, VIBINGVIEW_TOKEN: token } };
+  return client === "vscode" ? { type: "stdio", ...entry } : entry;
+}
+
+/** Merge the entry into existing JSON text without touching other servers. */
+export function mergeMcpConfig(existingText, client, entry) {
+  let config = {};
+  if (existingText && existingText.trim()) {
+    try { config = JSON.parse(existingText); } catch { throw new Error("The existing configuration is not plain JSON (it may contain comments). Add the entry manually."); }
+    if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("The existing configuration is not a JSON object");
+  }
+  const key = client === "vscode" ? "servers" : "mcpServers";
+  const servers = config[key] && typeof config[key] === "object" && !Array.isArray(config[key]) ? config[key] : {};
+  return { ...config, [key]: { ...servers, [SERVER_NAME]: entry } };
+}
+
+/** Replace the token with its masked form for printing. */
+export function maskedEntry(entry, token) {
+  return JSON.parse(JSON.stringify(entry).split(token).join(maskToken(token)));
+}
+
+/**
+ * Install the entry. Returns {file, backup, entry}. Never deletes or reorders
+ * other servers. A backup copy (owner-only) is written when the file existed.
+ */
+export async function installMcpConfig(client, options) {
+  const file = options.file ?? mcpConfigPath(client, options);
+  const entry = mcpServerEntry(client, options);
+  let existing = "";
+  let existed = false;
+  try { existing = await readFile(file, "utf8"); existed = true; } catch (error) { if (error.code !== "ENOENT") throw error; }
+  const merged = mergeMcpConfig(existing, client, entry);
+  if (options.dryRun) return { file, backup: undefined, entry, merged };
+  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  let backup;
+  if (existed) {
+    backup = `${file}.vibingview-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+    await copyFile(file, backup);
+    await chmod(backup, 0o600);
+  }
+  const temporary = `${file}.vibingview-${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(merged, null, 2) + "\n", { mode: 0o600 });
+  await chmod(temporary, 0o600);
+  await rename(temporary, file);
+  return { file, backup, entry, merged };
+}

package/src/lib/project.mjs

@@ -0,0 +1,160 @@
+// Project scanning, packaging and linked-project configuration for the CLI.
+// Pure Node.js; no runtime dependencies.
+import { createHash } from "node:crypto";
+import { lstat, readdir, readFile, realpath, stat, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createZip, MAX_ZIP_ENTRIES } from "./zip.mjs";
+
+export const MAX_ARCHIVE_BYTES = 50 * 1024 * 1024;
+export const MAX_SOURCE_BYTES = 500 * 1024 * 1024;
+export const PROJECT_DIR = ".vibingview";
+export const LEGACY_PROJECT_DIR = ".vibed";
+
+const EXCLUDED_DIRECTORIES = new Set([
+  "node_modules", "dist", "build", "coverage", "venv", "__pycache__", "bower_components", "jspm_packages",
+]);
+const SECRET_FILE_NAMES = new Set([
+  "credentials", "credentials.json", "credentials.yml", "credentials.yaml", "secrets.json", "secrets.yml", "secrets.yaml",
+  "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519", "known_hosts", "authorized_keys", "service-account.json",
+  ".npmrc", ".pypirc", ".netrc", ".git-credentials", ".htpasswd", ".pgpass", ".my.cnf", ".dockercfg",
+]);
+const EXCLUDED_EXTENSIONS = new Set([
+  // private keys and certificates bundles
+  ".pem", ".key", ".p12", ".pfx", ".jks", ".keystore", ".ppk", ".gpg", ".kdbx",
+  // archives
+  ".zip", ".tar", ".gz", ".tgz", ".bz2", ".xz", ".7z", ".rar", ".zst",
+  // binaries and compiled artefacts
+  ".exe", ".dll", ".so", ".dylib", ".bin", ".o", ".a", ".obj", ".class", ".jar", ".war", ".pyc", ".pyo", ".dmg", ".iso", ".img", ".msi", ".deb", ".rpm", ".apk",
+  // local databases
+  ".sqlite", ".sqlite3", ".db",
+  // large media
+  ".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v", ".wmv", ".flv", ".mp3", ".wav", ".flac", ".aac", ".ogg", ".psd", ".ai", ".sketch",
+  // logs
+  ".log",
+]);
+const ALLOWED_DOTFILES = new Set([".dockerignore", ".nvmrc", ".node-version", ".python-version", ".tool-versions", ".gitignore", ".htaccess", ".babelrc", ".browserslistrc", ".prettierrc", ".editorconfig", ".npmignore", ".eslintrc", ".eslintrc.json", ".eslintrc.js", ".eslintrc.cjs", ".env.example", ".env.sample", ".env.template"]);
+
+/** Whether a directory name must never be uploaded. */
+export function isExcludedDirectory(name) {
+  return name.startsWith(".") || EXCLUDED_DIRECTORIES.has(name) || /^\.?venv[\w.-]*$/i.test(name);
+}
+
+/** Whether a file name must never be uploaded (secrets, archives, binaries, large media). */
+export function isExcludedFile(name) {
+  const lower = name.toLowerCase();
+  if (SECRET_FILE_NAMES.has(lower)) return true;
+  if (lower.startsWith(".env")) return !ALLOWED_DOTFILES.has(lower);
+  if (lower.startsWith(".") && !ALLOWED_DOTFILES.has(lower)) return true;
+  if (/^id_(rsa|dsa|ecdsa|ed25519)(\.pub)?$/.test(lower)) return true;
+  if (/(^|[-_.])(service[-_]?account|gcloud|firebase-adminsdk)[\w.-]*\.json$/.test(lower)) return true;
+  if (lower === ".ds_store" || lower === "thumbs.db") return true;
+  return EXCLUDED_EXTENSIONS.has(path.extname(lower));
+}
+
+function inside(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+/**
+ * Recursively list uploadable files. Symlinks that resolve outside the project
+ * root abort the scan; symlinks to files inside the root are followed and
+ * symlinked directories are skipped to avoid loops.
+ * @returns {Promise<{files:{name:string,absolute:string,size:number}[],skipped:string[],warnings:string[]}>}
+ */
+export async function scanProject(directory) {
+  const root = await realpath(path.resolve(directory));
+  const rootStat = await stat(root);
+  if (!rootStat.isDirectory()) throw new Error(`${directory} is not a directory`);
+  const files = [];
+  const skipped = [];
+  const warnings = [];
+  let total = 0;
+  async function walk(current, prefix) {
+    const entries = (await readdir(current, { withFileTypes: true })).sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const entry of entries) {
+      const absolute = path.join(current, entry.name);
+      const name = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.name.includes("\\") || /[\0\r\n]/.test(entry.name)) { skipped.push(name); continue; }
+      const info = await lstat(absolute);
+      if (info.isSymbolicLink()) {
+        let target;
+        try { target = await realpath(absolute); } catch { warnings.push(`Skipped broken symlink ${name}`); continue; }
+        if (!inside(root, target)) throw new Error(`Refusing to package ${name}: symlink points outside the project root`);
+        const targetInfo = await stat(target);
+        if (targetInfo.isDirectory()) { warnings.push(`Skipped symlinked directory ${name}`); continue; }
+        if (!targetInfo.isFile()) continue;
+        if (isExcludedFile(entry.name) || isExcludedFile(path.basename(target))) { skipped.push(name); continue; }
+        total += targetInfo.size;
+        files.push({ name, absolute: target, size: targetInfo.size, mode: targetInfo.mode });
+      } else if (info.isDirectory()) {
+        if (isExcludedDirectory(entry.name)) { skipped.push(`${name}/`); continue; }
+        await walk(absolute, name);
+      } else if (info.isFile()) {
+        if (isExcludedFile(entry.name)) { skipped.push(name); continue; }
+        total += info.size;
+        files.push({ name, absolute, size: info.size, mode: info.mode });
+      }
+      if (total > MAX_SOURCE_BYTES) throw new Error("Project source exceeds 500 MB after exclusions");
+      if (files.length > MAX_ZIP_ENTRIES) throw new Error(`Project contains more than ${MAX_ZIP_ENTRIES} files after exclusions`);
+    }
+  }
+  await walk(root, "");
+  if (!files.length) throw new Error("No deployable files found after exclusions");
+  return { root, files, skipped, warnings };
+}
+
+/** Package a project directory into an in-memory ZIP and hash it. */
+export async function packageProject(directory) {
+  const scan = await scanProject(directory);
+  const entries = [];
+  for (const file of scan.files) entries.push({ name: file.name, data: await readFile(file.absolute), mode: file.mode & 0o111 ? 0o755 : 0o644 });
+  const archive = createZip(entries);
+  if (archive.length > MAX_ARCHIVE_BYTES) throw new Error(`Packaged project is ${(archive.length / 1048576).toFixed(1)} MB; the CLI limit is 50 MB`);
+  return { ...scan, archive, sha256: createHash("sha256").update(archive).digest("hex") };
+}
+
+/** True when an identical archive was already deployed for this linked app. */
+export function isIdenticalDeploy(projectConfig, hash, force = false) {
+  return !force && Boolean(projectConfig?.applicationId) && typeof projectConfig?.lastHash === "string" && projectConfig.lastHash === hash;
+}
+
+/** Derive a valid application name from package.json or the directory name. */
+export function inferAppName(packageName, directoryName) {
+  for (const candidate of [packageName, directoryName]) {
+    if (typeof candidate !== "string") continue;
+    const name = candidate.replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/g, "");
+    if (/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/.test(name)) return name;
+  }
+  return undefined;
+}
+
+export async function readProjectConfig(directory) {
+  for (const folder of [PROJECT_DIR, LEGACY_PROJECT_DIR]) {
+    try {
+      const value = JSON.parse(await readFile(path.join(directory, folder, "config.json"), "utf8"));
+      if (value && typeof value === "object" && !Array.isArray(value)) return folder === PROJECT_DIR ? value : { workspaceId: value.workspaceId, name: value.name ?? value.appName };
+    } catch {}
+  }
+  return {};
+}
+
+/** Persist linked-project state and keep the folder out of Git. Never stores tokens. */
+export async function writeProjectConfig(directory, value) {
+  const folder = path.join(directory, PROJECT_DIR);
+  await mkdir(folder, { recursive: true });
+  const safe = Object.fromEntries(Object.entries(value).filter(([key, item]) => item !== undefined && !/token|secret|password/i.test(key)));
+  await writeFile(path.join(folder, "config.json"), JSON.stringify(safe, null, 2) + "\n");
+  await ensureGitignore(directory);
+}
+
+/** Add the linked-project folder to .gitignore (run before packaging so the hash stays stable). */
+export async function ensureGitignore(directory) {
+  const gitignore = path.join(directory, ".gitignore");
+  let current = "";
+  try { current = await readFile(gitignore, "utf8"); } catch {}
+  const lines = current.split(/\r?\n/).map(line => line.trim());
+  if (!lines.includes(`${PROJECT_DIR}/`) && !lines.includes(PROJECT_DIR) && !lines.includes(`/${PROJECT_DIR}`) && !lines.includes(`/${PROJECT_DIR}/`)) {
+    await writeFile(gitignore, current + (current && !current.endsWith("\n") ? "\n" : "") + `${PROJECT_DIR}/\n`);
+  }
+}

package/src/lib/zip.mjs

@@ -0,0 +1,110 @@
+// Minimal, dependency-free ZIP writer used by the VibingView CLI.
+// Writes standard PKZIP archives (local file headers, central directory and
+// end-of-central-directory record). Deflate uses node:zlib; entries that do not
+// shrink are stored. ZIP64 is intentionally unsupported: the CLI caps archives
+// at 50 MB and 20,000 entries, well below the classic format's limits.
+import zlib from "node:zlib";
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+/** CRC-32 (IEEE) of a buffer. Uses zlib.crc32 when the runtime provides it. */
+export function crc32(buffer) {
+  if (typeof zlib.crc32 === "function") return zlib.crc32(buffer) >>> 0;
+  let crc = 0xffffffff;
+  for (let i = 0; i < buffer.length; i++) crc = CRC_TABLE[(crc ^ buffer[i]) & 0xff] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+// A fixed timestamp (1980-01-01 00:00) keeps archives byte-for-byte
+// reproducible, so an unchanged project produces the same SHA-256.
+const DOS_TIME = 0;
+const DOS_DATE = (0 << 9) | (1 << 5) | 1;
+export const MAX_ZIP_ENTRIES = 20000;
+
+function validEntryName(name) {
+  return typeof name === "string" && name.length > 0 && Buffer.byteLength(name) < 0xffff && !name.startsWith("/") &&
+    !name.includes("\\") && !name.includes("\0") && !/^[a-zA-Z]:/.test(name) && !name.split("/").some(part => part === ".." || part === "." || part === "");
+}
+
+/**
+ * Build a ZIP archive in memory.
+ * @param {{name:string,data:Buffer|Uint8Array|string,mode?:number}[]} entries
+ * @returns {Buffer}
+ */
+export function createZip(entries) {
+  if (!Array.isArray(entries)) throw new TypeError("entries must be an array");
+  if (entries.length > MAX_ZIP_ENTRIES) throw new Error(`Archives are limited to ${MAX_ZIP_ENTRIES} files`);
+  const seen = new Set();
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const entry of entries) {
+    if (!validEntryName(entry.name)) throw new Error(`Unsafe archive path: ${entry.name}`);
+    if (seen.has(entry.name)) throw new Error(`Duplicate archive path: ${entry.name}`);
+    seen.add(entry.name);
+    const name = Buffer.from(entry.name, "utf8");
+    const data = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(entry.data);
+    const deflated = zlib.deflateRawSync(data, { level: 9 });
+    const stored = deflated.length >= data.length;
+    const body = stored ? data : deflated;
+    const method = stored ? 0 : 8;
+    const crc = crc32(data);
+    if (offset > 0xffffffff || body.length > 0xffffffff) throw new Error("Archive too large for the ZIP format used by this CLI");
+
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4); // version needed
+    local.writeUInt16LE(0x0800, 6); // UTF-8 names
+    local.writeUInt16LE(method, 8);
+    local.writeUInt16LE(DOS_TIME, 10);
+    local.writeUInt16LE(DOS_DATE, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(body.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0);
+    central.writeUInt16LE((3 << 8) | 20, 4); // made by: Unix, spec 2.0
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0x0800, 8);
+    central.writeUInt16LE(method, 10);
+    central.writeUInt16LE(DOS_TIME, 12);
+    central.writeUInt16LE(DOS_DATE, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(body.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30); // extra
+    central.writeUInt16LE(0, 32); // comment
+    central.writeUInt16LE(0, 34); // disk
+    central.writeUInt16LE(0, 36); // internal attributes
+    // Regular file permissions only; never symlink or device bits.
+    central.writeUInt32LE((((entry.mode ?? 0o644) & 0o777) | 0o100000) * 0x10000 >>> 0, 38);
+    central.writeUInt32LE(offset, 42);
+
+    locals.push(local, name, body);
+    centrals.push(central, name);
+    offset += local.length + name.length + body.length;
+  }
+  const directory = Buffer.concat(centrals);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(entries.length, 8);
+  end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(directory.length, 12);
+  end.writeUInt32LE(offset, 16);
+  end.writeUInt16LE(0, 20);
+  return Buffer.concat([...locals, directory, end]);
+}

package/src/mcp.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// Standalone VibingView stdio MCP connector. Requires Node.js 18 or newer; no packages.
+// It is a thin bridge: initialize/ping are answered locally, while tools/list and
+// tools/call are forwarded to the control plane's remote MCP endpoint (/api/mcp),
+// so the stdio and remote tool sets are always identical and scope-checked server-side.
+// Keep this file self-contained (Node built-ins only): /api/mcp/download serves it as a
+// single standalone file, and `vibingview mcp` imports it from the npm package.
+import readline from "node:readline";
+
+const base = (process.env.VIBINGVIEW_URL ?? process.env.LAUNCHDECK_URL ?? "https://vibingview.com").replace(/\/$/, "");
+const token = process.env.VIBINGVIEW_TOKEN || process.env.LAUNCHDECK_TOKEN || "";
+const SUPPORTED_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+const INSTRUCTIONS = "Use only the user's own resources. Ask for approval before any mutating tool. Mutations are queued, not completed. Secret values are never returned.";
+
+class RpcError extends Error {
+  constructor(code, message) { super(message); this.rpcCode = code; }
+}
+const redact = text => (token ? String(text).split(token).join("[REDACTED]") : String(text));
+
+function endpoint() {
+  const url = new URL(base);
+  if (url.username || url.password || url.search || url.hash || url.pathname !== "/") throw new Error("VIBINGVIEW_URL must be the control-plane origin without credentials, a path or a query.");
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) throw new Error("Use HTTPS for a remote VibingView control plane.");
+  if (!token) throw new Error("Set VIBINGVIEW_TOKEN to a scoped account token before using tools.");
+  return `${url.origin}/api/mcp`;
+}
+
+let forwardId = 0;
+async function forward(method, params) {
+  const response = await fetch(endpoint(), {
+    method: "POST",
+    redirect: "error",
+    signal: AbortSignal.timeout(30000),
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream", "MCP-Protocol-Version": SUPPORTED_VERSIONS[0] },
+    body: JSON.stringify({ jsonrpc: "2.0", id: ++forwardId, method, ...(params === undefined ? {} : { params }) }),
+  });
+  const body = await response.json().catch(() => null);
+  if (body?.error) throw new RpcError(response.status === 401 ? -32001 : body.error.code ?? -32603, redact(body.error.message ?? `VibingView returned HTTP ${response.status}`));
+  if (!response.ok || !body || !("result" in body)) throw new RpcError(-32603, `VibingView returned HTTP ${response.status}`);
+  return body.result;
+}
+
+const textResult = (text, isError = false) => ({ content: [{ type: "text", text }], ...(isError ? { isError: true } : {}) });
+
+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.0" }, instructions: INSTRUCTIONS };
+  }
+  if (message.method === "ping") return {};
+  if (message.method === "tools/list") {
+    try { return await forward("tools/list"); }
+    catch (error) { throw error instanceof RpcError ? error : new RpcError(-32603, redact(error.message ?? error)); }
+  }
+  if (message.method === "tools/call") {
+    if (typeof params.name !== "string") throw new RpcError(-32602, "Tool name is required");
+    if (params.arguments !== undefined && (!params.arguments || typeof params.arguments !== "object" || Array.isArray(params.arguments))) throw new RpcError(-32602, "Tool arguments must be an object");
+    try { return await forward("tools/call", { name: params.name, arguments: params.arguments ?? {} }); }
+    catch (error) {
+      if (error instanceof RpcError && error.rpcCode === -32602) throw error;
+      return textResult(redact(error.message ?? error), true);
+    }
+  }
+  throw new RpcError(-32601, "Method not found");
+}
+
+function send(response) { process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...response }) + "\n"); }
+const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+for await (const line of input) {
+  if (!line.trim()) continue;
+  let message;
+  try { message = JSON.parse(line); } catch { send({ id: null, error: { code: -32700, message: "Parse error" } }); continue; }
+  if (!message || Array.isArray(message) || message.jsonrpc !== "2.0" || typeof message.method !== "string" || (message.id !== undefined && message.id !== null && !["string", "number"].includes(typeof message.id))) { send({ id: null, error: { code: -32600, message: "Invalid request" } }); continue; }
+  // Notifications have no response and must never invoke an action.
+  if (message.id === undefined) continue;
+  try { send({ id: message.id, result: await handle(message) }); }
+  catch (error) { send({ id: message.id, error: { code: error.rpcCode ?? -32603, message: error.rpcCode ? error.message : "Internal error" } }); }
+}