@rebasepro/cli 0.9.1-canary.ff338b5 → 0.10.0

package/dist/index.es.js

@@ -875,7 +875,54 @@ function buildInitQuestions(params) {
 	});
 	return questions;
 }
+/**
+* The `cd` a user must type to enter the new project.
+*
+* Not the project's basename: `init apps/my-app` has to say `cd apps/my-app`,
+* and `init .` returns "" because they are already in the project.
+*/
+function formatCdTarget(cwd, targetDirectory) {
+	return path.relative(cwd, targetDirectory);
+}
+/** Help for `rebase init` — the flags were previously only discoverable by
+* triggering the non-TTY error. */
+function printInitHelp() {
+	console.log(`
+${chalk.bold("rebase init")} — Create a new Rebase project
+
+${chalk.bold("Usage")}
+  rebase init ${chalk.blue("[name]")} [options]
+
+  ${chalk.gray("The name may be a nested path (apps/my-app) or \".\" for the current directory.")}
+  ${chalk.gray("Defaults to \"my-rebase-app\" when omitted with --yes.")}
+
+${chalk.bold("Options")}
+  ${chalk.blue("-t, --template")} ${chalk.gray("<preset>")}   blog | ecommerce | blank ${chalk.gray("(default: blog)")}
+  ${chalk.blue("-f, --flavor")} ${chalk.gray("<flavor>")}     cms | baas ${chalk.gray("(default: cms)")}
+  ${chalk.blue("-y, --yes")}                 Accept defaults, never prompt ${chalk.gray("(required for CI / non-TTY)")}
+  ${chalk.blue("-i, --install")}             Install dependencies after scaffolding
+  ${chalk.blue("-g, --git")}                 Initialize a git repository and make an initial commit
+  ${chalk.blue("--database-url")} ${chalk.gray("<url>")}      Use an existing database instead of the generated one
+  ${chalk.blue("--introspect")}              Generate collections from that database ${chalk.gray("(implies --template blank; needs --install)")}
+  ${chalk.blue("--project")} ${chalk.gray("<slug>")}          Link the scaffold to a Rebase Cloud project
+  ${chalk.blue("--setup-key")} ${chalk.gray("<key>")}         One-time key authenticating the cloud link ${chalk.gray("(use with --project)")}
+
+${chalk.bold("Flavors")}
+  ${chalk.blue("cms")}   BaaS + admin UI, driven by collections you define ${chalk.gray("(like Payload/Directus)")}
+  ${chalk.blue("baas")}  Headless API over your database — no collections, no UI ${chalk.gray("(like Supabase)")}
+        ${chalk.gray("--template has no effect on this flavor.")}
+
+${chalk.bold("Examples")}
+  ${chalk.gray("$")} rebase init my-shop --template ecommerce --install
+  ${chalk.gray("$")} rebase init my-api --flavor baas --yes
+  ${chalk.gray("$")} rebase init . --yes --git
+`);
+}
 async function createRebaseApp(rawArgs) {
+	if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+		printInitHelp();
+		return;
+	}
 	console.log(`
 ${chalk.bold("Rebase")} — Create a new project 🚀
 `);
