@devdogsuga/devtools 0.1.42 → 0.1.44

package/README.md

@@ -74,6 +74,24 @@ rather than a table here. Its first screen lists every interactive command
 under a plain-English title ("Restart local Supabase") with the command to
 type beside it (`restart-stack`).
 
+## Which repo it runs in
+
+Both CLIs run from a DevDogsUGA checkout or from Backstage's (`package.json`
+name `devdogs-monorepo` or `backstage`; the layout code is
+`packages/cli-core/src/repo/layout.ts`). From Backstage, DevDogsUGA is
+`<root>/devdogsuga`: a gitignored symlink to the sibling clone locally
+(`pnpm devdogsuga`), a real checkout at the pinned SHA in CI.
+
+| What                                                                                                  | Where                                                                                                                                                                                                                              |
+| ----------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `supabase/` (CLI cwd, config, migrations, seeds, avatars, env manifest), `database.types.ts`, `docs/` | DevDogsUGA's root (`devdogsuga/` from Backstage)                                                                                                                                                                                   |
+| `workers.json`, `.github/`                                                                            | the repo you are in; DevDogsUGA without one manages no Workers                                                                                                                                                                     |
+| apps (`cron`, `run`, `deploy <app>`, env manifests)                                                   | the repo you are in plus DevDogsUGA's `apps/`; on a name clash the repo you are in wins                                                                                                                                            |
+| `.env`, `.env.<tier>`, `.env.generated`                                                               | the root of the repo you are in; `deploy write-env` and the local stack's `.env.generated` also write DevDogsUGA's root, because schedule-builder reads its own repo root. `env pull\|push\|reset` touch only the root you are in. |
+
+`pnpm exec supabase` and `wrangler` run inside DevDogsUGA's workspace, so
+`devdogsuga/` needs its own `pnpm install` before the commands that use them.
+
 ## Telemetry disclosure
 
 This CLI reports its own crashes to Sentry (see `src/telemetry.ts`), on by

package/dist/{cli-BkHyIT5V.js → cli-B_AiECh4.js}

@@ -1,11 +1,11 @@
-import { a as cliName, d as positionals, u as flagValue } from "./failure-log-B5GG_8T1.js";
-import { C as helpPath, S as catalog, T as renderHelp, _ as bail, a as recordEnteredTier, b as explainError, c as describeEnvironment, d as resolveDbConnection, f as sessionIsLocal, i as beginInvocation, l as probeEnvironment, n as bareGroupStartPath, o as recordResolved, p as sessionLabel, r as runMenu, s as reproducibleCommand, t as bareGroupStartFlags, u as nonEmpty, v as errorMessage, w as renderCommandList, x as unwrap, y as explain } from "./menu-DXT1ICTI.js";
-import { _ as dryRunKind, c as reportRuns, f as supabase, g as runInGroup, h as reportRan, l as run$1, s as dbPush, u as runWithStderr, v as isDryRun, x as wouldRunLine } from "./supabase-project-Bw8sBFcE.js";
-import { a as ownVersion, n as discoverRepoRoot, r as findRepoRoot } from "./root-C2OmZDwD.js";
-import { i as loadEnvSession, n as loadEnv, r as loadEnvLoad, t as getEnvSync } from "./peers-RBplwovA.js";
-import { d as hasYes, f as isNonInteractive, n as captureDevtoolsError, o as initDevtoolsTelemetry, r as devtoolsEnvironment, t as captureDevtoolsDeprecation } from "./telemetry-xNMpvX5K.js";
-import { n as assertRegistryLoaded, r as loadRegistry, t as scopedProcessEnv } from "./local-env-hH4encfD.js";
-import { t as runStackCommand } from "./stack-7PuRcaI2.js";
+import { a as cliName, d as positionals, u as flagValue } from "./failure-log-DOt6E3hS.js";
+import { C as helpPath, S as catalog, T as renderHelp, _ as bail, a as recordEnteredTier, b as explainError, c as describeEnvironment, d as resolveDbConnection, f as sessionIsLocal, i as beginInvocation, l as probeEnvironment, n as bareGroupStartPath, o as recordResolved, p as sessionLabel, r as runMenu, s as reproducibleCommand, t as bareGroupStartFlags, u as nonEmpty, v as errorMessage, w as renderCommandList, x as unwrap, y as explain } from "./menu-DYQ-Dd-O.js";
+import { S as wouldRunLine, _ as runInGroup, c as reportRuns, f as supabase, g as reportRan, l as run$1, m as supabaseRoot, s as dbPush, u as runWithStderr, v as dryRunKind, y as isDryRun } from "./supabase-project-C93xRFkN.js";
+import { a as ownVersion, n as discoverRepoRoot, r as findRepoRoot } from "./root-CjPWNkBu.js";
+import { c as devdogsugaRootOrNull, d as listApps, f as resolveAppPath, i as loadEnvSession, l as findApp, n as loadEnv, p as resolveLayout, r as loadEnvLoad, s as appWorkspaceRoot, t as getEnvSync, u as layoutAt } from "./peers-DvUH5VxX.js";
+import { d as hasYes, f as isNonInteractive, n as captureDevtoolsError, o as initDevtoolsTelemetry, r as devtoolsEnvironment, t as captureDevtoolsDeprecation } from "./telemetry-C07-ioHm.js";
+import { n as assertRegistryLoaded, r as loadRegistry, t as scopedProcessEnv } from "./local-env-BuHU5Ckd.js";
+import { t as runStackCommand } from "./stack-C_50FafG.js";
 import { cancel, confirm, intro, isCancel, log, multiselect, note, outro, password, select, spinner, text } from "@clack/prompts";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { chmod, readFile, writeFile } from "node:fs/promises";
@@ -112,6 +112,19 @@ async function checkEnv(root) {
 		]
 	];
 	for (const [label, actual, expected] of pins) if (JSON.stringify(actual) !== JSON.stringify(expected)) problems.push(`The ${label} set is [${actual.join(", ")}]; expected exactly [${expected.join(", ")}]. A change here re-routes a credential: update this pin deliberately.`);
