@devdogsuga/devtools 0.1.50 → 0.1.51-next.526

package/dist/supabase-project-C93xRFkN.js

@@ -1,436 +0,0 @@
-import { a as cliName, r as noteRan } from "./failure-log-DOt6E3hS.js";
-import { r as findRepoRoot } from "./root-CjPWNkBu.js";
-import { p as resolveLayout } from "./peers-DvUH5VxX.js";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { execFile, execFileSync, spawn } from "node:child_process";
-import { promisify } from "node:util";
-//#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(" ")}`;
-}
-//#endregion
-//#region ../cli-core/src/process-group.ts
-/**
-* Running a child tool so that stopping it stops everything it started.
-*
-* `pnpm run dev` forks a shell that forks vinext that forks workerd. Killing
-* only the pnpm process (what a plain `child.kill()` does, and what a closed
-* terminal tab or a `kill` from another window delivers) orphans the rest,
-* and the orphan keeps its port. So the child gets its own process group, and
-* every stop signal this process receives is sent to the whole group.
-*
-* Ctrl-C needs the same care in reverse: a child in its own group is not in
-* the terminal's foreground group, so the terminal no longer delivers ^C to
-* it. The signal handlers below forward it.
-*
-* The group is only swept after the direct child exits when that exit was a
-* signal we forwarded; a child that exits on its own is left to have cleaned
-* up after itself, so a tool that deliberately leaves a daemon running keeps it.
-*/
-const FORWARDED = [
-	"SIGINT",
-	"SIGTERM",
-	"SIGHUP"
-];
-const SIGNAL_NUMBERS = {
-	SIGHUP: 1,
-	SIGINT: 2,
-	SIGTERM: 15,
-	SIGKILL: 9
-};
-/** How long a group gets to leave after SIGTERM before SIGKILL. */
-const GRACE_MS = 5e3;
-/** Sends `signal` to every process in `pid`'s group. False if it is already gone. */
-function signalGroup(pid, signal) {
-	try {
-		process.kill(process.platform === "win32" ? pid : -pid, signal);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function runInGroup(command, args, opts = {}) {
-	if (isDryRun()) {
-		process.stderr.write(`Would run: ${formatCommand(command, args)}\n`);
-		return Promise.resolve({
-			code: 0,
-			signal: null
-		});
-	}
-	return new Promise((resolve) => {
-		const child = spawn(command, [...args], {
-			stdio: opts.stdio ?? "inherit",
-			cwd: opts.cwd,
-			env: opts.env,
-			detached: process.platform !== "win32"
-		});
-		const pid = child.pid;
-		let forwarded = null;
-		let escalation;
-		const forward = (signal) => {
-			if (pid === void 0) return;
-			forwarded ??= signal;
-			signalGroup(pid, signal);
-			escalation ??= setTimeout(() => signalGroup(pid, "SIGKILL"), GRACE_MS);
-			escalation.unref();
-		};
-		if (opts.abort?.aborted) forward("SIGTERM");
-		else opts.abort?.addEventListener("abort", () => forward("SIGTERM"), { once: true });
-		const handlers = FORWARDED.map((signal) => {
-			const handler = () => forward(signal);
-			process.on(signal, handler);
-			return [signal, handler];
-		});
-		const onExit = () => {
-			if (pid !== void 0) signalGroup(pid, "SIGKILL");
-		};
-		process.on("exit", onExit);
-		const finish = (result) => {
-			noteRan(`${formatCommand(command, args)}  (exit ${result.code})`);
-			for (const [signal, handler] of handlers) process.off(signal, handler);
-			process.off("exit", onExit);
-			if (escalation) clearTimeout(escalation);
-			if (forwarded !== null && pid !== void 0) signalGroup(pid, "SIGKILL");
-			resolve(result);
-		};
-		child.on("error", (error) => {
-			process.stderr.write(`${error.message}\n`);
-			finish({
-				code: 1,
-				signal: null
-			});
-		});
-		child.on("exit", (code, signal) => {
-			const bySignal = signal ? 128 + (SIGNAL_NUMBERS[signal] ?? 0) : 1;
-			finish({
-				code: code ?? bySignal,
-				signal
-			});
-		});
-	});
-}
-const URL_CREDENTIALS = /\/\/[^/@\s]*@/;
-/**
-* The command as a person would type it, for printing. A database URL carries
-* its password, so the value after `--db-url` (and any URL with credentials)
-* is replaced rather than echoed.
-*/
-function formatCommand(command, args) {
-	const shown = [];
-	for (let i = 0; i < args.length; i += 1) {
-		const arg = args[i];
-		if (arg === "--db-url" && i + 1 < args.length) {
-			shown.push(arg, "<DB_URL>");
-			i += 1;
-		} else if (arg.startsWith("--db-url=")) shown.push("--db-url=<DB_URL>");
-		else shown.push(arg.replace(URL_CREDENTIALS, "//***@"));
-	}
-	return [command, ...shown].map((part) => /^[\w@%+=:,./<>*-]+$/.test(part) ? part : JSON.stringify(part)).join(" ");
-}
-/**
-* Prints the exact command that ran, AFTER it ran so the tool's own output
-* cannot bury it. On stderr, so a tool whose stdout is a pipe stays clean.
-*/
-function reportRan(command, args, result) {
-	if (isDryRun()) return;
-	const status = result.code === 0 ? "" : `  (exit ${result.code})`;
-	process.stderr.write(`Ran: ${formatCommand(command, args)}${status}\n`);
-}
-//#endregion
-//#region ../cli-core/src/db/run.ts
-/**
-* Shared helpers for running supabase CLI and pnpm commands.
-*
-* The supabase CLI is a workspace devDependency (not a global install), so
-* every invocation goes through `pnpm exec supabase`. Plain pnpm commands run
-* in `findRepoRoot()`; the supabase ones run in DevDogsUGA's root
-* (`supabaseRoot()`), where `supabase/config.toml` lives and where the CLI is
-* installed. From a Backstage checkout that is `<root>/devdogsuga`, so it needs
-* its own `pnpm install` there before any of these work.
-*/
-const runFile = promisify(execFile);
-/** Where `supabase/` lives, and so the cwd of every supabase CLI call. */
-function supabaseRoot() {
-	return resolveLayout().devdogsugaRoot;
-}
-/** Spawn a pnpm command with inherited stdio; resolves to the exit code. Pass
-* `env` to run the child against a loaded tier rather than process.env. The
-* child runs in its own process group, so stopping this process stops
-* whatever it started (see `process-group.ts`). */
-async function run(args, env, cwd = findRepoRoot()) {
-	const result = await runInGroup("pnpm", args, {
-		cwd,
-		...env ? { env } : {}
-	});
-	if (reporting) reportRan("pnpm", args, result);
-	return result.code;
-}
-let reporting = false;
-/**
-* Makes every `run()` after this print the exact command it ran (on stderr,
-* after it finishes). Off by default, so a deploy log or a piped command is
-* not changed under its caller; the presets turn it on because showing the
-* tool calls behind a button is their whole point.
-*/
-function reportRuns(enabled) {
-	reporting = enabled;
-}
-/** Spawn a pnpm command while echoing and retaining stderr for diagnostics.
-* Pass `env` to run the child against a loaded tier rather than process.env. */
-function runWithStderr(args, env, cwd = findRepoRoot()) {
-	return new Promise((resolve) => {
-		const child = spawn("pnpm", args, {
-			stdio: [
-				"inherit",
-				"inherit",
-				"pipe"
-			],
-			cwd,
-			...env ? { env } : {}
-		});
-		let stderr = "";
-		child.stderr.setEncoding("utf8");
-		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
-			process.stderr.write(chunk);
-		});
-		child.on("error", (error) => {
-			const message = `${error.message}\n`;
-			stderr += message;
-			process.stderr.write(message);
-			resolve({
-				code: 1,
-				stderr
-			});
-		});
-		child.on("exit", (code) => resolve({
-			code: code ?? 1,
-			stderr
-		}));
-	});
-}
-/** Spawn a pnpm command, capture stdout, throw on non-zero exit. */
-async function capture(args, cwd = findRepoRoot()) {
-	const { stdout } = await runFile("pnpm", args, {
-		cwd,
-		encoding: "utf8"
-	});
-	return stdout;
-}
-/** `pnpm exec supabase …` with inherited stdio. */
-const supabase = (...args) => run([
-	"exec",
-	"supabase",
-	...args
-], void 0, supabaseRoot());
-/** `pnpm exec supabase …` with captured stdout. */
-const supabaseCapture = (...args) => capture([
-	"exec",
-	"supabase",
-	...args
-], supabaseRoot());
-/**
-* `supabase db push` over `dbUrl`, inherited stdio, resolving to the exit code.
-*
-* The one spelling of the migration push, shared by the contributor `db
-* migrate` path (`stack.ts`'s `pushMigrations`) and CI's `deploy migrate`.
-* `--yes` is the unattended apply CI wants; the contributor path omits it so a
-* human still confirms. `includeSeed` adds the `[db.seed]` files, which the
-* CLI runs once each and records in `supabase_migrations.seed_files`. Neither variant regenerates types — that is
-* `pushMigrations`' own second step, layered on top only where a checkout is
-* meant to be rewritten. A CI apply must NOT write back into the repo, which is
-* exactly why the bare push is factored out here rather than reused whole.
-*/
-function dbPush(dbUrl, opts = {}) {
-	const args = [
-		"db",
-		"push",
-		"--db-url",
-		dbUrl
-	];
-	if (opts.includeSeed) args.push("--include-seed");
-	if (opts.yes) args.push("--yes");
-	return supabase(...args);
-}
-/** Seed storage buckets on the local stack or a resolved tier's project. */
-async function seedBuckets(conn) {
-	if (conn.kind === "local") return supabase("seed", "buckets", "--local", "--yes");
-	if (!conn.projectRef) {
-		process.stderr.write("devtools db: seed buckets against a hosted project needs PROJECT_REF in the session's env file.\n");
-		return 1;
-	}
-	return supabase("seed", "buckets", "--project-ref", conn.projectRef, "--linked");
-}
-//#endregion
-//#region ../cli-core/src/repo/supabase-project.ts
-/**
-* This repo's Supabase project id — read from `supabase/config.toml` — and
-* the container-name conventions the Supabase CLI derives from it.
-*
-* Shared by `environment.ts`'s adaptive-menu probe (does a stack answer for
-* THIS project?) and the foreign-stack detection in `db/generated-env.ts`
-* and `stack.ts` (does a DIFFERENT project's stack hold the shared ports? —
-* the case where `supabase status -o env` fails not because nothing is
-* running, but because what is running on 127.0.0.1:54321 belongs to
-* another workspace, or to this same repo before/after a `project_id`
-* rename). One project-id reader and one container-name parser, so both
-* questions agree on what "this project" means.
-*/
-/**
-* Reads `project_id` out of `<repoRoot>/supabase/config.toml`, or `null`
-* when the file is missing or unparsable.
-*
-* Regex, not a TOML parser: it is one line, the shape has been stable
-* across every CLI version this repo has seen, and a parser on a path some
-* callers pay before their first real subprocess is a cost that stays
-* invisible until it is why the tool feels slow.
-*/
-function readProjectId(repoRoot) {
-	try {
-		const path = join(repoRoot, "supabase", "config.toml");
-		return /^\s*project_id\s*=\s*"([^"]+)"/m.exec(readFileSync(path, "utf8"))?.[1] ?? null;
-	} catch {
-		return null;
-	}
-}
-/**
-* The Supabase CLI's container name prefix for a project id, or the bare
-* `supabase_db_` fallback when the id could not be read.
-*
-* Falling back to the bare prefix means a machine whose `config.toml`
-* cannot be read still detects *a* stack, at the cost of over-matching a
-* differently-named project — deliberate, and unchanged from this
-* function's original home in `environment.ts`: over-matching offers
-* `stop`/a foreign-stack hint for a stack that turns out to be this
-* project's own, which is harmless to see and decline, while
-* under-matching hides a real signal entirely.
-*/
-function containerPrefix(projectId) {
-	return projectId ? `supabase_db_${projectId}` : "supabase_db_";
-}
-/**
-* The local stack's API port, published by its Kong container. Mirrors
-* `@devdogsuga/env/load`'s `LOCAL_STACK_PORT`, which this module cannot import
-* statically (that package is an optional peer, loaded on demand).
-*/
-const STACK_API_PORT = 54321;
-function defaultExec(file, args) {
-	try {
-		return execFileSync(file, args, {
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			],
-			timeout: 3e3
-		});
-	} catch {
-		return null;
-	}
-}
-/**
-* `docker ps --format '{{.Names}}'`, split into trimmed, non-empty names —
-* or `null` when Docker could not be read at all (no daemon, not
-* installed, timed out). With `publish`, only the containers publishing that
-* host port. `execute` is injectable for tests, mirroring `environment.ts`'s
-* own probes.
-*/
-function listContainerNames(publish, execute = defaultExec) {
-	const out = execute("docker", [
-		"ps",
-		...publish === void 0 ? [] : ["--filter", `publish=${publish}`],
-		"--format",
-		"{{.Names}}"
-	]);
-	if (out === null) return null;
-	return out.split("\n").map((name) => name.trim()).filter((name) => name.length > 0);
-}
-/**
-* Finds the `supabase_kong_<id>` container among `names` whose id differs
-* from `projectId` — the signature of a stack started from a DIFFERENT
-* Supabase project (this same repo before/after a rename, or another
-* project entirely) holding the shared ports. Kong is the container that
-* publishes the API port, so callers pass the names `listContainerNames`
-* returns for `STACK_API_PORT`: that names the stack actually on 54321,
-* not just any Supabase stack on the machine.
-*
-* Returns that foreign id, or `null` when every matching container belongs
-* to this project, none match at all, or `projectId` itself could not be
-* read — with no known id of our own, there is nothing to compare against,
-* and guessing would risk telling a contributor their OWN stack is
-* foreign.
-*/
-function foreignStackProjectId(names, projectId) {
-	if (projectId === null) return null;
-	for (const name of names) {
-		const match = /^supabase_kong_(.+)$/.exec(name);
-		if (!match) continue;
-		const id = match[1];
-		if (id !== projectId) return id;
-	}
-	return null;
-}
-/**
-* The actionable message for a detected foreign stack — shared by
-* `db/generated-env.ts` (a failed `supabase status -o env`) and `stack.ts`
-* (a failed `supabase start`), so both name the same fix in the same
-* words.
-*/
-function foreignStackMessage(foreignProjectId) {
-	return `The stack on port ${STACK_API_PORT} belongs to project "${foreignProjectId}", not this checkout's. Stop it with \`supabase stop --project-id ${foreignProjectId}\` then \`pnpm devtools supabase start\`.`;
-}
-//#endregion
-export { wouldRunLine as S, runInGroup as _, listContainerNames as a, resolveDryRun as b, reportRuns as c, seedBuckets as d, supabase as f, reportRan as g, formatCommand as h, foreignStackProjectId as i, run as l, supabaseRoot as m, containerPrefix as n, readProjectId as o, supabaseCapture as p, foreignStackMessage as r, dbPush as s, STACK_API_PORT as t, runWithStderr as u, dryRunKind as v, setDryRun as x, isDryRun as y };