@devdogsuga/backstage 0.1.3 → 0.1.4

package/dist/connection-D3XsOE3S.js

@@ -0,0 +1,7 @@
+//#region ../cli-core/src/db/connection.ts
+/** An env value, with unset and empty both meaning "not given". */
+function nonEmpty(value) {
+	return value === void 0 || value === "" ? void 0 : value;
+}
+//#endregion
+export { nonEmpty as t };

package/dist/launch.js

@@ -1,5 +1,7 @@
 import { C as discoverRepoRoot, E as setCliName, S as RepoNotFoundError, T as cliName, _ as installFailureLog, d as hasYes, g as stripTierFlag, h as stripNoEnvFlag, m as setNoEnv, n as captureDevtoolsError, o as initDevtoolsTelemetry, p as isNonInteractive, s as lastSentryEventId } from "./telemetry-Bjoz29Hl.js";
-import { c as setMenuEnvHook, d as formatCommand, f as nonEmpty, g as loadEnvSession, h as loadEnvLoad, n as bareGroupStartPath, t as catalog, v as helpPath } from "./catalog-BOBE4ee7.js";
+import { c as setMenuEnvHook, d as formatCommand, f as helpPath, n as bareGroupStartPath, t as catalog } from "./catalog-BuNLUu08.js";
+import { i as loadEnvSession, r as loadEnvLoad } from "./peers-B0KDkI6a.js";
+import { t as nonEmpty } from "./connection-D3XsOE3S.js";
 import { c as setDryRun, o as isDryRun, s as resolveDryRun } from "./options-BTjOf5KP.js";
 import { o as unwrap, r as errorMessage } from "./ui-CdKo8mLw.js";
 import { confirm } from "@clack/prompts";
@@ -320,7 +322,7 @@ async function launchWith(argv, options) {
 */
 async function launch(argv) {
 	await launchWith(argv, { dispatch: async (args) => {
-		const { main } = await import("./cli-ZF4QgJro.js");
+		const { main } = await import("./cli-BI5Vn9sR.js");
 		await main(args);
 	} });
 }

package/dist/peers-B0KDkI6a.js

@@ -0,0 +1,229 @@
+import { S as RepoNotFoundError, w as findRepoRoot } from "./telemetry-Bjoz29Hl.js";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#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 };