+	if (typeof env.buildKeys === "function") {
+		const build = env.buildKeys();
+		const expectedBuild = [
+			"API_URL",
+			"BASE_URL",
+			"NEXT_PUBLIC_TURNSTILE_SITE_KEY",
+			"PLATFORM_SENTRY_DSN",
+			"PUBLISHABLE_KEY",
+			"SCHEDULE_BUILDER_SENTRY_DSN"
+		];
+		if (JSON.stringify(build) !== JSON.stringify(expectedBuild)) problems.push(`The build set is [${build.join(", ")}]; expected exactly [${expectedBuild.join(", ")}]. A change here changes what the build workflows read from \`<tier>-build\`: update both deliberately.`);
+		for (const key of build) if (!variableSet.has(key)) problems.push(`${key} is build: true but is not in variableKeys(), so push cannot write it to the build environment.`);
+	}
 	for (const key of narrowed) for (const entry of registry.get(key) ?? []) if (entry.meta.scope !== "environment") problems.push(`${key} is narrowed with scope "${entry.meta.scope}".`);
 	let routed = 0;
 	for (const [key, entries] of registry) {
@@ -245,7 +258,7 @@ function checkMigrationOrder(root, baseRef) {
 //#endregion
 //#region ../cli-core/src/workers.ts
 /**
-* The one list of Worker apps, read from root `workers.json`.
+* The one list of Worker apps, read from `workers.json` at the root of the repo you are in.
 *
 * Six call sites across `devtools` and `env` used to carry their own copy of
 * `["platform", "sandbox", "schedule-builder"]` — a CLI's app-choice list, a
@@ -270,11 +283,27 @@ function parseWorkerEntries(json) {
 		throw new Error(`workers.json entry ${index} must be a path string or an object with a "path".`);
 	});
 }
-/** Every entry in root `workers.json`. */
+/**
+* Every entry in `workers.json` at the root of the repo you are in. DevDogsUGA
+* after the platform moved to Backstage has no such file: no Worker apps are
+* managed there, so the list is empty rather than an error. A Backstage
+* checkout always has one, so a missing file there is still an error.
+*/
 function workerEntries() {
-	cachedWorkerEntries ??= parseWorkerEntries(JSON.parse(readFileSync(join(findRepoRoot(), "workers.json"), "utf8")));
+	if (cachedWorkerEntries === void 0) {
+		const layout = resolveLayout();
+		const file = join(layout.root, "workers.json");
+		cachedWorkerEntries = layout.kind === "devdogsuga" && !existsSync(file) ? [] : parseWorkerEntries(JSON.parse(readFileSync(file, "utf8")));
+	}
 	return cachedWorkerEntries;
 }
+/**
+* The directory of a Worker app by its `workers.json` path: under the repo
+* you are in, else under DevDogsUGA's (schedule-builder, from Backstage).
+*/
+function workerAppDir(entryPath) {
+	return resolveAppPath(entryPath);
+}
 /** Workspace-relative paths, exactly as listed in root `workers.json`. */
 function workerPaths() {
 	return workerEntries().map((entry) => entry.path);
@@ -353,17 +382,37 @@ function deployMatrixApps(yamlText) {
 function sameSet(a, b) {
 	return a.length === b.length && a.every((item) => b.includes(item));
 }
-/** Every drift between `workers.json`, the workspace and the deploy matrix,
-* as one readable line each. Empty means in step. */
-function checkWorkers(root) {
+/**
+* Every drift between `workers.json`, the workspace and the deploy matrix,
+* as one readable line each. Empty means in step.
+*
+* `workers.json` lives at the root of the repo being checked. DevDogsUGA
+* without one manages no Worker apps (the platform moved to Backstage), so
+* there is nothing to check. From a Backstage checkout the apps are looked up
+* in both repos, since schedule-builder is deployed from Backstage but stays in
+* DevDogsUGA's `apps/`.
+*/
+function checkWorkers(root, layout = layoutAt(root)) {
 	const problems = [];
-	const paths = parseWorkerEntries(JSON.parse(readFileSync(join(root, "workers.json"), "utf8"))).map((entry) => entry.path);
+	const workersFile = join(root, "workers.json");
+	if (!existsSync(workersFile)) {
+		if (layout.kind === "devdogsuga") return [];
+		return ["workers.json does not exist."];
+	}
+	const paths = parseWorkerEntries(JSON.parse(readFileSync(workersFile, "utf8"))).map((entry) => entry.path);
 	const apps = paths.map((path) => basename(path));
-	const withWrangler = expandWorkspacePackages(root, workspaceGlobs(readFileSync(join(root, "pnpm-workspace.yaml"), "utf8"))).filter((relative) => existsSync(join(root, relative, "wrangler.jsonc")));
+	const roots = [root];
+	if (layout.kind === "backstage" && layout.hasDevdogsuga) roots.push(layout.devdogsugaRoot);
+	const scanned = [...new Set(roots.flatMap((dir) => {
+		const workspace = join(dir, "pnpm-workspace.yaml");
+		return existsSync(workspace) ? expandWorkspacePackages(dir, workspaceGlobs(readFileSync(workspace, "utf8"))) : [];
+	}))];
+	const dirOf = (relative) => join(roots.find((dir) => existsSync(join(dir, relative))) ?? root, relative);
+	const withWrangler = scanned.filter((relative) => existsSync(join(dirOf(relative), "wrangler.jsonc")));
 	for (const path of withWrangler.filter((p) => !paths.includes(p))) problems.push(`${path} has a wrangler.jsonc but is not in workers.json.`);
 	for (const path of paths.filter((p) => !withWrangler.includes(p))) problems.push(`workers.json lists ${path}, which has no wrangler.jsonc.`);
 	for (const path of paths) {
-		const manifest = join(root, path, "package.json");
+		const manifest = join(dirOf(path), "package.json");
 		if (!existsSync(manifest)) continue;
 		const name = JSON.parse(readFileSync(manifest, "utf8")).name;
 		const slug = path.split("/").pop();
@@ -371,6 +420,7 @@ function checkWorkers(root) {
 	}
 	const deployApp = join(root, ".github", "workflows", "deploy-app.yaml");
 	if (!existsSync(deployApp)) {
+		if (layout.kind === "backstage") return problems;
 		problems.push(".github/workflows/deploy-app.yaml does not exist.");
 		return problems;
 	}
@@ -511,7 +561,7 @@ function report(name, problems, ok) {
 }
 function migrations(rest) {
 	const base = flagValue(rest, "--base") ?? DEFAULT_BASE;
-	const { baseLatest, violations } = checkMigrationOrder(findRepoRoot(), base);
+	const { baseLatest, violations } = checkMigrationOrder(resolveLayout().devdogsugaRoot, base);
 	return report("migrations", violations.map((v) => `${v.filename} (${v.timestamp}) sorts before ${base}'s newest migration (${baseLatest}). Recreate it with a fresh timestamp (\`devtools new-migration\`) and regenerate types.`), `in order (${base}'s newest: ${baseLatest ?? "none"}).`);
 }
 async function run(rest) {
@@ -1201,10 +1251,11 @@ async function runEnvironmentDoctor(opts) {
 			fix: machine.stack === "no" && machine.docker === "yes" ? "Start it with `pnpm devtools supabase start`." : void 0
 		});
 	}
-	if (repoRoot) checks.push(typesFreshness(repoRoot));
+	const supabaseRoot = repoRoot ? devdogsugaRootOrNull(layoutAt(repoRoot)) : null;
+	if (supabaseRoot) checks.push(typesFreshness(supabaseRoot));
 	const sessionDbUrl = process.env.DB_URL;
-	if (repoRoot && sessionDbUrl) try {
-		checks.push(...databaseChecks(await probeDatabase(sessionDbUrl), readDeclaredBuckets(repoRoot)));
+	if (supabaseRoot && sessionDbUrl) try {
+		checks.push(...databaseChecks(await probeDatabase(sessionDbUrl), readDeclaredBuckets(supabaseRoot)));
 	} catch (err) {
 		checks.push({
 			id: "database-unreachable",
@@ -2328,9 +2379,8 @@ function workflowsForTier(config, tier) {
 }
 /** Every app that actually carries a Wrangler configuration. */
 function discoverWranglerConfigs() {
-	const appsRoot = join(findRepoRoot(), "apps");
-	return readdirSync(appsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-		const path = join(appsRoot, entry.name, "wrangler.jsonc");
+	return listApps().flatMap((entry) => {
+		const path = join(entry.dir, "wrangler.jsonc");
 		return existsSync(path) ? [{
 			app: entry.name,
 			path,
@@ -2347,7 +2397,7 @@ function discoverWranglerConfigs() {
 async function discoverCronMaps() {
 	const results = [];
 	for (const { app } of discoverWranglerConfigs()) {
-		const scheduledPath = join(findRepoRoot(), "apps", app, "cloudflare", "scheduled.ts");
+		const scheduledPath = join(findApp(app) ?? join(findRepoRoot(), "apps", app), "cloudflare", "scheduled.ts");
 		if (!existsSync(scheduledPath)) continue;
 		const mod = await import(pathToFileURL(scheduledPath).href);
 		const parsed = CronRoutes.safeParse(mod.CRON_ROUTES);
@@ -2560,7 +2610,7 @@ function readEnvFile(path) {
 /** Resolve the selected app's origin without assuming every app uses port 3000. */
 function resolveBaseUrl(app, tier, config, tierEnv) {
 	if (tier === "development" && app) {
-		const appRoot = join(findRepoRoot(), "apps", app);
+		const appRoot = findApp(app) ?? join(findRepoRoot(), "apps", app);
 		const local = {
 			...readEnvFile(join(appRoot, ".dev.vars.example")),
 			...readEnvFile(join(appRoot, ".dev.vars"))
@@ -2630,7 +2680,7 @@ function workspaceDepsBuildCommand(app) {
 /** Build only `app`'s workspace dependencies — all `vinext dev` needs, since
 * it compiles the app itself on demand. */
 function buildWorkspaceDeps(app) {
-	return run$1(workspaceDepsBuildCommand(app));
+	return run$1(workspaceDepsBuildCommand(app), void 0, appWorkspaceRoot(app));
 }
 //#endregion
 //#region src/workflows/commands.ts
@@ -2770,7 +2820,7 @@ function pidIsAlive(pid) {
 }
 function appDir(app) {
 	const path = workerPaths().find((candidate) => basename(candidate) === app);
-	return path === void 0 ? void 0 : join(findRepoRoot(), path);
+	return path === void 0 ? void 0 : workerAppDir(path);
 }
 /** Probe Wrangler's Workflow explorer API, rather than merely checking a port. */
 async function isWranglerDevRunning(port, timeoutMs = 1e3, fetcher = fetch) {
@@ -2853,7 +2903,7 @@ async function startTemporaryWrangler(app, requestedPort) {
 		return null;
 	}
 	const child = spawn("pnpm", vinextDevArgs(app, port), {
-		cwd: findRepoRoot(),
+		cwd: appWorkspaceRoot(app),
 		stdio: "inherit",
 		detached: process.platform !== "win32",
 		env: await scopedProcessEnv(app, loaded.env, "development")
@@ -3060,7 +3110,7 @@ async function runWorkflowsRun(argv) {
 	if (givenPort === void 0 && options.port && options.port !== "8787") recordResolved("--port", options.port);
 	process.stdout.write(`→ ${choice.name} (${choice.app}, ${tier})\n`);
 	try {
-		const result = await runWithStderr(workflowTriggerArgs(choice, options), triggerEnv);
+		const result = await runWithStderr(workflowTriggerArgs(choice, options), triggerEnv, appWorkspaceRoot(choice.app));
 		if (result.code !== 0 && tier === "development" && isWranglerDevConnectionFailure(result.stderr)) process.stderr.write(wranglerDevConnectionHint(choice.app, options.port ?? "8787"));
 		if (result.code === 0 && tier === "development" && options.instanceId) try {
 			return await waitForLocalWorkflow(choice.name, options.instanceId, options.port ?? "8787");
@@ -3980,6 +4030,11 @@ function runStatus(argv, cwd) {
 * reasons that have nothing to do with Supabase.
 */
 function detectLocalSupabase(cwd) {
+	const repoRoot = discoverRepoRoot(cwd);
+	if (repoRoot !== null) {
+		const layout = layoutAt(repoRoot);
+		if (layout.kind === "backstage" && layout.hasDevdogsuga) cwd = layout.devdogsugaRoot;
+	}
 	let output;
 	try {
 		output = runStatus([
@@ -5408,7 +5463,7 @@ async function runSupabaseRaw(args) {
 		"supabase",
 		...args
 	];
-	const result = await runInGroup("pnpm", full, { cwd: findRepoRoot() });
+	const result = await runInGroup("pnpm", full, { cwd: supabaseRoot() });
 	reportRan("pnpm", full, result);
 	return result.code;
 }
@@ -5482,7 +5537,7 @@ async function regenerateTypes() {
 		"run",
 		"types:db"
 	];
-	const result = await runInGroup("pnpm", args, { cwd: findRepoRoot() });
+	const result = await runInGroup("pnpm", args, { cwd: supabaseRoot() });
 	reportRan("pnpm", args, result);
 	return result.code;
 }
@@ -5710,6 +5765,28 @@ const NEEDS_DEPS_BUILT = /* @__PURE__ */ new Set([
 	"lint:fix",
 	"test"
 ]);
+/** The workspace root an app lives in: `<root>/apps/<name>` gives `<root>`. */
+function workspaceRootOfApp(dir) {
+	return dirname(dirname(dir));
+}
+/**
+* Splits `filters` by the workspace that holds the app each one names. From a
+* Backstage checkout `schedule-builder` belongs to DevDogsUGA's workspace, and
+* a `pnpm --filter` run from Backstage's root would match nothing. A filter
+* naming no known app (a glob, a path) stays with the repo you are in. No
+* filters means the whole workspace of the repo you are in.
+*/
+function groupFiltersByRoot(filters, apps = appsWith(), repoRoot = findRepoRoot()) {
+	const groups = /* @__PURE__ */ new Map([[repoRoot, []]]);
+	for (const filter of filters) {
+		const root = apps.find((app) => app.name === filter)?.root ?? repoRoot;
+		const group = groups.get(root) ?? [];
+		group.push(filter);
+		groups.set(root, group);
+	}
+	if (filters.length > 0 && groups.get(repoRoot)?.length === 0) groups.delete(repoRoot);
+	return groups;
+}
 /**
 * Runs one `pnpm` invocation to completion, reporting its own exit the way
 * `passthroughApps` needs to: it returns to keep going, and exits the process
@@ -5727,9 +5804,9 @@ const NEEDS_DEPS_BUILT = /* @__PURE__ */ new Set([
 * `packages/devtools`, and a `pnpm -r`/`--filter` invoked there would scope
 * itself relative to that one package rather than the workspace root.
 */
-async function runOne(args, extraEnv, { final }) {
+async function runOne({ args, cwd }, extraEnv, { final }) {
 	const result = await runInGroup("pnpm", args, {
-		cwd: findRepoRoot(),
+		cwd,
 		env: {
 			...process.env,
 			...extraEnv,
@@ -5749,7 +5826,7 @@ async function runOne(args, extraEnv, { final }) {
 * Never returns: `runOne` exits on a failure and on the final command.
 */
 async function passthrough(commands, extraEnv) {
-	for (const [index, args] of commands.entries()) await runOne(args, extraEnv, { final: index === commands.length - 1 });
+	for (const [index, command] of commands.entries()) await runOne(command, extraEnv, { final: index === commands.length - 1 });
 	process.exit(1);
 }
 /**
@@ -5820,19 +5897,31 @@ function extractFilters(args) {
 * `packages/*`/`docs` package is reachable from at least one app's
 * dependency graph, and no app depends on another app).
 */
-function allAppNames() {
-	const dir = join(findRepoRoot(), "apps");
-	if (!existsSync(dir)) return [];
+function allAppNames(root = findRepoRoot()) {
 	const names = [];
-	for (const entry of readdirSync(dir)) {
-		const manifest = join(dir, entry, "package.json");
+	for (const app of appManifests(root)) if (app.pkg.name) names.push(app.pkg.name);
+	return names;
+}
+/**
+* The parsed `package.json` of every app in the repo you are in, plus DevDogsUGA's
+* from a Backstage checkout (`repo/layout.ts`). With `root`, only that
+* workspace's. An unparsable manifest is one we cannot use, so it is skipped.
+*/
+function appManifests(root) {
+	const found = [];
+	for (const app of listApps(resolveLayout())) {
+		const appRoot = workspaceRootOfApp(app.dir);
+		if (root !== void 0 && appRoot !== root) continue;
+		const manifest = join(app.dir, "package.json");
 		if (!existsSync(manifest)) continue;
 		try {
-			const pkg = JSON.parse(readFileSync(manifest, "utf8"));
-			if (pkg.name) names.push(pkg.name);
+			found.push({
+				root: appRoot,
+				pkg: JSON.parse(readFileSync(manifest, "utf8"))
+			});
 		} catch {}
 	}
-	return names;
+	return found;
 }
 /**
 * Builds the `pnpm run <task>` invocation(s) for a set of package filters (or
@@ -5885,27 +5974,35 @@ function allAppNames() {
 */
 async function passthroughApps(task, filters, rest, extraEnv) {
 	const commands = [];
-	if (NEEDS_DEPS_BUILT.has(task) && (task !== "build" || filters.length > 0)) {
-		const depsFilters = (filters.length > 0 ? filters : allAppNames()).flatMap((f) => ["--filter", `${f}^...`]);
-		commands.push([
-			"-r",
-			"--if-present",
-			...depsFilters,
-			"run",
-			"build"
-		]);
+	for (const [cwd, groupFilters] of groupFiltersByRoot(filters)) {
+		if (NEEDS_DEPS_BUILT.has(task) && (task !== "build" || filters.length > 0)) {
+			const depsFilters = (groupFilters.length > 0 ? groupFilters : allAppNames(cwd)).flatMap((f) => ["--filter", `${f}^...`]);
+			commands.push({
+				args: [
+					"-r",
+					"--if-present",
+					...depsFilters,
+					"run",
+					"build"
+				],
+				cwd
+			});
+		}
+		const ownFilters = groupFilters.flatMap((f) => ["--filter", f]);
+		const parallel = task === "dev" ? ["--parallel"] : [];
+		commands.push({
+			args: [
+				"-r",
+				"--if-present",
+				...parallel,
+				...ownFilters,
+				"run",
+				task,
+				...rest
+			],
+			cwd
+		});
 	}
-	const ownFilters = filters.flatMap((f) => ["--filter", f]);
-	const parallel = task === "dev" ? ["--parallel"] : [];
-	commands.push([
-		"-r",
-		"--if-present",
-		...parallel,
-		...ownFilters,
-		"run",
-		task,
-		...rest
-	]);
 	return passthrough(commands, extraEnv);
 }
 /** A `dev` script that starts `vinext dev` (platform's `with-env vinext dev`). */
@@ -5954,15 +6051,18 @@ function planDev(apps, filters, rest) {
 * The env is the session's: `launch.ts` has already entered the tier into
 * `process.env` (or `--tier` loaded one into `tierEnv`).
 */
-async function runDev(plan, filters, rest, tierEnv) {
-	await runOne([
-		"-r",
-		"--if-present",
-		...(filters.length > 0 ? filters : allAppNames()).flatMap((f) => ["--filter", `${f}^...`]),
-		"run",
-		"build"
-	], tierEnv, { final: false });
-	const { scopedProcessEnv } = await import("./local-env-CR3McKHZ.js");
+async function runDev(plan, filters, rest, tierEnv, root) {
+	await runOne({
+		args: [
+			"-r",
+			"--if-present",
+			...(filters.length > 0 ? filters : allAppNames(root)).flatMap((f) => ["--filter", `${f}^...`]),
+			"run",
+			"build"
+		],
+		cwd: root
+	}, tierEnv, { final: false });
+	const { scopedProcessEnv } = await import("./local-env-MqH18s-N.js");
 	const environment = {
 		...process.env,
 		...tierEnv
@@ -5986,7 +6086,7 @@ async function runDev(plan, filters, rest, tierEnv) {
 	let first;
 	const runs = children.map(async ({ args, env }) => {
 		const result = await runInGroup("pnpm", args, {
-			cwd: findRepoRoot(),
+			cwd: root,
 			env: {
 				...env,
 				DEVDOGS_PICK: "0"
@@ -6004,8 +6104,14 @@ async function runDev(plan, filters, rest, tierEnv) {
 * `runDev`. */
 async function dispatch$1(task, filters, rest, tierEnv) {
 	if (task === "dev") {
-		const plan = planDev(appsWith("dev"), filters, rest);
-		if (plan.vinext.length > 0) return runDev(plan, filters, rest, tierEnv);
+		const groups = groupFiltersByRoot(filters);
+		if (groups.size > 1) {
+			process.stderr.write("devtools run: dev servers from DevDogsUGA and Backstage cannot be started together; start them from their own checkouts.\n");
+			process.exit(1);
+		}
+		const root = [...groups.keys()][0];
+		const plan = planDev(appsWith("dev", root), filters, rest);
+		if (plan.vinext.length > 0) return runDev(plan, filters, rest, tierEnv, root);
 	}
 	return passthroughApps(task, filters, rest, tierEnv);
 }
@@ -6053,21 +6159,15 @@ function parseTierArg(args) {
 * out to a dry-run equivalent, which costs about a second before the first
 * question.
 */
-function appsWith(task) {
-	const dir = join(findRepoRoot(), "apps");
-	if (!existsSync(dir)) return [];
+function appsWith(task, root) {
 	const found = [];
-	for (const entry of readdirSync(dir)) {
-		const manifest = join(dir, entry, "package.json");
-		if (!existsSync(manifest)) continue;
-		try {
-			const pkg = JSON.parse(readFileSync(manifest, "utf8"));
-			const script = pkg.scripts?.[task];
-			if (pkg.name && script) found.push({
-				name: pkg.name,
-				script
-			});
-		} catch {}
+	for (const app of appManifests(root)) {
+		const script = task === void 0 ? "" : app.pkg.scripts?.[task];
+		if (app.pkg.name && (task === void 0 || script)) found.push({
+			name: app.pkg.name,
+			script: script ?? "",
+			root: app.root
+		});
 	}
 	return found;
 }

package/dist/{failure-log-B5GG_8T1.js → failure-log-DOt6E3hS.js}

@@ -1,4 +1,4 @@
-import { a as ownVersion } from "./root-C2OmZDwD.js";
+import { a as ownVersion } from "./root-CjPWNkBu.js";
 import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir, platform, release } from "node:os";

package/dist/launch.js

@@ -1,9 +1,9 @@
-import { a as cliName, t as installFailureLog } from "./failure-log-B5GG_8T1.js";
-import { C as helpPath, S as catalog, _ as bail, g as setMenuEnvHook, h as realEnvEntryDeps, m as enterSessionEnvironment, n as bareGroupStartPath, u as nonEmpty, v as errorMessage, x as unwrap } from "./menu-DXT1ICTI.js";
-import { b as setDryRun, m as formatCommand, v as isDryRun, y as resolveDryRun } from "./supabase-project-Bw8sBFcE.js";
-import { n as discoverRepoRoot, r as findRepoRoot, t as RepoNotFoundError } from "./root-C2OmZDwD.js";
-import { i as loadEnvSession, r as loadEnvLoad } from "./peers-RBplwovA.js";
-import { d as hasYes, f as isNonInteractive, m as stripTierFlag, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as stripNoEnvFlag, s as lastSentryEventId } from "./telemetry-xNMpvX5K.js";
+import { a as cliName, t as installFailureLog } from "./failure-log-DOt6E3hS.js";
+import { C as helpPath, S as catalog, _ as bail, g as setMenuEnvHook, h as realEnvEntryDeps, m as enterSessionEnvironment, n as bareGroupStartPath, u as nonEmpty, v as errorMessage, x as unwrap } from "./menu-DYQ-Dd-O.js";
+import { b as resolveDryRun, h as formatCommand, x as setDryRun, y as isDryRun } from "./supabase-project-C93xRFkN.js";
+import { n as discoverRepoRoot, r as findRepoRoot, t as RepoNotFoundError } from "./root-CjPWNkBu.js";
+import { i as loadEnvSession, r as loadEnvLoad } from "./peers-DvUH5VxX.js";
+import { d as hasYes, f as isNonInteractive, m as stripTierFlag, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as stripNoEnvFlag, s as lastSentryEventId } from "./telemetry-C07-ioHm.js";
 import { confirm, select } from "@clack/prompts";
 //#region ../cli-core/src/session.ts
 /**
@@ -155,7 +155,7 @@ function skipsEnvEntry(rest) {
 /** The offer's stack start (`env-entry.ts` holds the TTY prompt, this holds
 * the lifecycle command), imported lazily like the rest of the commands. */
 async function startStack() {
-	const { runStackCommand } = await import("./stack-B5UHASY2.js");
+	const { runStackCommand } = await import("./stack-o1Kml3V0.js");
 	return runStackCommand("start");
 }
 /**
@@ -166,7 +166,7 @@ async function startStack() {
 * post-tier-resolution path.
 */
 async function dispatch(argv) {
-	const { main } = await import("./cli-BkHyIT5V.js");
+	const { main } = await import("./cli-B_AiECh4.js");
 	try {
 		await main(argv);
 	} catch (err) {

package/dist/{local-env-hH4encfD.js → local-env-BuHU5Ckd.js}

@@ -1,7 +1,7 @@
-import { i as ownPackageDir, r as findRepoRoot } from "./root-C2OmZDwD.js";
-import { a as repoPeerUrl, n as loadEnv, t as getEnvSync } from "./peers-RBplwovA.js";
+import { i as ownPackageDir } from "./root-CjPWNkBu.js";
+import { a as repoPeerUrl, n as loadEnv, o as resolveRepoPeerUrl, p as resolveLayout, t as getEnvSync } from "./peers-DvUH5VxX.js";
 import { register } from "node:module";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 //#region ../cli-core/src/repo/peer-redirect.ts
@@ -23,10 +23,10 @@ import { pathToFileURL } from "node:url";
 * manifest also imports `zod`, which has to keep resolving from devtools'
 * own location, and a copy written anywhere else would lose that.
 */
-/** Registers `redirect`. Hooks cannot be unregistered, so each call adds a
-*  loader for the rest of the process; call it once per redirect. */
-function redirectPeer(redirect) {
-	register("./peer-redirect-hooks.js", import.meta.url, { data: [redirect] });
+/** `redirectPeer` for several at once: the hooks keep one table per
+*  registration, so everything that needs redirecting goes in one call. */
+function redirectPeers(redirects) {
+	register("./peer-redirect-hooks.js", import.meta.url, { data: redirects });
 }
 //#endregion
 //#region ../cli-core/src/repo/tsx-loader.ts
@@ -85,7 +85,11 @@ async function importRepoTs(absolutePath) {
 * filename (`tsconfig.json`, `wrangler.jsonc`, `supadart.yaml`), and a pointer
 * would be the only one of its kind.
 *
-* One special case: `supabase/env.ts` sits at the repo root, OUTSIDE the
+* From a Backstage checkout the scan covers BOTH repos (`repo/layout.ts`):
+* Backstage's `apps/*` and `packages/*`, then DevDogsUGA's through
+* `devdogsuga/`, de-duplicated by directory name with Backstage first.
+*
+* One special case: `supabase/env.ts` sits at DevDogsUGA's root, OUTSIDE the
 * workspace globs. Its variables belong to `config.toml` and the Supabase
 * CLI, not to any package, so it lives next to the config that reads them.
 *
@@ -157,12 +161,17 @@ function assertRegistryLoaded() {
 }
 async function importManifests() {
 	await loadEnv();
+	const redirects = [];
 	const envUrl = repoPeerUrl("@devdogsuga/env");
-	if (envUrl) redirectPeer({
-		parentURL: pathToFileURL(ownManifestPath()).href,
-		specifier: "@devdogsuga/env",
-		url: envUrl
-	});
+	if (envUrl) {
+		redirects.push({
+			parentURL: pathToFileURL(ownManifestPath()).href,
+			specifier: "@devdogsuga/env",
+			url: envUrl
+		});
+		redirects.push(...siblingRedirects(envUrl));
+	}
+	if (redirects.length > 0) redirectPeers(redirects);
 	const previous = process.env.SKIP_ENV_VALIDATION;
 	process.env.SKIP_ENV_VALIDATION = "1";
 	try {
@@ -177,6 +186,36 @@ async function importManifests() {
 	}
 }
 /**
+* From a Backstage checkout, the manifests under `devdogsuga/` import
+* `@devdogsuga/env` through THAT checkout's `node_modules` (or not at all, when
+* it has none): a second copy of the package, and so a second registry that
+* every `declare()` there would populate instead of the one this process
+* reads. Point their imports at the copy `loadEnv()` resolved. Resolved
+* through `realpath`, because the loader sees the module's real location, not
+* the `devdogsuga` symlink.
+*/
+function siblingRedirects(envUrl) {
+	const layout = resolveLayout();
+	if (layout.kind !== "backstage" || !layout.hasDevdogsuga) return [];
+	const nextjs = resolveRepoPeerUrl("@devdogsuga/env/nextjs");
+	const redirects = [];
+	for (const path of manifestPaths()) {
+		if (!path.startsWith(layout.devdogsugaRoot)) continue;
+		const parentURL = pathToFileURL(realpathSync(path)).href;
+		redirects.push({
+			parentURL,
+			specifier: "@devdogsuga/env",
+			url: envUrl
+		});
+		if (nextjs) redirects.push({
+			parentURL,
+			specifier: "@devdogsuga/env/nextjs",
+			url: nextjs
+		});
+	}
+	return redirects;
+}
+/**
 * Every manifest file, in a stable order.
 *
 * The workspace members are enumerated by scanning `apps/*` and `packages/*`
@@ -192,7 +231,8 @@ function manifestPaths() {
 		const manifest = manifestIn(dir);
 		if (manifest) paths.push(manifest);
 	}
-	const supabase = manifestIn(join(findRepoRoot(), "supabase"));
+	const layout = resolveLayout();
+	const supabase = layout.hasDevdogsuga ? manifestIn(join(layout.devdogsugaRoot, "supabase")) : null;
 	if (supabase) paths.push(supabase);
 	paths.push(ownManifestPath());
 	return paths;
@@ -213,20 +253,41 @@ function manifestPaths() {
 function ownManifestPath() {
 	return join(ownPackageDir(), "env.ts");
 }
+/**
+* The CLIs' own packages: each loads its own operator manifest through
+* `ownManifestPath()`, so scanning them from a Backstage checkout would
+* declare the same keys twice.
+*/
+const CLI_PACKAGES = /* @__PURE__ */ new Set(["devtools", "backstage"]);
+/**
+* `apps/*` and `packages/*` of every repo in the layout (the repo you are in
+* first, so it wins a name clash: before the cutover both repos carry
+* `apps/platform` and `packages/email`), then DevDogsUGA's `docs`.
+*/
 function workspaceDirs() {
+	const layout = resolveLayout();
+	const roots = [layout.root];
+	if (layout.kind === "backstage" && layout.hasDevdogsuga) roots.push(layout.devdogsugaRoot);
 	const dirs = [];
-	const repoRoot = findRepoRoot();
 	for (const parent of ["apps", "packages"]) {
-		const names = [];
-		for (const entry of readdirSync(join(repoRoot, parent), { withFileTypes: true })) {
-			if (!entry.isDirectory()) continue;
-			if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-			names.push(entry.name);
+		const found = /* @__PURE__ */ new Map();
+		for (const root of roots) {
+			let entries;
+			try {
+				entries = readdirSync(join(root, parent), { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+				if (layout.kind === "backstage" && parent === "packages" && CLI_PACKAGES.has(entry.name)) continue;
+				if (!found.has(entry.name)) found.set(entry.name, join(root, parent, entry.name));
+			}
 		}
-		names.sort();
-		for (const name of names) dirs.push(join(repoRoot, parent, name));
+		for (const name of [...found.keys()].sort()) dirs.push(found.get(name));
 	}
-	dirs.push(join(repoRoot, "docs"));
+	if (layout.hasDevdogsuga) dirs.push(join(layout.devdogsugaRoot, "docs"));
 	return dirs;
 }
 /** `src/env.ts`, then `env.ts`; both present in one package is a hard error. */

package/dist/local-env-MqH18s-N.js

@@ -0,0 +1,2 @@
+import { t as scopedProcessEnv } from "./local-env-BuHU5Ckd.js";
+export { scopedProcessEnv };

package/dist/{menu-DXT1ICTI.js → menu-DYQ-Dd-O.js}

@@ -1,8 +1,8 @@
-import { c as YES, d as positionals, i as suppressFailureLog, l as createCatalog, o as JSON_FLAG, s as SCOPES } from "./failure-log-B5GG_8T1.js";
-import { a as listContainerNames, i as foreignStackProjectId, n as containerPrefix, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT } from "./supabase-project-Bw8sBFcE.js";
-import { r as findRepoRoot } from "./root-C2OmZDwD.js";
-import { n as loadEnv, r as loadEnvLoad } from "./peers-RBplwovA.js";
-import { c as reportDevtoolsError, f as isNonInteractive } from "./telemetry-xNMpvX5K.js";
+import { c as YES, d as positionals, i as suppressFailureLog, l as createCatalog, o as JSON_FLAG, s as SCOPES } from "./failure-log-DOt6E3hS.js";
+import { a as listContainerNames, i as foreignStackProjectId, n as containerPrefix, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT } from "./supabase-project-C93xRFkN.js";
+import { r as findRepoRoot } from "./root-CjPWNkBu.js";
+import { c as devdogsugaRootOrNull, n as loadEnv, p as resolveLayout, r as loadEnvLoad } from "./peers-DvUH5VxX.js";
+import { c as reportDevtoolsError, f as isNonInteractive } from "./telemetry-C07-ioHm.js";
 import { cancel, confirm, isCancel, log, note, select, text } from "@clack/prompts";
 import { existsSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
@@ -826,7 +826,7 @@ async function ensureGeneratedEnvFile(tier, devDatabase, deps) {
 	if (!await deps.probeLocalStack()) return { outcome: "skipped" };
 	try {
 		const env = await deps.captureStatus();
-		await deps.write(join(deps.repoRoot, GENERATED_FILE), env);
+		for (const dir of [deps.repoRoot, ...deps.mirrorRoots ?? []]) await deps.write(join(dir, GENERATED_FILE), env);
 		return {
 			outcome: "wrote",
 			line: "devtools: wrote .env.generated from the running local stack"
@@ -851,15 +851,18 @@ async function ensureGeneratedEnvFile(tier, devDatabase, deps) {
 * different copies of the same optional peer in play.
 */
 function realEnsureGeneratedEnvDeps(probeLocalStack) {
-	const repoRoot = findRepoRoot();
+	const layout = resolveLayout();
+	const repoRoot = layout.root;
+	const supabaseRoot = devdogsugaRootOrNull(layout);
 	return {
 		probeLocalStack,
-		exists: (file) => existsSync(join(repoRoot, file)),
+		exists: (file) => [repoRoot, ...layout.envMirrors].every((dir) => existsSync(join(dir, file))),
 		captureStatus: () => supabaseCapture("status", "-o", "env"),
 		write: (path, contents) => writeFile(path, contents),
 		listContainerNames: () => listContainerNames(STACK_API_PORT),
-		projectId: () => readProjectId(repoRoot),
-		repoRoot
+		projectId: () => supabaseRoot === null ? null : readProjectId(supabaseRoot),
+		repoRoot,
+		mirrorRoots: layout.envMirrors
 	};
 }
 //#endregion
@@ -1276,7 +1279,8 @@ function probeEnvironment(execute = run) {
 		stack: "unknown",
 		envFile
 	};
-	const prefix = containerPrefix(readProjectId(findRepoRoot()));
+	const supabaseRoot = devdogsugaRootOrNull(resolveLayout());
+	const prefix = containerPrefix(supabaseRoot === null ? null : readProjectId(supabaseRoot));
 	return {
 		docker,
 		stack: names.split("\n").some((name) => name.trim().startsWith(prefix)) ? "yes" : "no",

package/dist/{peers-RBplwovA.js → peers-DvUH5VxX.js}

@@ -1,8 +1,114 @@
-import { r as findRepoRoot, t as RepoNotFoundError } from "./root-C2OmZDwD.js";
+import { r as findRepoRoot, t as RepoNotFoundError } from "./root-CjPWNkBu.js";
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
+/** The directory (relative to a Backstage root) holding the DevDogsUGA checkout. */
+const DEVDOGSUGA_LINK = "devdogsuga";
+var DevdogsugaMissingError = class extends Error {
+	constructor(path) {
+		super(`The DevDogsUGA checkout is missing at ${path}. Run \`pnpm devdogsuga\` (links the sibling clone, or \$DEVDOGSUGA_DIR) or \`pnpm install\` in the Backstage root first.`);
+		this.name = "DevdogsugaMissingError";
+	}
+};
+/** The kind of repo `dir` is the root of, by its `package.json` name; null if neither. */
+function repoKindOf(dir) {
+	try {
+		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		if (pkg.name === "devdogs-monorepo") return "devdogsuga";
+		if (pkg.name === "backstage") return "backstage";
+	} catch {}
+	return null;
+}
+function isDir(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* The layout of the repo rooted at `root`. Pure: nothing is memoized, so tests
+* can build fixtures freely. An unrecognised package name is treated as
+* DevDogsUGA (the contract fixtures and every pre-Backstage caller).
+*/
+function layoutAt(root) {
+	const kind = repoKindOf(root) === "backstage" ? "backstage" : "devdogsuga";
+	const sibling = join(root, DEVDOGSUGA_LINK);
+	const hasDevdogsuga = kind === "devdogsuga" || isDir(sibling);
+	const devdogsugaRoot = kind === "devdogsuga" ? root : sibling;
+	const appsDirs = [join(root, "apps")];
+	if (kind === "backstage" && hasDevdogsuga) appsDirs.push(join(devdogsugaRoot, "apps"));
+	return {
+		kind,
+		root,
+		get devdogsugaRoot() {
+			if (!hasDevdogsuga) throw new DevdogsugaMissingError(sibling);
+			return devdogsugaRoot;
+		},
+		...kind === "backstage" ? { backstageRoot: root } : {},
+		hasDevdogsuga,
+		appsDirs: appsDirs.filter(isDir),
+		envMirrors: kind === "backstage" && hasDevdogsuga ? [devdogsugaRoot] : []
+	};
+}
+/** `layout.devdogsugaRoot`, or null instead of a throw when the checkout is missing. */
+function devdogsugaRootOrNull(layout) {
+	return layout.hasDevdogsuga ? layout.devdogsugaRoot : null;
+}
+let cached;
+let cachedFor;
+/** The layout of the repo the process is in (`findRepoRoot()`), memoized per root. */
+function resolveLayout() {
+	const root = findRepoRoot();
+	if (cached === void 0 || cachedFor !== root) {
+		cached = layoutAt(root);
+		cachedFor = root;
+	}
+	return cached;
+}
+/** Every directory under `appsDirs` (one app each), de-duplicated by name, sorted by name. */
+function listApps(layout = resolveLayout()) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const parent of layout.appsDirs) for (const entry of readdirSync(parent, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+		if (!seen.has(entry.name)) seen.set(entry.name, {
+			name: entry.name,
+			dir: join(parent, entry.name)
+		});
+	}
+	return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** The directory of the app called `name`, or undefined when no repo has it. */
+function findApp(name, layout = resolveLayout()) {
+	return listApps(layout).find((app) => app.name === name)?.dir;
+}
+/**
+* Resolves a workspace-relative path such as `workers.json`'s
+* `apps/schedule-builder` to a directory: the repo you are in first, then
+* DevDogsUGA's. When neither has it the first candidate is returned, so
+* callers get an ordinary ENOENT naming the path rather than a second error.
+*/
+function resolveAppPath(relative, layout = resolveLayout()) {
+	const first = join(layout.root, relative);
+	if (existsSync(first)) return first;
+	if (layout.kind === "backstage" && layout.hasDevdogsuga) {
+		const second = join(layout.devdogsugaRoot, relative);
+		if (existsSync(second)) return second;
+	}
+	return first;
+}
+/**
+* The pnpm workspace root holding the app called `name`: where
+* `pnpm --filter <name>` has to run. DevDogsUGA's root for its apps seen from a
+* Backstage checkout, `layout.root` otherwise.
+*/
+function appWorkspaceRoot(name, layout = resolveLayout()) {
+	const dir = findApp(name, layout);
+	return dir === void 0 ? layout.root : dirname(dirname(dir));
+}
+//#endregion
 //#region ../cli-core/src/repo/resolve.ts
 /**
 * Resolves an `@devdogsuga/*` package FROM the target repo, not from
@@ -199,6 +305,25 @@ function loadPeer(specifier) {
 function repoPeerUrl(specifier) {
 	return resolvedUrls.get(specifier);
 }
+/**
+* Like `repoPeerUrl`, but for any specifier a package of the repo you are in
+* can resolve, subpaths included (`@devdogsuga/env/nextjs`), without having
+* loaded it. Undefined outside a real repo or when nothing depends on it.
+*/
+function resolveRepoPeerUrl(specifier) {
+	const known = resolvedUrls.get(specifier);
+	if (known) return known;
+	if (process.env.DEVTOOLS_TEST_REPO_ROOT) return void 0;
+	try {
+		const repoRoot = findRepoRoot();
+		const base = findDependent(repoRoot, specifier);
+		if (!base) return void 0;
+		const { resolvedPath } = resolveFromRepo(repoRoot, base, specifier);
+		return pathToFileURL(resolvedPath).href;
+	} catch {
+		return;
+	}
+}
 let resolvedEnvModule;
 function loadEnv() {
 	return loadPeer("@devdogsuga/env").then((mod) => {
@@ -226,4 +351,4 @@ function loadEnvSession() {
 	return loadPeer("@devdogsuga/env/session");
 }
 //#endregion
-export { repoPeerUrl as a, loadEnvSession as i, loadEnv as n, loadEnvLoad as r, getEnvSync as t };
+export { repoPeerUrl as a, devdogsugaRootOrNull as c, listApps as d, resolveAppPath as f, loadEnvSession as i, findApp as l, loadEnv as n, resolveRepoPeerUrl as o, resolveLayout as p, loadEnvLoad as r, appWorkspaceRoot as s, getEnvSync as t, layoutAt as u };

package/dist/{root-C2OmZDwD.js → root-CjPWNkBu.js}

@@ -38,13 +38,17 @@ function ownVersion() {
 * marker validated in the `devtools-dlx` prototype
 * (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
 * experiment 1): a directory containing `pnpm-workspace.yaml` AND whose
-* `package.json` has `"name": "devdogs-monorepo"`. The name check is not
-* redundant — a bare `pnpm-workspace.yaml` also matches a Backstage
-* checkout (a separate pnpm workspace), which devtools should refuse
-* rather than silently "find".
+* `package.json` has `"name": "devdogs-monorepo"` (DevDogsUGA) or
+* `"backstage"` (Backstage, which the CLIs also run from; `layout.ts` says
+* what differs). The name check is not redundant — a bare
+* `pnpm-workspace.yaml` matches any pnpm workspace, which devtools should
+* refuse rather than silently "find".
 */
-/** The `package.json` name every real DevDogsUGA checkout carries at its root. */
-const REPO_MARKER_NAME = "devdogs-monorepo";
+/**
+* The `package.json` names a repo root may carry: DevDogsUGA's, and Backstage's
+* (the CLIs run from both; see `layout.ts`).
+*/
+const REPO_MARKER_NAMES = ["devdogs-monorepo", "backstage"];
 var RepoNotFoundError = class extends Error {
 	constructor() {
 		super("run this from inside a DevDogsUGA clone");
@@ -54,7 +58,8 @@ var RepoNotFoundError = class extends Error {
 function looksLikeRepoRoot(dir) {
 	if (!existsSync(join(dir, "pnpm-workspace.yaml"))) return false;
 	try {
-		return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name === REPO_MARKER_NAME;
+		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		return REPO_MARKER_NAMES.includes(pkg.name);
 	} catch {
 		return false;
 	}

package/dist/{stack-7PuRcaI2.js → stack-C_50FafG.js}

@@ -1,6 +1,5 @@
-import { a as listContainerNames, d as seedBuckets, f as supabase, i as foreignStackProjectId, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT, v as isDryRun } from "./supabase-project-Bw8sBFcE.js";
-import { r as findRepoRoot } from "./root-C2OmZDwD.js";
-import { i as loadEnvSession, r as loadEnvLoad } from "./peers-RBplwovA.js";
+import { a as listContainerNames, d as seedBuckets, f as supabase, i as foreignStackProjectId, o as readProjectId, p as supabaseCapture, r as foreignStackMessage, t as STACK_API_PORT, y as isDryRun } from "./supabase-project-C93xRFkN.js";
+import { i as loadEnvSession, p as resolveLayout, r as loadEnvLoad } from "./peers-DvUH5VxX.js";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 //#region src/db/session-refresh.ts
@@ -52,7 +51,7 @@ async function refreshSessionEnv(opts = {}) {
 function foreignStackHint() {
 	const names = listContainerNames(STACK_API_PORT);
 	if (names === null) return void 0;
-	const foreign = foreignStackProjectId(names, readProjectId(findRepoRoot()));
+	const foreign = foreignStackProjectId(names, readProjectId(resolveLayout().devdogsugaRoot));
 	return foreign === null ? void 0 : foreignStackMessage(foreign);
 }
 /**
@@ -101,7 +100,8 @@ async function startLocalStack() {
 			wroteEnvFile: false
 		};
 	}
-	await writeFile(join(findRepoRoot(), ".env.generated"), env);
+	const layout = resolveLayout();
+	for (const dir of [layout.root, ...layout.envMirrors]) await writeFile(join(dir, ".env.generated"), env);
 	return {
 		code: await seedBuckets({ kind: "local" }),
 		wroteEnvFile: true

package/dist/stack-o1Kml3V0.js

@@ -0,0 +1,2 @@
+import { t as runStackCommand } from "./stack-C_50FafG.js";
+export { runStackCommand };

package/dist/{supabase-project-Bw8sBFcE.js → supabase-project-C93xRFkN.js}

@@ -1,5 +1,6 @@
-import { a as cliName, r as noteRan } from "./failure-log-B5GG_8T1.js";
-import { r as findRepoRoot } from "./root-C2OmZDwD.js";
+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";
@@ -190,20 +191,27 @@ function reportRan(command, args, result) {
 //#endregion
 //#region ../cli-core/src/db/run.ts
 /**
-* Shared helpers for running supabase CLI and pnpm commands from the repo root.
+* 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`. The cwd is always
-* findRepoRoot(), where `supabase/config.toml` lives.
+* 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) {
+async function run(args, env, cwd = findRepoRoot()) {
 	const result = await runInGroup("pnpm", args, {
-		cwd: findRepoRoot(),
+		cwd,
 		...env ? { env } : {}
 	});
 	if (reporting) reportRan("pnpm", args, result);
@@ -221,7 +229,7 @@ function reportRuns(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) {
+function runWithStderr(args, env, cwd = findRepoRoot()) {
 	return new Promise((resolve) => {
 		const child = spawn("pnpm", args, {
 			stdio: [
@@ -229,7 +237,7 @@ function runWithStderr(args, env) {
 				"inherit",
 				"pipe"
 			],
-			cwd: findRepoRoot(),
+			cwd,
 			...env ? { env } : {}
 		});
 		let stderr = "";
@@ -254,9 +262,9 @@ function runWithStderr(args, env) {
 	});
 }
 /** Spawn a pnpm command, capture stdout, throw on non-zero exit. */
-async function capture(args) {
+async function capture(args, cwd = findRepoRoot()) {
 	const { stdout } = await runFile("pnpm", args, {
-		cwd: findRepoRoot(),
+		cwd,
 		encoding: "utf8"
 	});
 	return stdout;
@@ -266,13 +274,13 @@ 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.
 *
@@ -425,4 +433,4 @@ 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 { dryRunKind as _, listContainerNames as a, setDryRun as b, reportRuns as c, seedBuckets as d, supabase as f, runInGroup as g, reportRan as h, foreignStackProjectId as i, run as l, formatCommand 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, isDryRun as v, wouldRunLine as x, resolveDryRun as y };
+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 };

package/dist/{telemetry-xNMpvX5K.js → telemetry-C07-ioHm.js}

@@ -1,5 +1,5 @@
-import { a as cliName, n as noteError } from "./failure-log-B5GG_8T1.js";
-import { a as ownVersion, n as discoverRepoRoot } from "./root-C2OmZDwD.js";
+import { a as cliName, n as noteError } from "./failure-log-DOt6E3hS.js";
+import { a as ownVersion, n as discoverRepoRoot } from "./root-CjPWNkBu.js";
 import { readFileSync } from "node:fs";
 import * as Sentry from "@sentry/node";
 import "@sentry/core";

package/dist/telemetry.js

@@ -1,2 +1,2 @@
-import { a as hasRealCaller, c as reportDevtoolsError, i as devtoolsTelemetryEnabled, l as reportDevtoolsFailure, n as captureDevtoolsError, o as initDevtoolsTelemetry, r as devtoolsEnvironment, s as lastSentryEventId, t as captureDevtoolsDeprecation, u as resolveDevtoolsDsn } from "./telemetry-xNMpvX5K.js";
+import { a as hasRealCaller, c as reportDevtoolsError, i as devtoolsTelemetryEnabled, l as reportDevtoolsFailure, n as captureDevtoolsError, o as initDevtoolsTelemetry, r as devtoolsEnvironment, s as lastSentryEventId, t as captureDevtoolsDeprecation, u as resolveDevtoolsDsn } from "./telemetry-C07-ioHm.js";
 export { captureDevtoolsDeprecation, captureDevtoolsError, devtoolsEnvironment, devtoolsTelemetryEnabled, hasRealCaller, initDevtoolsTelemetry, lastSentryEventId, reportDevtoolsError, reportDevtoolsFailure, resolveDevtoolsDsn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devdogsuga/devtools",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "private": false,
   "type": "module",
   "description": "Contributor CLI for a DevDogsUGA checkout: the real tools with the session's tier filled in, a menu over them, and the checks CI runs. Ships built JS; run via `pnpm dlx @devdogsuga/devtools` (or the `devtools` bin once installed) from inside a DevDogsUGA clone.",
@@ -51,10 +51,10 @@
     "eslint": "^9.39.5",
     "tsdown": "^0.23.0",
     "vitest": "^4.1.11",
-    "@devdogsuga/cli-core": "0.0.0",
-    "@devdogsuga/env": "0.1.6",
-    "@devdogsuga/db": "0.1.4",
     "@devdogsuga/config": "0.1.3",
+    "@devdogsuga/cli-core": "0.0.0",
+    "@devdogsuga/db": "0.1.5",
+    "@devdogsuga/env": "0.1.8",
     "@devdogsuga/telemetry": "0.1.5"
   },
   "scripts": {

package/dist/local-env-CR3McKHZ.js

@@ -1,2 +0,0 @@
-import { t as scopedProcessEnv } from "./local-env-hH4encfD.js";
-export { scopedProcessEnv };

package/dist/stack-B5UHASY2.js

@@ -1,2 +0,0 @@
-import { t as runStackCommand } from "./stack-7PuRcaI2.js";
-export { runStackCommand };