@devdogsuga/backstage 0.1.0

package/dist/launch.js

@@ -0,0 +1,329 @@
+import { C as discoverRepoRoot, E as setCliName, S as RepoNotFoundError, T as cliName, _ as installFailureLog, d as hasYes, g as stripTierFlag, h as stripNoEnvFlag, m as setNoEnv, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive, s as lastSentryEventId } from "./telemetry-Bjoz29Hl.js";
+import { c as setMenuEnvHook, d as formatCommand, f as nonEmpty, g as loadEnvSession, h as loadEnvLoad, n as bareGroupStartPath, t as catalog, v as helpPath } from "./catalog-BOBE4ee7.js";
+import { c as setDryRun, o as isDryRun, s as resolveDryRun } from "./options-BTjOf5KP.js";
+import { o as unwrap, r as errorMessage } from "./ui-CdKo8mLw.js";
+import { confirm } from "@clack/prompts";
+//#region ../cli-core/src/pipes.ts
+/**
+* Keeps a closed stdout/stderr from crashing devtools.
+*
+* When whatever reads devtools' output goes away first (`devtools … | head`,
+* or a wrapper that stopped listening), the next write fails with EPIPE. The
+* stream emits that as an `'error'` event nobody handles, so Node throws it as
+* an uncaught exception and Sentry files it as a fatal. Nobody is left to read
+* the output, so dropping it is the right outcome. Any other stream error is
+* rethrown and crashes as it did before.
+*
+* Idempotent, because `launch`, `launchCi` and `ci.ts`'s `main` can all run in
+* one process.
+*/
+let installed = false;
+function ignoreClosedPipes() {
+	if (installed) return;
+	installed = true;
+	for (const stream of [process.stdout, process.stderr]) stream.on("error", (err) => {
+		if (err.code !== "EPIPE") throw err;
+	});
+}
+//#endregion
+//#region ../cli-core/src/safety-gate.ts
+/**
+* The production and staging safety gate.
+*
+* devtools can reach any tier, and it cannot tell which `supabase`
+* subcommands write, so the question is asked before ANY command runs against
+* a hosted tier, passthroughs and presets included. This replaces the
+* per-command confirmations `db reset`, `db migrate`, `seed production` and
+* `cf preview` each used to carry.
+*
+*   * production: shows the tier and project ref (never the `DB_URL`, which
+*     holds the password) and asks once, defaulting to no.
+*   * staging: the same, with milder wording.
+*   * non-interactive runs need `--yes`; without it the gate refuses instead
+*     of hanging on a prompt nobody can answer. clack's `confirm()` never
+*     resolves without a TTY, so `--yes` is checked before anything that
+*     could wait on one.
+*   * development (local or remote): no prompt.
+*/
+/** Set once the gate passed, so a devtools run spawned by devtools does not ask again. */
+const GATE_PASSED_ENV = "DEVTOOLS_GATE_PASSED";
+const HOSTED = /* @__PURE__ */ new Set(["staging", "production"]);
+function isHostedTier(tier) {
+	return HOSTED.has(tier);
+}
+async function askClack(message) {
+	return unwrap(await confirm({
+		message,
+		initialValue: false
+	}));
+}
+/**
+* Decides whether a command may run against `tier`. Writes its own refusal to
+* stderr, so the caller only has to exit non-zero on `proceed: false`.
+*/
+async function gateHostedTier(input) {
+	const env = input.env ?? process.env;
+	if (!isHostedTier(input.tier)) return { proceed: true };
+	if (env["DEVTOOLS_GATE_PASSED"] === input.tier) return { proceed: true };
+	const production = input.tier === "production";
+	const target = `${production ? "PRODUCTION" : "staging"} (project ${input.projectRef ?? "unknown"})`;
+	const cli = cliName();
+	const command = formatCommand(cli, input.argv);
+	if (input.yes) {
+		if (input.nonInteractive) process.stderr.write(`${cli}: running \`${command}\` against ${target}.\n`);
+		return { proceed: true };
+	}
+	if (input.nonInteractive) {
+		process.stderr.write(`${cli}: refusing to run \`${command}\` against ${target} without --yes. Nobody is here to confirm it.
+`);
+		return {
+			proceed: false,
+			reason: "refused"
+		};
+	}
+	if (!await (input.ask ?? askClack)(production ? `This runs \`${command}\` against PRODUCTION, project ${input.projectRef ?? "unknown"}. It is live data. Continue?` : `This runs \`${command}\` against staging, project ${input.projectRef ?? "unknown"}. Continue?`)) {
+		process.stderr.write(`${cli}: left ${input.tier} alone.\n`);
+		return {
+			proceed: false,
+			reason: "declined"
+		};
+	}
+	return { proceed: true };
+}
+//#endregion
+//#region src/launch-core.ts
+/**
+* What `backstage` does BEFORE `cli.ts` (and so every command it dispatches)
+* is imported: settle the session's tier, enter it, hand off. `launch.ts` is
+* the entry point the `bin/backstage.mjs` bootstrap runs.
+*
+* ## It starts anywhere
+*
+* `pnpm dlx @devdogsuga/backstage` works from any directory, a DevDogsUGA
+* checkout or not. Nothing here needs one until a command does: help, version,
+* completions and anything run with `--no-env` never look for a repository,
+* and never import the optional-peer `@devdogsuga/*` libraries, which are only
+* installed next to a checkout. A command that reads a checkout (`env`,
+* `deploy <app>`, `planner`…) says "run this from inside a DevDogsUGA clone"
+* and exits 1, instead of a stack trace.
+*
+* ## The session's tier
+*
+* Every command here always needs production secrets, but they name their
+* own targets: `env` takes `--target`, `planner` works on the production
+* database. So unlike devtools, nothing is ever asked at launch:
+*
+*   * `--tier <t>` (anywhere in argv, stripped here), else `DEPLOY_ENV`, names
+*     the session's tier and so the env file loaded (`.env.<tier>`);
+*   * with neither, the session is plain `development` and `.env` is loaded,
+*     which is where `BWS_ACCESS_TOKEN` lives;
+*   * the `deploy` group refuses to run without one of the two. Applying
+*     migrations to whatever `DB_URL` the development `.env` happens to hold is
+*     not a default anybody wants.
+*
+* ## `--no-env`
+*
+* Skips tier resolution and env-file loading: the caller's environment is the
+* environment. For `deploy write-env`, which CREATES the file tier resolution
+* would otherwise insist on reading, and for the CI steps that hold one narrow
+* credential in the job's own `env:` block (`preflight`, `plan`, `migrate`,
+* `smoke`, `reconcile`, `planner status`).
+*
+* ## Staging and production ask first
+*
+* A command that is not read-only asks once before it runs against a hosted
+* tier, `--yes` answers, and with no terminal (or `CI=true`) it refuses
+* without `--yes` (`@devdogsuga/cli-core/safety-gate`).
+*/
+/** The tier words a `--tier` or `DEPLOY_ENV` may carry. */
+const SESSION_TIERS = [
+	"development",
+	"development:local",
+	"development:remote",
+	"staging",
+	"production"
+];
+/** `--tier`, else `DEPLOY_ENV`, else plain development. Exported for the tests. */
+function resolveSession(explicit, deployEnv = process.env.DEPLOY_ENV) {
+	const selector = explicit ?? nonEmpty(deployEnv);
+	if (selector === void 0) return {
+		ok: true,
+		session: {
+			tier: "development",
+			named: false
+		}
+	};
+	if (!SESSION_TIERS.includes(selector)) return {
+		ok: false,
+		reason: `unknown tier "${selector}". Expected: ${SESSION_TIERS.join(", ")}.`
+	};
+	const [tier, qualifier] = selector.split(":");
+	return {
+		ok: true,
+		session: qualifier === void 0 ? {
+			tier,
+			named: true
+		} : {
+			tier,
+			devDatabase: qualifier,
+			named: true
+		}
+	};
+}
+/**
+* Whether the command `argv` names is declared `envFree`: it needs no env
+* file and no tier (`graphics`, `qr`, `github`, `newsletter`), so the session
+* behaves as if `--no-env` was typed. They run in a directory with no
+* checkout and no `.env`, which is the point of `pnpm dlx`.
+*/
+function isEnvFree(argv) {
+	const path = helpPath(argv);
+	for (let end = path.length; end > 0; end -= 1) {
+		const node = catalog.findCommand(path.slice(0, end));
+		if (node) return node.envFree === true;
+	}
+	return false;
+}
+function fail(label, message) {
+	process.stderr.write(`${label}: ${message}\n`);
+	process.exit(1);
+}
+/**
+* Loads the session's env files onto `process.env`, or just names the tier
+* under `--no-env`. Exits on a refusal: there is no command dispatched yet for
+* a caller to fall back to.
+*/
+async function enterSession(session, noEnv, label) {
+	if (noEnv) {
+		process.env.DEPLOY_ENV = session.tier;
+		if (session.devDatabase !== void 0) process.env.DEV_DB = session.devDatabase;
+		return;
+	}
+	if (discoverRepoRoot() === null) fail(label, new RepoNotFoundError().message);
+	const envLoad = await loadEnvLoad();
+	const envSession = await loadEnvSession();
+	process.env[envLoad.SHELL_KEYS_ENV] ??= Object.keys(process.env).join(",");
+	try {
+		const entered = await envSession.enterEnvironment(session.tier, {
+			override: false,
+			devDatabase: session.devDatabase
+		});
+		for (const warning of entered.warnings) process.stderr.write(`${label}: ${warning}\n`);
+		process.stderr.write(`${label}: loaded ${entered.files.length > 0 ? entered.files.join(", ") : "no env files"} (${session.tier})\n`);
+	} catch (err) {
+		if (!(err instanceof envLoad.MissingEnvFileError)) throw err;
+		if (session.tier !== "development") fail(label, err.message);
+		process.stderr.write(`${label}: ${err.message}\n`);
+	}
+}
+/**
+* Runs `proceed` only if the hosted-tier gate lets the command through. A
+* command the gate stops exits non-zero and returns `blocked`.
+*/
+async function gated(session, commandArgv, proceed, blocked, enabled) {
+	if (!enabled || isDryRun() || catalog.findCommand(helpPath(commandArgv))?.dryRun === "read-only") return proceed();
+	if (!(await gateHostedTier({
+		tier: session.tier,
+		projectRef: nonEmpty(process.env.PROJECT_REF),
+		argv: commandArgv,
+		yes: hasYes(commandArgv),
+		nonInteractive: isNonInteractive()
+	})).proceed) {
+		process.exitCode = 1;
+		return blocked;
+	}
+	process.env[GATE_PASSED_ENV] = session.tier;
+	return proceed();
+}
+/**
+* The refusal for a `deploy` command run with no tier named, if it applies.
+* Under `--no-env` the caller supplied the environment, credentials and all,
+* so there is no env file for the tier to choose and nothing to default.
+*/
+function missingTier(argv, session, noEnv) {
+	if (argv[0] !== "deploy" || session.named || noEnv) return null;
+	return "no tier named. A deploy command must be told which environment it is for: pass --tier <staging|production> or set DEPLOY_ENV.";
+}
+/**
+* Resolves the session's tier, enters it, and hands off to `options.dispatch`.
+*/
+async function launchWith(argv, options) {
+	setCliName("backstage");
+	const label = "backstage";
+	const gate = options.gate ?? true;
+	const { noEnv: typedNoEnv, rest: withoutNoEnv } = stripNoEnvFlag(argv);
+	const { explicit, rest: withoutTier } = stripTierFlag(withoutNoEnv);
+	const { dryRun, rest } = resolveDryRun(withoutTier);
+	const noEnv = typedNoEnv || isEnvFree(rest);
+	setNoEnv(noEnv);
+	setDryRun(dryRun);
+	installFailureLog({
+		argv,
+		eventId: lastSentryEventId
+	});
+	ignoreClosedPipes();
+	initDevtoolsTelemetry(rest.slice(0, 2).join(" ") || "menu");
+	const dispatch = async (args) => {
+		try {
+			await options.dispatch(args);
+		} catch (err) {
+			process.stderr.write(`${label}: ${errorMessage(err)}\n`);
+			await captureDevtoolsError(err);
+			process.exit(1);
+		}
+	};
+	if (rest.includes("--help") || rest.includes("-h") || rest[0] === "version" || rest[0] === "completions") {
+		await dispatch(rest);
+		return;
+	}
+	const name = helpPath(rest)[0];
+	if (name !== void 0 && catalog.findCommand([name]) === null) {
+		await dispatch(rest);
+		return;
+	}
+	const resolved = resolveSession(explicit);
+	if (!resolved.ok) fail(label, resolved.reason);
+	const { session } = resolved;
+	if (rest.length === 0 || process.stdin.isTTY === true && bareGroupStartPath(catalog, rest) !== null) {
+		setMenuEnvHook(async (commandArgv, dispatchCommand) => {
+			const chosen = resolveSession(stripTierFlag(commandArgv).explicit);
+			if (!chosen.ok) {
+				process.stderr.write(`${label}: ${chosen.reason}\n`);
+				process.exitCode = 1;
+				return null;
+			}
+			const skipEnv = noEnv || isEnvFree(commandArgv);
+			setNoEnv(skipEnv);
+			const refusal = missingTier(commandArgv, chosen.session, skipEnv);
+			if (refusal) {
+				process.stderr.write(`${label}: ${refusal}\n`);
+				process.exitCode = 1;
+				return null;
+			}
+			await enterSession(chosen.session, skipEnv, label);
+			return gated(chosen.session, commandArgv, dispatchCommand, null, gate);
+		});
+		await dispatch(rest);
+		return;
+	}
+	const refusal = missingTier(rest, session, noEnv);
+	if (refusal) fail(label, refusal);
+	await enterSession(session, noEnv, label);
+	await gated(session, rest, () => dispatch(rest), void 0, gate);
+}
+//#endregion
+//#region src/launch.ts
+/**
+* `backstage`'s entry point, run by the `bin/backstage.mjs` bootstrap. All of
+* the launching is in `launch-core.ts`; this file only says which dispatcher
+* runs the command.
+*/
+async function launch(argv) {
+	await launchWith(argv, { dispatch: async (args) => {
+		const { main } = await import("./cli-YLCe3Zrx.js");
+		await main(args);
+	} });
+}
+if (import.meta.url === `file://${process.argv[1]}`) await launch(process.argv.slice(2));
+//#endregion
+export { launch };