@@ -935,6 +982,7 @@ async function promptForOptions(rawArgs, pm) {
 			databaseUrl: args["--database-url"] || void 0,
 			introspect: args["--introspect"] || false,
 			preset: templateArg || "blog",
+			explicitPreset: !!templateArg,
 			flavor: flavorArg || "cms",
 			pm,
 			pmCommands,
@@ -972,6 +1020,7 @@ async function promptForOptions(rawArgs, pm) {
 		databaseUrl: answers.databaseUrl?.trim() || void 0,
 		introspect: answers.introspect || false,
 		preset: templateArg || answers.preset || "blog",
+		explicitPreset: !!templateArg,
 		flavor: flavorArg || answers.flavor || "cms",
 		pm,
 		pmCommands,
@@ -1056,6 +1105,7 @@ async function createProject$1(options) {
 		const shipped = path.join(options.targetDirectory, from);
 		if (fs.existsSync(shipped)) fs.renameSync(shipped, path.join(options.targetDirectory, to));
 	}
+	if (options.flavor === "baas" && options.explicitPreset) console.log(chalk.yellow(`  Ignoring --template ${options.preset}: the baas flavor has no collections.`));
 	if (options.flavor !== "baas") {
 		if (options.introspect && options.preset !== "blank") console.log(chalk.gray("  Using the blank template: collections will come from your database."));
 		await applyPreset(options.targetDirectory, options.introspect ? "blank" : options.preset);
@@ -1067,6 +1117,33 @@ async function createProject$1(options) {
 		console.log(chalk.gray("  Initializing git repository..."));
 		try {
 			await execa("git", ["init"], { cwd: options.targetDirectory });
+			try {
+				await execa("git", [
+					"symbolic-ref",
+					"HEAD",
+					"refs/heads/main"
+				], { cwd: options.targetDirectory });
+			} catch {}
+			await execa("git", ["add", "-A"], { cwd: options.targetDirectory });
+			let identity = {};
+			try {
+				await execa("git", ["config", "user.email"], { cwd: options.targetDirectory });
+			} catch {
+				identity = {
+					GIT_AUTHOR_NAME: "Rebase",
+					GIT_AUTHOR_EMAIL: "noreply@rebase.pro",
+					GIT_COMMITTER_NAME: "Rebase",
+					GIT_COMMITTER_EMAIL: "noreply@rebase.pro"
+				};
+			}
+			await execa("git", [
+				"commit",
+				"-m",
+				"Initial commit from Rebase"
+			], {
+				cwd: options.targetDirectory,
+				env: identity
+			});
 		} catch {
 			console.warn(chalk.yellow("  Warning: Failed to initialize git repository"));
 		}
@@ -1097,6 +1174,7 @@ async function createProject$1(options) {
 			console.warn(chalk.yellow(`  Warning: Failed to install dependencies. You may need to run \`${installCmd.join(" ")}\` manually.`));
 		}
 	}
+	let introspected = false;
 	if (options.introspect) {
 		console.log("");
 		if (options.installDeps) {
@@ -1112,6 +1190,7 @@ async function createProject$1(options) {
 					stdio: "inherit"
 				});
 				console.log(chalk.green("  Database successfully introspected!"));
+				introspected = true;
 			} catch {
 				console.warn(chalk.yellow("  Warning: Failed to introspect database automatically."));
 				console.warn(chalk.yellow(`  You can run \`${execCmd.join(" ")}\` then \`${generateCmd.join(" ")}\` manually after setup.`));
@@ -1130,13 +1209,21 @@ async function createProject$1(options) {
 	const runDev = pmCommands.run("dev");
 	const runDbPush = pmCommands.run("db:push");
 	const isBaas = options.flavor === "baas";
-	console.log(`  ${chalk.cyan("cd")} ${options.projectName}`);
+	const cdTarget = formatCdTarget(process.cwd(), options.targetDirectory);
+	if (cdTarget) console.log(`  ${chalk.cyan("cd")} ${cdTarget}`);
 	if (!options.installDeps) console.log(`  ${chalk.cyan(installCmd.join(" "))}`);
 	console.log("");
-	if (options.databaseUrl) if (options.introspect) {
+	if (options.databaseUrl) if (introspected) {
 		console.log(chalk.gray("  # Database has been introspected & collections generated!"));
 		console.log(chalk.gray("  # Start the development server (frontend + backend):"));
 		console.log(`  ${chalk.cyan(runDev.join(" "))}`);
+	} else if (options.introspect) {
+		console.log(chalk.gray("  # Introspection did not run — finish it with:"));
+		console.log(`  ${chalk.cyan(execCmd.join(" "))}`);
+		console.log(`  ${chalk.cyan(generateCmd.join(" "))}`);
+		console.log("");
+		console.log(chalk.gray("  # Then start the development server:"));
+		console.log(`  ${chalk.cyan(runDev.join(" "))}`);
 	} else {
 		console.log(chalk.gray("  # Your custom database is configured in .env."));
 		console.log(chalk.gray("  # If the database is empty, push the Rebase schema to initialize it:"));
@@ -1365,7 +1452,7 @@ async function configureEnvFile(targetDirectory, databaseUrl) {
 		envContent = envContent.replace(/^#\s*REBASE_SERVICE_KEY=.*$/m, `REBASE_SERVICE_KEY=${serviceKey}`);
 		if (databaseUrl) {
 			if (/[\r\n]/.test(databaseUrl)) throw new Error("Invalid DATABASE_URL: multiline values are not allowed.");
-			envContent = envContent.replace(/^DATABASE_URL=.*$/m, `DATABASE_URL=${databaseUrl}`);
+			envContent = envContent.replace(/^DATABASE_URL=.*$/m, `DATABASE_URL=${databaseUrl}\nDATABASE_PASSWORD=${dbPassword}`);
 		} else {
 			const dbPort = await findAvailablePort(5432);
 			envContent = envContent.replace(/^DATABASE_URL=.*$/m, `DATABASE_URL=postgresql://rebase:${dbPassword}@localhost:${dbPort}/rebase?options=-c%20search_path=public&sslmode=disable\nDATABASE_PASSWORD=${dbPassword}`);
@@ -4871,7 +4958,7 @@ function deploymentDurationMs(dep) {
 	const ms = b - a;
 	return ms >= 0 ? ms : null;
 }
-function formatDuration(ms) {
+function formatDuration$1(ms) {
 	const totalSec = Math.max(0, Math.round(ms / 1e3));
 	if (totalSec < 60) return `${totalSec}s`;
 	const m = Math.floor(totalSec / 60);
@@ -4944,7 +5031,7 @@ async function deploymentsListCommand(rawArgs) {
 				return;
 			}
 			for (const v of views) {
-				const dur = v.durationMs !== null ? formatDuration(v.durationMs) : chalk.gray("running");
+				const dur = v.durationMs !== null ? formatDuration$1(v.durationMs) : chalk.gray("running");
 				const trig = v.trigger.source;
 				const roll = v.rollbackable ? chalk.green(" ↺ rollbackable") : "";
 				console.log(`  ${chalk.gray(`[${v.id}]`)} ${colorStatus(v.status)}  ${chalk.gray(String(v.createdAt ?? "—"))}  ${dur}  ${chalk.gray(trig)}${roll}`);
@@ -5115,6 +5202,737 @@ async function powerCommand(action, rawArgs) {
 	}
 }
 //#endregion
+//#region src/commands/cloud/debug.ts
+/**
+* `rebase cloud debug <subcommand>` — one entry point for "why is my deployed
+* app not behaving".
+*
+* ## Why this exists
+*
+* The useful signals for a deployed project live in four different places — the
+* control plane, the workload's pods, the tenant database, and the public URL —
+* and each is normally reached with a different tool and a different set of
+* flags. Getting to a log should not be a research task. This started life as a
+* hand-rolled `prod-debug.sh` for a single project, with the namespace and the
+* URL hardcoded at the top; it earned its place twice in one week, so it is
+* generalised here to any project the CLI can already resolve.
+*
+* ## Read-only by default
+*
+* Every subcommand here only reads. The two things the original script could do
+* that mutate are deliberately NOT reproduced as-is:
+*
+*   - restarting the workload lives at `rebase cloud restart`, which already
+*     gates downtime behind `--yes`; duplicating it here would give the same
+*     destructive act a second, ungated spelling.
+*   - `debug db` prints the port-forward recipe and the connection's *shape*.
+*     It opens no session and prints no password — `rebase cloud db info
+*     --reveal` is the explicit, auditable way to get one.
+*
+* ## The probes are the point
+*
+* `debug health` is the highest-value piece and the reason the script existed.
+* A bare status code is not a diagnosis: a 404 from a functions route means
+* something completely different from a 404 at the root, and a 200 on an
+* unauthenticated read is a finding rather than a success. So every probe ships
+* with the interpretation of what it got, not just the number — see
+* {@link PROBES}.
+*/
+/** A response never arrived: DNS, TLS, ingress, or the pod. */
+var NO_RESPONSE = {
+	verdict: "fail",
+	meaning: "nothing answered — the hostname does not resolve, the ingress has no route, or no pod is running"
+};
+function serverError(what) {
+	return {
+		verdict: "fail",
+		meaning: `the server is running but ${what}`
+	};
+}
+/**
+* The probe set, in the order a failure cascades: if `health` is down, nothing
+* below it is meaningful, so it is checked first and reported first.
+*/
+var PROBES = [
+	{
+		id: "health",
+		label: "health",
+		method: "GET",
+		path: () => "/health",
+		healthy: "200 — the backend is up",
+		interpret: (status) => {
+			if (status === null) return NO_RESPONSE;
+			if (status === 200) return {
+				verdict: "ok",
+				meaning: "the backend is up and serving"
+			};
+			if (status === 404) return {
+				verdict: "fail",
+				meaning: "something answered but it is not a Rebase backend — the ingress is routing this host elsewhere"
+			};
+			if (status >= 500) return serverError("its health endpoint is failing");
+			return {
+				verdict: "unknown",
+				meaning: "unexpected for a health endpoint"
+			};
+		}
+	},
+	{
+		id: "spa",
+		label: "spa",
+		method: "GET",
+		path: () => "/",
+		healthy: "200 — the frontend is being served",
+		interpret: (status) => {
+			if (status === null) return NO_RESPONSE;
+			if (status === 200) return {
+				verdict: "ok",
+				meaning: "the frontend bundle is being served"
+			};
+			if (status === 404) return {
+				verdict: "warn",
+				meaning: "no frontend at the root — expected for a backend-only project, otherwise the SPA assets were not bundled into the image"
+			};
+			if (status >= 500) return serverError("the root route throws");
+			return {
+				verdict: "unknown",
+				meaning: "unexpected at the site root"
+			};
+		}
+	},
+	{
+		id: "auth",
+		label: "auth",
+		method: "POST",
+		path: () => "/api/auth/login",
+		body: {},
+		healthy: "400 — auth is mounted and rejects an empty body",
+		interpret: (status) => {
+			if (status === null) return NO_RESPONSE;
+			if (status === 400 || status === 422) return {
+				verdict: "ok",
+				meaning: "auth is mounted and rejected the empty body, as it should"
+			};
+			if (status === 401 || status === 403) return {
+				verdict: "ok",
+				meaning: "auth is mounted and refused the credentials"
+			};
+			if (status === 404) return {
+				verdict: "fail",
+				meaning: "the auth routes are NOT mounted — this project cannot sign anyone in"
+			};
+			if (status === 200) return {
+				verdict: "fail",
+				meaning: "an EMPTY login body was accepted — a login with no credentials must never succeed"
+			};
+			if (status >= 500) return serverError("the login route throws — often a missing or unmigrated auth table");
+			return {
+				verdict: "unknown",
+				meaning: "unexpected for a login route"
+			};
+		}
+	},
+	{
+		id: "unauthRead",
+		label: "unauth read",
+		method: "GET",
+		path: (t) => `/api/data/${encodeURIComponent(t.collection)}`,
+		healthy: "401 — reads require authentication",
+		interpret: (status) => {
+			if (status === null) return NO_RESPONSE;
+			if (status === 401 || status === 403) return {
+				verdict: "ok",
+				meaning: "unauthenticated reads are refused — row-level security is enforced"
+			};
+			if (status === 200) return {
+				verdict: "warn",
+				meaning: "this collection is readable with NO authentication — correct only if it is deliberately public"
+			};
+			if (status === 404) return {
+				verdict: "warn",
+				meaning: "no such collection on this deployment — check the name, or pass --collection"
+			};
+			if (status >= 500) return serverError("the read reached the database and failed — most often an RLS policy naming a column or table that is not there");
+			return {
+				verdict: "unknown",
+				meaning: "unexpected for a data read"
+			};
+		}
+	},
+	{
+		id: "functions",
+		label: "functions",
+		method: "GET",
+		/**
+		* The router's own listing endpoint, NOT a function's path.
+		*
+		* This matters, and it is the one place the original script got a wrong
+		* answer. A function is a Hono sub-app mounted at `/<name>`, and it
+		* usually defines only sub-routes (`/get`, `/list`) — so
+		* `/api/functions/<name>` 404s **even when everything is mounted and
+		* healthy**. Probing there cannot separate "the router is missing" from
+		* "that function defines no root route", and reporting the first is how
+		* you send someone to debug a deployment that was fine.
+		*
+		* `GET /api/functions` is unambiguous: the router registers a listing
+		* route at its own root (see `createFunctionRoutes`), so a 200 proves
+		* the mount *and* names every function that loaded.
+		*/
+		path: () => "/api/functions",
+		healthy: "200 — the functions router is mounted and lists its functions",
+		interpret: (status) => {
+			if (status === null) return NO_RESPONSE;
+			if (status === 200) return {
+				verdict: "ok",
+				meaning: "the functions router is mounted"
+			};
+			if (status === 401 || status === 403) return {
+				verdict: "ok",
+				meaning: "the functions router is mounted (its listing requires auth)"
+			};
+			if (status === 404) return {
+				verdict: "fail",
+				meaning: "the functions router did not mount — no functions directory was found at build time, or it held no functions, so every function on this project is unreachable"
+			};
+			if (status >= 500) return serverError("the functions router throws");
+			return {
+				verdict: "unknown",
+				meaning: "unexpected for the functions listing"
+			};
+		},
+		needsBody: true,
+		refine: (body, t) => {
+			const names = functionNames(body);
+			if (!names) return null;
+			if (t.fn && !names.includes(t.fn)) return {
+				verdict: "fail",
+				meaning: `the router is mounted but no function is named "${t.fn}" — it loaded ${names.length}: ${names.join(", ")}`
+			};
+			const found = t.fn ? `, including ${t.fn}` : "";
+			return {
+				verdict: "ok",
+				meaning: `the functions router is mounted and loaded ${names.length} function${names.length === 1 ? "" : "s"}${found}`
+			};
+		}
+	}
+];
+/** The function names out of a listing body, or null when it is not one. */
+function functionNames(body) {
+	const list = body?.functions;
+	if (!Array.isArray(list)) return null;
+	const names = list.map((f) => f?.name).filter((n) => typeof n === "string");
+	return names.length === list.length ? names : null;
+}
+/** Milliseconds before a probe is treated as unanswered. */
+var PROBE_TIMEOUT_MS = 1e4;
+/**
+* Ceiling on a probe body we will parse. The only body read is the function
+* listing; anything larger is a page we have no use for, and a debug command
+* must not be the thing that runs a machine out of memory.
+*/
+var MAX_PROBE_BODY_BYTES = 256 * 1024;
+/**
+* Run one probe. A transport failure is a `null` status, never a thrown error:
+* "nothing answered" is a diagnosis in its own right and the other probes still
+* need to run.
+*/
+async function runProbe(origin, spec, targets) {
+	const url = `${origin}${spec.path(targets)}`;
+	const started = Date.now();
+	let status = null;
+	let body;
+	try {
+		const res = await fetch(url, {
+			method: spec.method,
+			headers: spec.body ? { "Content-Type": "application/json" } : void 0,
+			body: spec.body ? JSON.stringify(spec.body) : void 0,
+			redirect: "manual",
+			signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+		});
+		status = res.status;
+		if (spec.needsBody && res.ok) {
+			const text = await res.text();
+			if (text.length <= MAX_PROBE_BODY_BYTES) try {
+				body = JSON.parse(text);
+			} catch {}
+		}
+	} catch {
+		status = null;
+	}
+	const statusReading = spec.interpret(status);
+	const reading = status !== null && spec.refine?.(body, targets) || statusReading;
+	return {
+		statusOk: statusReading.verdict === "ok",
+		id: spec.id,
+		label: spec.label,
+		method: spec.method,
+		url,
+		status,
+		ms: Date.now() - started,
+		verdict: reading.verdict,
+		meaning: reading.meaning,
+		healthy: spec.healthy
+	};
+}
+/** The worst verdict across probes — what the command's exit code keys off. */
+function overallVerdict(results) {
+	if (results.some((r) => r.verdict === "fail")) return "fail";
+	if (results.some((r) => r.verdict === "unknown")) return "unknown";
+	if (results.some((r) => r.verdict === "warn")) return "warn";
+	return "ok";
+}
+function verdictMark(v) {
+	switch (v) {
+		case "ok": return chalk.green("✓");
+		case "warn": return chalk.yellow("!");
+		case "fail": return chalk.red("✗");
+		default: return chalk.gray("?");
+	}
+}
+var LOG_PREFIX_RE = /^(?:(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)\s+)?(?:\[([^\]]+)\]\s+)?([\s\S]*)$/;
+function parseLogLine(line) {
+	const m = LOG_PREFIX_RE.exec(line);
+	if (!m) return {
+		ts: null,
+		pod: null,
+		text: line
+	};
+	return {
+		ts: m[1] ?? null,
+		pod: m[2] ?? null,
+		text: m[3] ?? ""
+	};
+}
+/**
+* Lines an operator scanning for a fault wants to see.
+*
+* Matches the structured `severity` field first, then the shapes that show up
+* in unstructured output. `refus`/`denied` are in the list because a permission
+* failure often logs at info level and is exactly what one is hunting for.
+*/
+function isErrorLine(text) {
+	return /"(?:severity|level)":\s*"(?:ERROR|WARN(?:ING)?|error|warn)"|\bError:|\bERR!|refus|denied|EACCES|ECONNREFUSED/i.test(text);
+}
+/**
+* Pull an HTTP request record out of a log line, or null when it is not one.
+*
+* Only structured request lines are recognised. Guessing at prose would produce
+* a table with invented columns, which is worse than a short one.
+*/
+function parseRequestLine(text) {
+	const start = text.indexOf("{");
+	if (start === -1) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(text.slice(start));
+	} catch {
+		return null;
+	}
+	if (parsed.message !== "request" && parsed.msg !== "request") return null;
+	const num = (v) => {
+		const n = typeof v === "string" ? Number(v) : typeof v === "number" ? v : NaN;
+		return Number.isFinite(n) ? n : null;
+	};
+	return {
+		status: num(parsed.status),
+		method: typeof parsed.method === "string" ? parsed.method : "",
+		path: typeof parsed.path === "string" ? parsed.path : "",
+		latencyMs: num(parsed.latencyMs ?? parsed.durationMs)
+	};
+}
+/**
+* Startup lines: what the server *decided* it was going to do. Which storage
+* backend it bound, which functions it loaded, whether auth tables were found.
+* This is the fastest way to tell a misconfiguration from a runtime fault.
+*/
+function isBootLine(text) {
+	return /storage|Loaded function|Mounted|Auth tables|Server running|listening|Refusing|migrat/i.test(text);
+}
+/** Render a number of seconds back as the compact duration a user would type. */
+function formatDuration(seconds) {
+	if (seconds % 86400 === 0 && seconds >= 86400) return `${seconds / 86400}d`;
+	if (seconds % 3600 === 0 && seconds >= 3600) return `${seconds / 3600}h`;
+	if (seconds % 60 === 0 && seconds >= 60) return `${seconds / 60}m`;
+	return `${seconds}s`;
+}
+/**
+* Parse a duration like `15m`, `2h`, `90s`, `1d` (or a bare number of seconds)
+* into seconds. Returns null when it is not a duration.
+*/
+function parseSince(input) {
+	if (!input) return null;
+	const m = /^(\d+(?:\.\d+)?)\s*([smhd])?$/i.exec(input.trim());
+	if (!m) return null;
+	const value = parseFloat(m[1]);
+	const unit = (m[2] || "s").toLowerCase();
+	return Math.round(value * (unit === "s" ? 1 : unit === "m" ? 60 : unit === "h" ? 3600 : 86400));
+}
+async function fetchRuntimeLogs(client, projectId, opts) {
+	const params = new URLSearchParams();
+	if (opts.sinceSeconds !== void 0) params.set("sinceSeconds", String(opts.sinceSeconds));
+	if (opts.tailLines !== void 0) params.set("tailLines", String(opts.tailLines));
+	if (opts.previous) params.set("previous", "true");
+	params.set("timestamps", "true");
+	const qs = params.toString();
+	return client.functions.invoke("runtime-logs", void 0, {
+		method: "GET",
+		path: `${projectId}${qs ? `?${qs}` : ""}`
+	});
+}
+/** Print the per-pod states runtime-logs reports, including its hints. */
+function printPodStates(res) {
+	if (res.state === "no_pods") {
+		console.log(chalk.yellow(`  ${res.message ?? "No pods are running for this project."}`));
+		console.log("");
+		return;
+	}
+	for (const p of res.pods ?? []) {
+		if (p.state === "ok") continue;
+		console.log(`  ${chalk.yellow(p.pod)} ${chalk.gray(`(${p.state})`)}`);
+		if (p.message) console.log(chalk.gray(`    ${p.message}`));
+		if (p.hint) console.log(chalk.cyan(`    → ${p.hint}`));
+	}
+	if (res.truncated) console.log(chalk.gray("  (output truncated — narrow the window with --since)"));
+}
+/** Resolve the public origin a project is served at. */
+async function resolveOrigin(rawArgs, client, url, projectId) {
+	const parsed = arg({ "--host": String }, {
+		argv: rawArgs.slice(3),
+		permissive: true
+	});
+	if (parsed["--host"]) {
+		const h = parsed["--host"].trim().replace(/\/+$/, "");
+		return /^https?:\/\//.test(h) ? h : `https://${h}`;
+	}
+	const [project, baseDomain] = await Promise.all([client.data.collection("projects").findById(projectId), fetchTenantBaseDomain(client, url)]);
+	if (!project) fail(`Project ${displayProjectRef(rawArgs)} not found.`);
+	const host = projectHost(project, baseDomain);
+	if (!host) fail("Could not determine the public URL for this project.", "It may never have been deployed. Pass --host <hostname> to probe an address directly.");
+	return `https://${host}`;
+}
+async function healthCommand(rawArgs) {
+	const parsed = arg({
+		"--collection": String,
+		"--function": String
+	}, {
+		argv: rawArgs.slice(3),
+		permissive: true
+	});
+	const targets = {
+		collection: parsed["--collection"] || "users",
+		fn: parsed["--function"]
+	};
+	const { client, url } = await requireClient(rawArgs);
+	const origin = await resolveOrigin(rawArgs, client, url, await requireProject(rawArgs, client));
+	const results = [];
+	for (const spec of PROBES) results.push(await runProbe(origin, spec, targets));
+	const overall = overallVerdict(results);
+	emit(() => {
+		console.log("");
+		console.log(chalk.bold(`  🩺 Health — ${displayProjectRef(rawArgs)}`) + chalk.gray(`  ${origin}`));
+		console.log("");
+		const width = Math.max(...results.map((r) => r.label.length));
+		for (const r of results) {
+			const code = r.status === null ? chalk.red("---") : String(r.status);
+			console.log(`  ${verdictMark(r.verdict)} ${chalk.bold(r.label.padEnd(width))}  ${code.padStart(3)}  ${chalk.gray(`${r.ms}ms`)}`);
+			console.log(`      ${chalk.gray(r.meaning)}`);
+		}
+		console.log("");
+		if (overall === "ok") console.log(chalk.green("  Everything reachable and wired as expected."));
+		else {
+			const bad = results.filter((r) => r.verdict === "fail" || r.verdict === "warn");
+			console.log(chalk.gray(`  ${bad.length} of ${results.length} check${bad.length === 1 ? "" : "s"} need attention.`));
+			const wrongStatus = bad.filter((r) => !r.statusOk);
+			if (wrongStatus.length > 0) {
+				console.log(chalk.gray("  A healthy deployment answers:"));
+				for (const r of wrongStatus) console.log(chalk.gray(`    ${r.label.padEnd(width)}  ${r.healthy}`));
+			}
+		}
+		console.log("");
+	}, {
+		origin,
+		overall,
+		probes: results
+	});
+	if (overall === "fail") process.exit(1);
+}
+async function logView(rawArgs, view) {
+	const parsed = arg({
+		"--since": String,
+		"--tail": Number,
+		"--previous": Boolean
+	}, {
+		argv: rawArgs.slice(3),
+		permissive: true
+	});
+	const sinceArg = parsed["--since"];
+	if (sinceArg !== void 0 && parseSince(sinceArg) === null) fail(`--since must be a duration like 15m, 2h or 90s; received "${sinceArg}".`);
+	const sinceSeconds = parseSince(sinceArg) ?? view.defaultSinceSeconds;
+	const { client } = await requireClient(rawArgs);
+	const projectId = await requireProject(rawArgs, client);
+	let res;
+	try {
+		res = await fetchRuntimeLogs(client, projectId, {
+			sinceSeconds,
+			tailLines: parsed["--tail"] ?? 500,
+			previous: Boolean(parsed["--previous"])
+		});
+	} catch (e) {
+		reportError(e, "Failed to fetch runtime logs");
+	}
+	const parsedLines = (res.logs ?? "").split("\n").filter((l) => l !== "").map(parseLogLine);
+	const kept = view.filter ? parsedLines.filter((l) => view.filter(l.text)) : parsedLines;
+	const shown = kept.slice(-view.limit);
+	emit(() => {
+		console.log("");
+		console.log(chalk.bold(`  ${view.title} — ${displayProjectRef(rawArgs)}`) + chalk.gray(`  last ${formatDuration(sinceSeconds)}`));
+		console.log("");
+		printPodStates(res);
+		if (shown.length === 0) {
+			console.log(chalk.gray("  (nothing matched in this window)"));
+			console.log("");
+			return;
+		}
+		for (const l of shown) console.log(`  ${l.pod ? chalk.gray(`[${l.pod}] `) : ""}${l.text}`);
+		console.log("");
+		if (kept.length > shown.length) {
+			console.log(chalk.gray(`  (showing the last ${shown.length} of ${kept.length} matching lines)`));
+			console.log("");
+		}
+	}, {
+		sinceSeconds,
+		state: res.state ?? null,
+		pods: res.pods ?? [],
+		truncated: Boolean(res.truncated),
+		matched: kept.length,
+		lines: shown
+	});
+}
+async function requestsCommand(rawArgs) {
+	const parsed = arg({
+		"--since": String,
+		"--tail": Number
+	}, {
+		argv: rawArgs.slice(3),
+		permissive: true
+	});
+	const sinceArg = parsed["--since"];
+	if (sinceArg !== void 0 && parseSince(sinceArg) === null) fail(`--since must be a duration like 15m, 2h or 90s; received "${sinceArg}".`);
+	const sinceSeconds = parseSince(sinceArg) ?? 900;
+	const { client } = await requireClient(rawArgs);
+	const projectId = await requireProject(rawArgs, client);
+	let res;
+	try {
+		res = await fetchRuntimeLogs(client, projectId, {
+			sinceSeconds,
+			tailLines: parsed["--tail"] ?? 1e3
+		});
+	} catch (e) {
+		reportError(e, "Failed to fetch runtime logs");
+	}
+	const shown = (res.logs ?? "").split("\n").filter((l) => l !== "").map((l) => parseRequestLine(parseLogLine(l).text)).filter((e) => e !== null).slice(-40);
+	emit(() => {
+		console.log("");
+		console.log(chalk.bold(`  🌐 Requests — ${displayProjectRef(rawArgs)}`) + chalk.gray(`  last ${formatDuration(sinceSeconds)}`));
+		console.log("");
+		printPodStates(res);
+		if (shown.length === 0) {
+			console.log(chalk.gray("  No structured request lines in this window."));
+			console.log(chalk.gray("  (this view needs the server's request logging; try `debug logs`)"));
+			console.log("");
+			return;
+		}
+		for (const e of shown) {
+			const status = e.status ?? 0;
+			const color = status >= 500 ? chalk.red : status >= 400 ? chalk.yellow : chalk.green;
+			console.log(`  ${color(String(e.status ?? "---").padStart(3))}  ${e.method.padEnd(6)} ${e.path.slice(0, 70).padEnd(70)} ${chalk.gray(e.latencyMs === null ? "" : `${e.latencyMs}ms`)}`);
+		}
+		console.log("");
+	}, {
+		sinceSeconds,
+		requests: shown
+	});
+}
+async function podCommand(rawArgs) {
+	const { client } = await requireClient(rawArgs);
+	const projectId = await requireProject(rawArgs, client);
+	let m;
+	try {
+		m = await client.functions.invoke("metrics", void 0, {
+			method: "GET",
+			path: projectId
+		});
+	} catch (e) {
+		reportError(e, "Failed to read workload placement");
+	}
+	const p = m.placement ?? {};
+	const replicas = p.replicas ?? {};
+	emit(() => {
+		console.log("");
+		console.log(chalk.bold(`  ☸  Workload — ${displayProjectRef(rawArgs)}`));
+		console.log("");
+		keyValues([
+			["Status", m.status ? colorStatus(m.status === "running" ? "active" : m.status) : void 0],
+			["Replicas", replicas.desired === void 0 ? void 0 : `${replicas.available ?? 0} / ${replicas.desired} available`],
+			["Namespace", p.namespace],
+			["Cluster", p.cluster],
+			["Region", [p.provider, p.region].filter(Boolean).join(" · ") || void 0],
+			["Host", p.host],
+			["Image", p.image],
+			["CPU", m.cpu ?? void 0],
+			["Memory", m.memory ?? void 0]
+		]);
+		console.log("");
+		if ((replicas.available ?? 0) === 0 && (replicas.desired ?? 0) > 0) {
+			console.log(chalk.yellow("  No replica is available — the pod is not passing its readiness check."));
+			console.log(chalk.gray("  See why with:  ") + chalk.bold("rebase cloud debug logs --previous"));
+			console.log("");
+		}
+	}, {
+		status: m.status ?? null,
+		placement: p
+	});
+}
+async function dbDebugCommand(rawArgs) {
+	const { client } = await requireClient(rawArgs);
+	const projectId = await requireProject(rawArgs, client);
+	let info;
+	try {
+		info = await client.functions.invoke("db-info", void 0, {
+			method: "GET",
+			path: projectId
+		});
+	} catch (e) {
+		reportError(e, "Failed to read database connection info");
+	}
+	const pf = info.portForward;
+	const forwardCmd = pf ? `kubectl port-forward -n ${pf.namespace} svc/${pf.service} ${pf.localPort}:${pf.remotePort}` : null;
+	const psqlCmd = pf && info.username && info.database ? `psql -h 127.0.0.1 -p ${pf.localPort} -U ${info.username} -d ${info.database}` : null;
+	emit(() => {
+		console.log("");
+		console.log(chalk.bold(`  🐘 Database — ${displayProjectRef(rawArgs)}`));
+		console.log("");
+		if (info.unavailableReason) {
+			console.log(chalk.yellow(`  ${info.unavailableReason}`));
+			console.log("");
+			return;
+		}
+		keyValues([
+			["Type", info.type],
+			["Host", info.host],
+			["Port", info.port],
+			["Database", info.database],
+			["Username", info.username],
+			["Password", info.passwordAvailable ? chalk.gray("stored — not shown here") : chalk.yellow("none stored")]
+		]);
+		console.log("");
+		if (forwardCmd) {
+			console.log(chalk.gray("  A managed database is only reachable inside its cluster. To connect:"));
+			console.log("");
+			console.log(`    ${forwardCmd}`);
+			if (psqlCmd) console.log(`    ${psqlCmd}`);
+			console.log("");
+			if (info.passwordAvailable) {
+				console.log(chalk.gray("  Get the password with:  ") + chalk.bold("rebase cloud db info --reveal"));
+				console.log("");
+			}
+		}
+	}, {
+		type: info.type ?? null,
+		host: info.host ?? null,
+		port: info.port ?? null,
+		database: info.database ?? null,
+		username: info.username ?? null,
+		passwordAvailable: Boolean(info.passwordAvailable),
+		portForwardCommand: forwardCmd,
+		psqlCommand: psqlCmd
+	});
+}
+async function debugCommand(action, rawArgs) {
+	switch (action) {
+		case void 0:
+		case "health":
+			await healthCommand(rawArgs);
+			break;
+		case "logs":
+			await logView(rawArgs, {
+				defaultSinceSeconds: 900,
+				limit: 200,
+				title: "📄 Logs"
+			});
+			break;
+		case "errors":
+			await logView(rawArgs, {
+				filter: isErrorLine,
+				defaultSinceSeconds: 3600,
+				limit: 40,
+				title: "🔥 Errors"
+			});
+			break;
+		case "boot":
+			await logView(rawArgs, {
+				filter: isBootLine,
+				defaultSinceSeconds: 168 * 3600,
+				limit: 25,
+				title: "🚀 Boot"
+			});
+			break;
+		case "requests":
+			await requestsCommand(rawArgs);
+			break;
+		case "pod":
+		case "workload":
+			await podCommand(rawArgs);
+			break;
+		case "db":
+			await dbDebugCommand(rawArgs);
+			break;
+		case "help":
+		case "--help":
+			printDebugHelp();
+			break;
+		default:
+			if (isJsonMode()) fail(`Unknown debug command: ${action}`, void 0, "unknown_command");
+			console.error(chalk.red(`Unknown debug command: ${action}`));
+			console.log("");
+			printDebugHelp();
+			process.exit(1);
+	}
+}
+function printDebugHelp() {
+	console.log(`
+${chalk.bold("rebase cloud debug")} — Find out why a deployed project is misbehaving
+
+${chalk.green.bold("Usage")}
+  rebase cloud debug ${chalk.blue("<subcommand>")} [options]
+
+${chalk.green.bold("End-to-end")}
+  ${chalk.blue.bold("health")}                  Probe the live URL and explain every status code ${chalk.gray("(default)")}
+
+${chalk.green.bold("Runtime")}
+  ${chalk.blue.bold("logs")} ${chalk.gray("[--since 15m]")}      Recent application logs
+  ${chalk.blue.bold("errors")} ${chalk.gray("[--since 1h]")}     Error and warning lines only
+  ${chalk.blue.bold("requests")} ${chalk.gray("[--since 15m]")}  HTTP requests the server logged ${chalk.gray("(status, path, latency)")}
+  ${chalk.blue.bold("boot")}                    What the server decided at startup ${chalk.gray("(storage, functions, auth)")}
+  ${chalk.blue.bold("pod")}                     Replicas, image, namespace, cluster placement
+
+${chalk.green.bold("Data")}
+  ${chalk.blue.bold("db")}                      Connection shape + the port-forward recipe ${chalk.gray("(no password)")}
+
+${chalk.green.bold("Options")}
+  ${chalk.blue("--since <dur>")}           Lookback window: ${chalk.gray("90s, 15m, 2h, 1d")}
+  ${chalk.blue("--tail <n>")}              Lines to read per pod ${chalk.gray("(default 500)")}
+  ${chalk.blue("--previous")}              Read the CRASHED container instance ${chalk.gray("(where the reason lives)")}
+  ${chalk.blue("--host <hostname>")}       Probe this address instead of the project's own
+  ${chalk.blue("--collection <name>")}     Collection for the unauth-read probe ${chalk.gray("(default: users)")}
+  ${chalk.blue("--function <name>")}       Also assert this function loaded ${chalk.gray("(checked against the listing)")}
+  ${chalk.blue("--project, -p <slug>")}    Operate on a project without linking
+
+${chalk.gray("Everything here is read-only. `health` exits non-zero when a check fails,")}
+${chalk.gray("so it works in a deploy script. To restart a workload, use `rebase cloud restart`.")}
+`);
+}
+//#endregion
 //#region src/commands/cloud/resources.ts
 /**
 * `rebase cloud` resource subcommands: status, metrics, webhooks, storage,
@@ -5547,6 +6365,9 @@ async function cloudCommand(subcommand, rawArgs) {
 		case "metrics":
 			await metricsCommand(rawArgs);
 			break;
+		case "debug":
+			await debugCommand(action, rawArgs);
+			break;
 		case "env":
 			await envCommand(action, rawArgs);
 			break;
@@ -5658,6 +6479,7 @@ ${chalk.green.bold("Deploy & observe")}
   ${chalk.blue.bold("start|stop|restart")} ${chalk.gray("[-y]")}  Power ops ${chalk.gray("(stop/restart need -y)")}
   ${chalk.blue.bold("status")}                  One-glance project status
   ${chalk.blue.bold("metrics")}                 Live CPU / memory / disk
+  ${chalk.blue.bold("debug")} ${chalk.gray("[health|logs|…]")}    Diagnose a misbehaving deployment ${chalk.gray("(read-only)")}
 
 ${chalk.green.bold("Config")}
   ${chalk.blue.bold("env list|set|unset|reveal|pull")}
@@ -5719,6 +6541,7 @@ async function entry(args) {
 	const command = parsedArgs._[0];
 	const subcommand = parsedArgs._[1];
 	if (!command || parsedArgs["--help"] && ![
+		"init",
 		"schema",
 		"db",
 		"dev",
@@ -5849,6 +6672,6 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
 `);
 }
 //#endregion
-export { authCommand, buildCommand, buildInitQuestions, cloudCommand, configureEnvFile, createRebaseApp, dbCommand, detectPackageManager, devCommand, doctorCommand, entry, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, requireBackendDir, requireProjectRoot, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
+export { authCommand, buildCommand, buildInitQuestions, cloudCommand, configureEnvFile, createRebaseApp, dbCommand, detectPackageManager, devCommand, doctorCommand, entry, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, printInitHelp, requireBackendDir, requireProjectRoot, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, validateProjectName, validateTsxInstallation };
 
 //# sourceMappingURL=index.es.js.map