@devdogsuga/devtools 0.1.26 → 0.1.28

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 };

package/dist/peers-RBplwovA.js

@@ -0,0 +1,229 @@
+import { r as findRepoRoot, t as RepoNotFoundError } from "./root-C2OmZDwD.js";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region ../cli-core/src/repo/resolve.ts
+/**
+* Resolves an `@devdogsuga/*` package FROM the target repo, not from
+* devtools' own (dlx-isolated) `node_modules`.
+*
+* Ported from the `devtools-dlx` prototype
+* (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
+* experiments 2 and 4 — read that file for the two gotchas this module
+* exists to avoid). The short version:
+*
+*   - `require.resolve(\`${specifier}/package.json\`)` throws
+*     `ERR_PACKAGE_PATH_NOT_EXPORTED` on packages (like `@devdogsuga/env`,
+*     `@devdogsuga/open-graph`) whose `exports` map does not list
+*     `"./package.json"`, even though the file is on disk.
+*   - A resolved path cannot be assumed to contain a literal
+*     `node_modules/<specifier>` segment — pnpm workspace-linked packages
+*     resolve to their REALPATH (e.g. `packages/open-graph/dist/index.js`),
+*     which has no such segment at all.
+*   - `require.resolve` ignores whatever `conditions` a caller has set on
+*     `tsx`'s `register()` — condition-based resolution (the
+*     `devdogs-source` condition) has to be done by hand, reading the
+*     target package's own `exports["."]` map.
+*
+* Both problems are solved the same way: walk up from the resolved file's
+* directory to the nearest `package.json` whose own `"name"` field matches
+* the specifier. That works for a real installed dependency AND a
+* workspace symlink, uniformly.
+*/
+/**
+* The installable package name a (possibly subpath) specifier belongs to:
+* `@devdogsuga/env/load` → `@devdogsuga/env`, `foo/bar` → `foo`. A repo's
+* package.json declares the PACKAGE as a dependency, never a subpath, so
+* `findDependent` has to search on this rather than the literal specifier a
+* caller wants to import.
+*/
+function packageNameOf(specifier) {
+	const parts = specifier.split("/");
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+/**
+* Scans `apps/*` and `packages/*` under `repoRoot` for the first
+* `package.json` whose `dependencies`/`devDependencies`/`peerDependencies`
+* names `specifier`'s package (see `packageNameOf`). Returns its path
+* relative to `repoRoot`, or `null` if nothing in the repo depends on it.
+*
+* Re-scans the filesystem on every call — fine for a short-lived CLI
+* invocation calling this a handful of times; see FINDINGS item 5 if this
+* is ever called in a hot loop.
+*/
+function findDependent(repoRoot, specifier) {
+	const packageName = packageNameOf(specifier);
+	for (const group of ["apps", "packages"]) {
+		const groupDir = join(repoRoot, group);
+		let entries;
+		try {
+			entries = readdirSync(groupDir);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const pkgJsonPath = join(groupDir, entry, "package.json");
+			if (!existsSync(pkgJsonPath)) continue;
+			let pkg;
+			try {
+				pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+			} catch {
+				continue;
+			}
+			if (packageName in {
+				...pkg.dependencies,
+				...pkg.devDependencies,
+				...pkg.peerDependencies
+			}) return join(group, entry, "package.json");
+		}
+	}
+	return null;
+}
+/** Walks up from `startDir` to the nearest `package.json` whose `"name"` matches `specifier`. */
+function findOwningPackageJson(startDir, specifier) {
+	const packageName = packageNameOf(specifier);
+	let dir = startDir;
+	for (;;) {
+		const candidate = join(dir, "package.json");
+		if (existsSync(candidate)) try {
+			if (JSON.parse(readFileSync(candidate, "utf8")).name === packageName) return candidate;
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) throw new Error(`resolveFromRepo: could not find ${specifier}'s own package.json by walking up from ${startDir}`);
+		dir = parent;
+	}
+}
+/**
+* Resolves `specifier` as `resolutionBase` (a workspace-relative
+* `package.json` path known to depend on it, from `findDependent()`) would
+* see it.
+*
+* `opts.condition`, when given, is NOT passed through to Node's resolver —
+* `require.resolve` ignores tsx's `register({ conditions })` entirely (see
+* this module's header). Instead the target package's own
+* `exports["."]` map is read directly and `exports["."][condition]` is
+* picked, falling back to `.default`.
+*/
+function resolveFromRepo(repoRoot, resolutionBase, specifier, opts) {
+	const baseFile = join(repoRoot, resolutionBase);
+	const require = createRequire(baseFile);
+	let resolvedPath;
+	if (opts?.condition) {
+		const defaultEntry = require.resolve(specifier);
+		const pkgJsonPath = findOwningPackageJson(dirname(defaultEntry), specifier);
+		const rootExport = JSON.parse(readFileSync(pkgJsonPath, "utf8")).exports?.["."];
+		const conditioned = rootExport && typeof rootExport === "object" ? rootExport[opts.condition] ?? rootExport.default : void 0;
+		if (typeof conditioned !== "string") throw new Error(`resolveFromRepo: ${specifier} has no "${opts.condition}" (or "default") export in its exports["."] map`);
+		resolvedPath = join(dirname(pkgJsonPath), conditioned);
+	} else resolvedPath = require.resolve(specifier);
+	const pkgJsonPath = findOwningPackageJson(dirname(resolvedPath), specifier);
+	const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+	return {
+		resolvedPath,
+		version: pkg.version ?? "0.0.0",
+		pkgJsonPath
+	};
+}
+//#endregion
+//#region ../cli-core/src/repo/peers.ts
+/**
+* Loads devtools' optional-peer `@devdogsuga/*` libraries — the ones
+* published to npm and consumed by the TARGET repo, which devtools reads at
+* runtime rather than bundling its own copy of (see this package's
+* `package.json`: `peerDependencies` + `peerDependenciesMeta.optional`, and
+* `FINDINGS.md` experiment 2).
+*
+* Every export here is memoized per module (one dynamic `import()` per
+* process, not per call) — this is what makes the module-identity guarantee
+* in FINDINGS experiment 3 hold: every devtools call site that needs
+* `@devdogsuga/env`'s registry gets the exact same module instance the
+* repo's own manifests populated via `declare()`/`define()`, because both
+* resolve to the identical absolute file path and Node's ESM cache is keyed
+* by resolved URL.
+*/
+const moduleCache = /* @__PURE__ */ new Map();
+/** The file URL each peer resolved to through the target repo, set only on
+*  that path (not on either plain bare-specifier fallback). See
+*  `repoPeerUrl()`. */
+const resolvedUrls = /* @__PURE__ */ new Map();
+/**
+* Dynamically imports `specifier` as the repo would resolve it, memoized so
+* repeated calls in one process return the SAME module instance (required
+* for the env-registry identity guarantee above).
+*
+* Falls back to a plain bare-specifier `import()` when devtools is not
+* running inside a DevDogsUGA checkout at all (`findRepoRoot()` throws
+* `RepoNotFoundError`). That is not a production affordance — under real
+* `pnpm dlx` use, `specifier` is an optional peer devtools' own package
+* never installs, so the fallback import fails with the ordinary
+* `MODULE_NOT_FOUND` either way. It exists so devtools' OWN test suite
+* (which has no target repo to discover, but does have every one of these
+* peers as a real Backstage workspace package) exercises this code against
+* the genuine package rather than needing every test to mock this module.
+*/
+function loadPeer(specifier) {
+	const cached = moduleCache.get(specifier);
+	if (cached) return cached;
+	const promise = (async () => {
+		if (process.env.DEVTOOLS_TEST_REPO_ROOT) return import(specifier);
+		let repoRoot;
+		try {
+			repoRoot = findRepoRoot();
+		} catch (err) {
+			if (err instanceof RepoNotFoundError) return import(specifier);
+			throw err;
+		}
+		const resolutionBase = findDependent(repoRoot, specifier);
+		if (!resolutionBase) throw new Error(`Nothing in this repo depends on ${specifier} — expected an app or package under apps/* or packages/* to declare it (dependencies/devDependencies/peerDependencies).`);
+		const { resolvedPath } = resolveFromRepo(repoRoot, resolutionBase, specifier);
+		const url = pathToFileURL(resolvedPath).href;
+		resolvedUrls.set(specifier, url);
+		return import(url);
+	})();
+	moduleCache.set(specifier, promise);
+	return promise;
+}
+/**
+* The file URL `specifier` was loaded from through the target repo, or
+* undefined if it has not been loaded yet or came from a plain bare-specifier
+* `import()` (the test-suite and not-in-a-repo fallbacks above).
+*
+* For code devtools imports that itself names a peer by bare specifier --
+* today only devtools' own `env.ts` manifest. From an installed copy that
+* specifier cannot resolve at all (an optional peer is never installed next
+* to devtools under `pnpm dlx`), and even where it can, the only copy that
+* keeps module identity is this one. `repo/peer-redirect.ts` uses it to
+* point the import here.
+*/
+function repoPeerUrl(specifier) {
+	return resolvedUrls.get(specifier);
+}
+let resolvedEnvModule;
+function loadEnv() {
+	return loadPeer("@devdogsuga/env").then((mod) => {
+		resolvedEnvModule = mod;
+		return mod;
+	});
+}
+/**
+* The synchronous companion to `loadEnv()`, for the handful of call sites
+* (`gh/environments.ts`'s `GITHUB_ENVIRONMENT_SPECS` getters) that cannot
+* become async without changing their own callers' contract — they read a
+* plain array off a getter, not a Promise. Safe ONLY after `loadEnv()` has
+* resolved at least once; every caller of these getters already requires
+* `env/discovery.ts`'s `loadRegistry()` (which calls `loadEnv()` itself) to
+* have run first, via `assertRegistryLoaded()`'s own guard.
+*/
+function getEnvSync() {
+	if (!resolvedEnvModule) throw new Error("getEnvSync() called before loadEnv() ever resolved — call loadRegistry() (env/discovery.ts) first.");
+	return resolvedEnvModule;
+}
+function loadEnvLoad() {
+	return loadPeer("@devdogsuga/env/load");
+}
+function loadEnvSession() {
+	return loadPeer("@devdogsuga/env/session");
+}
+//#endregion
+export { repoPeerUrl as a, loadEnvSession as i, loadEnv as n, loadEnvLoad as r, getEnvSync as t };

package/dist/root-C2OmZDwD.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region ../cli-core/src/version.ts
+let cachedOwnDir;
+/** The published package's own root: the nearest directory above this
+* module's file that holds a `package.json`. A bundled CLI runs from a flat
+* `dist/`, so that is the CLI's root (`dist/launch.js` -> up one); the core
+* is inlined into it, so its own source location never matters at run time.
+* Memoized since it never changes within a process. */
+function ownPackageDir() {
+	if (cachedOwnDir !== void 0) return cachedOwnDir;
+	let dir = dirname(fileURLToPath(import.meta.url));
+	while (!existsSync(join(dir, "package.json")) && dirname(dir) !== dir) dir = dirname(dir);
+	cachedOwnDir = dir;
+	return dir;
+}
+/** Reads this build's own `package.json` version — used by `telemetry.ts`
+* (release tagging) and the CLI's `version` command. */
+function ownVersion() {
+	const pkg = JSON.parse(readFileSync(join(ownPackageDir(), "package.json"), "utf8"));
+	return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+}
+//#endregion
+//#region ../cli-core/src/repo/root.ts
+/**
+* Where devtools finds the DevDogsUGA checkout it is running against.
+*
+* devtools used to live inside `packages/devtools` of that repo, so its own
+* `import.meta.url` WAS a path into the repo (`PROJECT_ROOT` /
+* `REPO_ROOT` walked up a fixed number of `..` segments from this file).
+* Published as its own package and run through `pnpm dlx`, that assumption
+* breaks: this file's `import.meta.url` points into a dlx cache directory
+* or an isolated `node_modules` tree that has nothing to do with the repo
+* the contributor is standing in.
+*
+* So repo discovery walks up from `process.cwd()` instead, looking for the
+* 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".
+*/
+/** The `package.json` name every real DevDogsUGA checkout carries at its root. */
+const REPO_MARKER_NAME = "devdogs-monorepo";
+var RepoNotFoundError = class extends Error {
+	constructor() {
+		super("run this from inside a DevDogsUGA clone");
+		this.name = "RepoNotFoundError";
+	}
+};
+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;
+	} catch {
+		return false;
+	}
+}
+/**
+* Walks up from `startDir` (default `process.cwd()`) looking for the repo
+* marker. Returns `null` rather than throwing — `findRepoRoot()` below is
+* the throwing convenience most callers want; this is exported for callers
+* (like `setup`) that need to know without failing.
+*/
+function discoverRepoRoot(startDir = process.cwd()) {
+	let dir = startDir;
+	for (;;) {
+		if (looksLikeRepoRoot(dir)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+let cachedRoot;
+/**
+* The memoized, throwing repo-root lookup. Lazy on purpose: importing this
+* module must never fail just because nothing has called it yet (`setup`
+* and `completions` in `launch.ts` never need a repo at all, and must stay
+* that way — see that file's header comment on why).
+*
+* Resolved once per process: `process.cwd()` does not change mid-invocation
+* for this CLI, and re-walking the filesystem on every call would be pure
+* waste.
+*/
+function findRepoRoot() {
+	if (cachedRoot === void 0) cachedRoot = process.env.DEVTOOLS_TEST_REPO_ROOT ?? discoverRepoRoot();
+	if (cachedRoot === null) throw new RepoNotFoundError();
+	return cachedRoot;
+}
+//#endregion
+export { ownVersion as a, ownPackageDir as i, discoverRepoRoot as n, findRepoRoot as r, RepoNotFoundError as t };

package/dist/stack-Bx-55oi_.js

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

package/dist/stack-BynCgRVS.js

@@ -0,0 +1,181 @@
+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-0knM0mqd.js";
+import { r as findRepoRoot } from "./root-C2OmZDwD.js";
+import { i as loadEnvSession, r as loadEnvLoad } from "./peers-RBplwovA.js";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/db/session-refresh.ts
+/**
+* Re-enters development — refreshing `process.env` from `.env.generated`'s
+* latest state — when (and only when) this process is already running under
+* development. Returns the one-line note callers report on success, or an
+* empty array when the guard held and nothing needed refreshing.
+*/
+async function refreshSessionEnv(opts = {}) {
+	const deployEnv = opts.deployEnv ?? process.env.DEPLOY_ENV;
+	if (deployEnv !== void 0 && deployEnv !== "" && deployEnv !== "development") return [];
+	const envLoad = await loadEnvLoad();
+	const enter = opts.enterEnvironment ?? (await loadEnvSession()).enterEnvironment;
+	try {
+		await enter("development", { override: true });
+	} catch (err) {
+		if (!(err instanceof envLoad.LocalStackOfflineError)) throw err;
+		const devDb = process.env[envLoad.DEV_DB_ENV];
+		delete process.env[envLoad.DEV_DB_ENV];
+		try {
+			await enter("development", { override: true });
+		} finally {
+			if (devDb !== void 0) process.env[envLoad.DEV_DB_ENV] = devDb;
+		}
+	}
+	return [`refreshed ${envLoad.GENERATED_FILE}`];
+}
+//#endregion
+//#region src/db/stack.ts
+/**
+* The local Supabase stack's lifecycle: `start`, `stop` and the `restart`
+* preset.
+*
+* `start` writes `.env.generated` and seeds the storage buckets, which is what
+* the deprecated `db start` alias on DevDogsUGA's main relies on until the
+* cutover; `with-env` takes the file over after it. `stop` leaves the file
+* alone: `with-env` already ignores it while the stack is down.
+*/
+/**
+* A running Docker container whose name says it belongs to a DIFFERENT
+* Supabase project than this checkout's own `config.toml` — the signature
+* of a foreign stack holding the shared ports (see
+* `repo/supabase-project.ts`'s header). `undefined` when nothing points
+* that way, including when Docker or `config.toml` could not be read at
+* all: with no signal either way, `startLocalStack`'s own failure and the
+* Supabase CLI's own output are still the reader's best explanation.
+*/
+function foreignStackHint() {
+	const names = listContainerNames(STACK_API_PORT);
+	if (names === null) return void 0;
+	const foreign = foreignStackProjectId(names, readProjectId(findRepoRoot()));
+	return foreign === null ? void 0 : foreignStackMessage(foreign);
+}
+/**
+* `wroteEnvFile` is split out from `code` on purpose: `.env.generated` is
+* written to disk BEFORE `seedBuckets` runs, so a nonzero `code` from
+* `seedBuckets` alone does not mean the file on disk is unchanged — the
+* fresh connection block is already there, a later `db start` retry or the
+* probe table would already see it, and this process's OWN entered
+* environment is now the stale one. `afterLocalStackChange` below refreshes
+* whenever the file changed, independently of whether the command as a whole
+* succeeded, and still reports the failing code so the caller does not
+* mistake a seed failure for success.
+*
+* `hint` is set when `supabase start` itself fails (before anything here
+* could have written `.env.generated`) AND a foreign project's stack is
+* holding the ports — the same signal `db/generated-env.ts` surfaces for a
+* failed `supabase status -o env`, named here too so `db start` explains
+* itself instead of leaving only the bare Supabase CLI error.
+*/
+async function startLocalStack() {
+	const code = await supabase("start");
+	if (isDryRun()) {
+		process.stderr.write("Would write .env.generated from the running stack\n");
+		return {
+			code: 0,
+			wroteEnvFile: false
+		};
+	}
+	if (code !== 0) {
+		const hint = foreignStackHint();
+		return hint === void 0 ? {
+			code,
+			wroteEnvFile: false
+		} : {
+			code,
+			wroteEnvFile: false,
+			hint
+		};
+	}
+	let env;
+	try {
+		env = await supabaseCapture("status", "-o", "env");
+	} catch {
+		return {
+			code: 1,
+			wroteEnvFile: false
+		};
+	}
+	await writeFile(join(findRepoRoot(), ".env.generated"), env);
+	return {
+		code: await seedBuckets({ kind: "local" }),
+		wroteEnvFile: true
+	};
+}
+async function stopLocalStack() {
+	return supabase("stop");
+}
+/**
+* BUG 2's fix, applied at every point `start`/`stop`/`restart` can change
+* `.env.generated`: on success, refresh this process's entered environment
+* (see `db/session-refresh.ts`) so the rest of the session — including a
+* `db introspect` run right after this one — sees the stack's CURRENT
+* connection, not whatever `process.env` held at launch. A failed stack
+* command USUALLY changed nothing on disk, so by default there is nothing to
+* refresh.
+*
+* `wroteEnvFile` is the one exception: `startLocalStack` writes
+* `.env.generated` BEFORE the buckets-seed step that can still fail
+* afterwards, so a nonzero `code` from THAT failure does not mean the file on
+* disk is unchanged — see `startLocalStack`'s own doc. Passing `true` here
+* refreshes regardless of `code`, while the failing code itself still reaches
+* the caller untouched, so `db start` is still reported as failed even though
+* the session's environment was brought current.
+*/
+async function afterLocalStackChange(code, wroteEnvFile = false) {
+	if (isDryRun() || code !== 0 && !wroteEnvFile) return [];
+	return refreshSessionEnv();
+}
+/**
+* Stop, then start again.
+*
+* Two steps rather than one, because `supabase restart` does not exist. The
+* CLI's own answer to a changed `config.toml` is a stop/start pair. Doing it
+* here turns that into one menu entry, rather than two commands the contributor
+* has to know to run in that order.
+*
+* A failed stop short-circuits. Starting a stack that never went down would
+* report success and leave the config change unapplied, which is the one
+* outcome worse than a visible failure.
+*/
+async function restartLocal() {
+	const stopCode = await stopLocalStack();
+	if (stopCode !== 0) return {
+		code: stopCode,
+		lines: ["Stopping failed, so nothing was restarted. Scroll up for the output from the Supabase CLI."]
+	};
+	const { code, wroteEnvFile, hint } = await startLocalStack();
+	const lines = await afterLocalStackChange(code, wroteEnvFile);
+	return {
+		code,
+		lines: hint === void 0 ? lines : [hint, ...lines]
+	};
+}
+/**
+* Runs a stack lifecycle command, returning its exit code and anything to
+* report. The lifecycle commands act on this machine's containers and so need
+* no resolvable database (that is what `start` is FOR).
+*/
+async function runStackCommand(command) {
+	if (command === "restart") return restartLocal();
+	if (command === "stop") {
+		const code = await stopLocalStack();
+		return {
+			code,
+			lines: await afterLocalStackChange(code)
+		};
+	}
+	const { code, wroteEnvFile, hint } = await startLocalStack();
+	const lines = await afterLocalStackChange(code, wroteEnvFile);
+	return {
+		code,
+		lines: hint === void 0 ? lines : [hint, ...lines]
+	};
+}
+//#endregion
+export { runStackCommand as t };