package/dist/options-BTjOf5KP.js

@@ -0,0 +1,183 @@
+import { T as cliName } from "./telemetry-Bjoz29Hl.js";
+//#region ../cli-core/src/dry-run.ts
+const DRY_RUN_FLAG = "--dry-run";
+/** Commands that forward everything after their name to another tool. */
+const FORWARDING = /* @__PURE__ */ new Set([
+	"supabase",
+	"wrangler",
+	"drizzle-kit",
+	"psql",
+	"bw",
+	"run"
+]);
+let active = false;
+function setDryRun(on) {
+	active = on;
+}
+function isDryRun() {
+	return active;
+}
+/**
+* Decides whether `argv` asks for a dry run and returns the argv to dispatch.
+*
+* For a forwarding command a leading `--dry-run` is consumed (the tool never
+* sees it) and a later one is the tool's. For any other command the argv is
+* returned as it came, because several commands read `--dry-run` themselves.
+*/
+function resolveDryRun(argv) {
+	const firstPositional = argv.findIndex((arg) => !arg.startsWith("-"));
+	const lead = firstPositional === -1 ? argv.length : firstPositional;
+	const command = argv[firstPositional];
+	if (command !== void 0 && FORWARDING.has(command)) {
+		const rest = argv.filter((arg, i) => i >= lead || arg !== "--dry-run");
+		return {
+			dryRun: rest.length !== argv.length,
+			rest
+		};
+	}
+	return {
+		dryRun: argv.includes(DRY_RUN_FLAG),
+		rest: [...argv]
+	};
+}
+/**
+* How a command treats `--dry-run`, from the nearest node on its path that
+* says. `undefined` means it did not say, and the dispatcher stops it.
+*/
+function dryRunKind(catalog, path) {
+	for (let end = path.length; end > 0; end -= 1) {
+		const kind = catalog.findCommand(path.slice(0, end))?.dryRun;
+		if (kind !== void 0) return kind;
+	}
+}
+/** The command line a stopped command would have run. */
+function wouldRunLine(argv) {
+	return `Would run: ${cliName()} ${argv.join(" ")}`;
+}
+const QR_FLAGS = {
+	text: {
+		name: "text",
+		value: "<text>",
+		summary: "What to encode: a URL or any text. May be given as the argument."
+	},
+	theme: {
+		name: "theme",
+		value: `<${[
+			"devdogs-light",
+			"devdogs-dark",
+			"acm-light",
+			"acm-dark"
+		].join("|")}>`,
+		summary: "Logo, shape and ink colour in one go, as the console's theme buttons."
+	},
+	size: {
+		name: "size",
+		value: "<px>",
+		summary: "Width and height of the image in pixels. Defaults to 999."
+	},
+	margin: {
+		name: "margin",
+		value: "<modules>",
+		summary: "Quiet zone around the code, in modules. Defaults to 2."
+	},
+	color: {
+		name: "color",
+		value: "<css colour>",
+		summary: "Ink colour. Defaults to the theme's."
+	},
+	background: {
+		name: "background",
+		value: "<css colour|transparent>",
+		summary: "Background colour. Transparent by default."
+	},
+	gradient: {
+		name: "gradient",
+		value: "<from,to>",
+		summary: "Two-colour diagonal gradient for the ink, instead of --color."
+	},
+	shape: {
+		name: "shape",
+		value: "<rounded|square>",
+		summary: "Module shape. Defaults to the theme's."
+	},
+	logo: {
+		name: "logo",
+		value: "<preset|none|file>",
+		summary: `Centre logo: a preset (${[
+			"devdogs",
+			"acm",
+			"discord-white",
+			"discord-black",
+			"discord-blurple"
+		].join(", ")}), none, or an image file path.`
+	},
+	logoSize: {
+		name: "logo-size",
+		value: "<modules>",
+		summary: "Logo width in modules. Defaults to 9."
+	},
+	logoPadding: {
+		name: "logo-padding",
+		value: "<modules>",
+		summary: "Clear space around the logo, in modules. Defaults to 1."
+	},
+	errorLevel: {
+		name: "error-level",
+		value: `<${[
+			"L",
+			"M",
+			"Q",
+			"H"
+		].join("|")}>`,
+		summary: "Error-correction level. Defaults to H."
+	},
+	version: {
+		name: "qr-version",
+		value: "<1-40>",
+		summary: "Force a QR version (grid size). Defaults to the smallest that fits."
+	},
+	formats: {
+		name: "format",
+		value: `<${[
+			"svg",
+			"png",
+			"jpg",
+			"webp",
+			"avif",
+			"tiff"
+		].join(",")}>`,
+		summary: "Output formats, comma-separated, several at once. Defaults to svg,png."
+	}
+};
+/** CLI-only flags: the crop of a logo file, and where the files go. */
+const QR_EXTRA_FLAGS = {
+	logoCrop: {
+		name: "logo-crop",
+		value: "<x,y,width,height>",
+		summary: "Crop a logo file to this region (source pixels) before it goes in the code."
+	},
+	out: {
+		name: "out",
+		value: "<dir>",
+		summary: "Directory for the files. Defaults to the current directory."
+	},
+	name: {
+		name: "name",
+		value: "<stem>",
+		summary: "File name without extension. Defaults to qr."
+	}
+};
+/** The flags as the command catalog declares them (help, completions, menu). */
+function qrCatalogOptions() {
+	return [...Object.values(QR_FLAGS), ...Object.values(QR_EXTRA_FLAGS)].map((flag) => ({
+		flag: `--${flag.name}`,
+		value: flag.value,
+		summary: flag.summary
+	}));
+}
+/** Every flag name `parseArgs` should accept, all string-valued. */
+function qrParseOptions() {
+	return Object.fromEntries([...Object.values(QR_FLAGS), ...Object.values(QR_EXTRA_FLAGS)].map((flag) => [flag.name, { type: "string" }]));
+}
+//#endregion
+export { dryRunKind as a, setDryRun as c, qrParseOptions as i, wouldRunLine as l, QR_FLAGS as n, isDryRun as o, qrCatalogOptions as r, resolveDryRun as s, QR_EXTRA_FLAGS as t };

package/dist/peer-redirect-hooks.js

@@ -0,0 +1,15 @@
+//#region ../cli-core/src/repo/peer-redirect-hooks.ts
+let redirects = [];
+const initialize = (data) => {
+	redirects = data;
+};
+const resolve = (specifier, context, nextResolve) => {
+	const redirect = redirects.find((r) => r.specifier === specifier && r.parentURL === context.parentURL);
+	if (redirect) return {
+		url: redirect.url,
+		shortCircuit: true
+	};
+	return nextResolve(specifier, context);
+};
+//#endregion
+export { initialize, resolve };