@devdogsuga/devtools 0.1.50 → 0.1.51-next.526

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

@@ -1,8 +1,6 @@
-import { a as cliName, n as noteError } from "./failure-log-DOt6E3hS.js";
-import { a as ownVersion, n as discoverRepoRoot } from "./root-CjPWNkBu.js";
+import { a as noteError, l as ownVersion, n as discoverRepoRoot, u as cliName } from "./root-CsocfxnK.js";
 import { readFileSync } from "node:fs";
 import * as Sentry from "@sentry/node";
-import "@sentry/core";
 //#region ../cli-core/src/mode.ts
 /**
 * Non-interactive mode: the one definition both published CLIs share.
@@ -75,7 +73,7 @@ function stripTierFlag(argv) {
 	};
 }
 //#endregion
-//#region ../telemetry/dist/constants.js
+//#region ../sdk/dist/telemetry/constants.js
 /**
 * `tracesSampleRate` by environment. Every environment not listed samples at
 * 0 — that is the "else 0" branch, not an omission, and covers `development`,
@@ -100,7 +98,7 @@ const TAG_KEYS = {
 	ALERT: "alert"
 };
 //#endregion
-//#region ../telemetry/dist/scrub.js
+//#region ../sdk/dist/telemetry/scrub.js
 /**
 * Pure scrubbing functions plus the `beforeSend` that composes them.
 *
@@ -124,6 +122,7 @@ const BEARER_TOKEN = /\b[Bb]earer\s+[A-Za-z0-9._-]+/g;
 function scrubSecrets(text) {
 	return text.replace(ENV_ASSIGNMENT, "$1=[redacted]").replace(BEARER_TOKEN, "Bearer [redacted]");
 }
+WINDOWS_PATH.source, WINDOWS_PATH.flags, POSIX_PATH.source, POSIX_PATH.flags, EMAIL.source, EMAIL.flags, ENV_ASSIGNMENT.source, ENV_ASSIGNMENT.flags, BEARER_TOKEN.source, BEARER_TOKEN.flags;
 /** Runs all three text scrubbers, in order. */
 function scrubText(text) {
 	return scrubSecrets(scrubEmails(scrubPaths(text)));
@@ -165,7 +164,7 @@ function scrubEvent(event, _hint) {
 	};
 }
 //#endregion
-//#region ../telemetry/dist/options.js
+//#region ../sdk/dist/telemetry/options.js
 /**
 * Chains `beforeSend`-shaped functions left to right, short-circuiting the
 * moment one drops the event. Used to compose the shared scrubbers with a
@@ -214,7 +213,7 @@ function buildSentryOptions({ service, environment, dsn, release, extraBeforeSen
 //#region ../cli-core/src/telemetry.ts
 /**
 * devtools' own Sentry wiring — the CLI is a consumer of
-* `@devdogsuga/telemetry` like `apps/platform` and `apps/schedule-builder`,
+* `@devdogsuga/sdk/telemetry` like `apps/platform` and `apps/schedule-builder`,
 * but on `@sentry/node` rather than a framework SDK: a CLI
 * process starts, runs one command, and exits, with none of a server's
 * request lifecycle for a framework integration to hook into.
@@ -222,7 +221,7 @@ function buildSentryOptions({ service, environment, dsn, release, extraBeforeSen
 * ## Reporting is on by default
 *
 * Every other `*_SENTRY_DSN` in this org is optional-and-empty until
-* configured (see `@devdogsuga/telemetry`'s no-op-without-DSN contract), and
+* configured (see `@devdogsuga/sdk/telemetry`'s no-op-without-DSN contract), and
 * so is this one — empty means `buildSentryOptions` returns `undefined` and
 * `Sentry.init` never runs — but the DEFAULT here is reporting ON once a DSN
 * exists, unlike a feature a contributor opts into. `DEVTOOLS_TELEMETRY=0` is
@@ -273,7 +272,7 @@ function sent(id) {
 * `'ci'` whenever the run is non-interactive (no TTY, or `CI=true`, which the
 * runner sets itself before any workflow-authored env), `'local'` on a
 * contributor's terminal.
-* One of `@devdogsuga/telemetry`'s `ENVIRONMENTS`.
+* One of `@devdogsuga/sdk/telemetry`'s `ENVIRONMENTS`.
 */
 function devtoolsEnvironment() {
 	return isNonInteractive() ? "ci" : "local";

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-C07-ioHm.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-BKFDtzXI.js";
 export { captureDevtoolsDeprecation, captureDevtoolsError, devtoolsEnvironment, devtoolsTelemetryEnabled, hasRealCaller, initDevtoolsTelemetry, lastSentryEventId, reportDevtoolsError, reportDevtoolsFailure, resolveDevtoolsDsn };

package/dist/with-env.js

@@ -0,0 +1,370 @@
+import { a as LocalStackOfflineError, c as applyDeployTierAliases, d as loadEnvironment, g as UnknownEnvironmentError, l as applyWranglerLocalDatabaseAlias, n as GENERATED_FILE, o as MissingEnvFileError, p as probeLocalStack } from "./load-Cp8AMERM.js";
+import { n as availableTiers, s as askSession, t as SESSION_SELECTORS } from "./session-rbONwFvY.js";
+import { createRequire } from "node:module";
+import { existsSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { execFile, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+//#region ../cli-core/src/env-runtime/confirm.ts
+async function askOnTerminal(question) {
+	const { createInterface } = await import("node:readline/promises");
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	try {
+		const answer = await rl.question(`${question} [y/N] `);
+		return /^y(es)?$/i.test(answer.trim());
+	} finally {
+		rl.close();
+	}
+}
+async function confirmProduction(options) {
+	if (options.tier !== "production" || options.yes) return { ok: true };
+	if (!options.isTTY) return {
+		ok: false,
+		reason: "--yes is required to preview production."
+	};
+	return await (options.ask ?? askOnTerminal)(`Run ${options.what} against live production data?`) ? { ok: true } : {
+		ok: false,
+		reason: "not confirmed."
+	};
+}
+//#endregion
+//#region ../cli-core/src/env-runtime/generated.ts
+/**
+* Writes `.env.generated` — the local Supabase stack's connection block — when
+* the stack is listening and the file is missing or stale, so
+* `supabase start|stop` can stay plain passthroughs and nothing has to be
+* remembered afterwards.
+*
+* Cost: `supabase status -o env` takes about 1.1s, paid once, not per run.
+*
+* Do the values survive a stack restart? Yes: the keys are signed from the
+* `jwt_secret` in `supabase/config.toml` and the ports are pinned there, so a
+* restart reproduces them byte for byte. What does invalidate the file is
+* editing `config.toml` (a new secret or port), so the file counts as stale
+* when `config.toml` is newer than it.
+*/
+function supabaseStatus(root) {
+	return new Promise((resolve, reject) => {
+		execFile("supabase", [
+			"status",
+			"-o",
+			"env"
+		], {
+			cwd: root,
+			shell: process.platform === "win32",
+			timeout: 3e4
+		}, (err, stdout) => err ? reject(new Error(err.message)) : resolve(stdout));
+	});
+}
+/**
+* Where `supabase/config.toml` lives for the repo at `root`: `root` itself in
+* DevDogsUGA, `<root>/devdogsuga` in a Backstage checkout (which has no
+* `supabase/` of its own; see cli-core's `repo/layout.ts`). Falls back to
+* `root` when neither has one.
+*/
+function supabaseRootFor(root) {
+	if (existsSync(join(root, "supabase", "config.toml"))) return root;
+	const sibling = join(root, "devdogsuga");
+	return existsSync(join(sibling, "supabase", "config.toml")) ? sibling : root;
+}
+function isStale(root) {
+	const config = join(supabaseRootFor(root), "supabase", "config.toml");
+	if (!existsSync(config)) return false;
+	return statSync(config).mtimeMs > statSync(join(root, GENERATED_FILE)).mtimeMs;
+}
+async function ensureGeneratedEnv(options) {
+	const { root } = options;
+	const supabaseRoot = supabaseRootFor(root);
+	const targets = supabaseRoot === root ? [root] : [root, supabaseRoot];
+	const exists = targets.every((dir) => existsSync(join(dir, GENERATED_FILE)));
+	if (exists && !isStale(root)) return { action: "none" };
+	if (!await options.probe()) return { action: "none" };
+	try {
+		const output = await (options.status ?? supabaseStatus)(supabaseRoot);
+		if (!/^[A-Z_]+=/m.test(output)) return {
+			action: "failed",
+			reason: "unexpected output from supabase"
+		};
+		for (const dir of targets) writeFileSync(join(dir, GENERATED_FILE), output);
+		return {
+			action: exists ? "refreshed" : "written",
+			file: GENERATED_FILE
+		};
+	} catch (err) {
+		return {
+			action: "failed",
+			reason: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+//#endregion
+//#region ../cli-core/src/env-runtime/cli.ts
+/**
+* Single env-loading helper for every workspace script:
+*
+*   with-env [--tier <tier>] <command> [args...] [--tier <tier>]
+*   with-env -c '<shell command>'
+*   with-env --worker <app> [--yes] -- <command> [args...]
+*
+* `--tier` is also taken from the END of the wrapped command, because that is
+* where `pnpm <script> --tier staging` puts it. On a terminal, the questions
+* `askSession` (in `ask.ts`) shares with the devtools launcher are asked:
+* which tier when several tier files are present and none is named, and which
+* development database (remembered in `.env` if you say so) when `.env` names
+* a remote one. With no terminal, an unnamed tier among several is refused.
+*
+* Loads the environment `DEPLOY_ENV` selects, where unset means development
+* means the root `.env`. In development only, it also loads the
+* `.env.generated` overlay when the local Supabase stack is actually listening
+* (see `load.ts` for the probe table). Installed as a bin, so it inherits the
+* calling package's directory and its node_modules/.bin, with no chdir or PATH
+* fixup.
+*
+* The files it loaded are printed to stderr on every run. That is a design
+* requirement, not chattiness: the probe silently decides between the hosted
+* project and a running local container, and which database a command just
+* touched must never be a guess.
+*
+* Use -c when the command needs a value *from* the env files. A $VAR in the
+* script is expanded by pnpm's shell before this helper loads anything, so it
+* would resolve against the ambient environment; quoting it and passing it to
+* -c defers expansion until after the env is loaded. -c runs the string
+* through @yarnpkg/shell, the same JS shell pnpm's shellEmulator uses, so it
+* stays cross-platform.
+*
+* `--worker <app>` additionally writes the app's Worker env (see
+* `worker-env.ts`) to a private mode-0600 file for the life of the command and
+* substitutes its path for any argument spelled `{env-file}`, e.g.
+* `with-env --worker platform -- wrangler dev --env-file {env-file}`.
+* Previewing the production tier asks first (`--yes` when there is no
+* terminal).
+*
+* ⚠️ The `--` there is load-bearing. Node scans a script's WHOLE argv for
+* `--env-file`, not just its own options, and stops only at `--`: without it,
+* the node running this file tries to load the literal `{env-file}` and dies
+* with `node: {env-file}: not found` before any of this code runs.
+*
+* Neither mode spawns a platform shell, so this works on Windows and POSIX.
+*/
+function findRoot(from) {
+	for (let dir = from;;) {
+		if (existsSync(join(dir, "pnpm-workspace.yaml"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) {
+			console.error("with-env: could not locate the monorepo root.");
+			process.exit(1);
+		}
+		dir = parent;
+	}
+}
+const rootOverride = process.env.WITH_ENV_ROOT_FOR_TESTS;
+if (rootOverride !== void 0 && rootOverride !== "") console.error(`with-env: root overridden by WITH_ENV_ROOT_FOR_TESTS=${rootOverride} (tests only)`);
+const root = rootOverride !== void 0 && rootOverride !== "" ? rootOverride : findRoot(resolve(dirname(fileURLToPath(import.meta.url)), ".."));
+const program = new Command("with-env").enablePositionalOptions().passThroughOptions().option("-c <script>", "run a shell script string with the env loaded").option("--tier <tier>", `environment to load (${SESSION_SELECTORS.join(", ")}, or bare development); overrides DEPLOY_ENV`).option("--worker <app>", "write <app>'s Worker env to a temp file; {env-file} in the command is replaced by its path").option("--yes", "confirm previewing the production tier without asking").argument("[command...]", "command to run with the env loaded").configureOutput({ writeErr: (str) => process.stderr.write(str.replace(/^error:/, "with-env:")) });
+program.parse();
+const opts = program.opts();
+const args = program.args;
+let trailingTier;
+for (let i = 1; i < args.length; i++) {
+	const arg = args[i];
+	if (arg !== "--tier" && !arg.startsWith("--tier=")) continue;
+	const value = arg === "--tier" ? args[i + 1] : arg.slice(7);
+	if (value === void 0 || value === "" || value.startsWith("-")) {
+		console.error("with-env: --tier needs a value");
+		process.exit(1);
+	}
+	trailingTier = value;
+	args.splice(i, arg === "--tier" ? 2 : 1);
+	i--;
+}
+if (trailingTier !== void 0 && opts.tier !== void 0 && trailingTier !== opts.tier) {
+	console.error(`with-env: the script names --tier ${opts.tier} and its arguments name --tier ${trailingTier}`);
+	process.exit(1);
+}
+const explicitTier = opts.tier ?? trailingTier;
+const usage = "with-env: usage: with-env <command> [args...]\n                 with-env -c '<shell command>'";
+const shellMode = opts.c !== void 0;
+if (shellMode && args.length > 0) {
+	console.error("with-env: -c takes a single quoted string\n" + usage);
+	process.exit(1);
+}
+if (shellMode && opts.worker !== void 0) {
+	console.error("with-env: --worker takes a command, not -c\n" + usage);
+	process.exit(1);
+}
+if (!shellMode && args.length === 0) {
+	console.error(usage);
+	process.exit(1);
+}
+const cwd = process.cwd();
+const tierExists = (relPath) => existsSync(join(root, relPath));
+const canAsk = process.stdin.isTTY === true && process.stdout.isTTY === true && process.env.CI !== "true" && process.env.CI !== "1";
+const resolution = await askSession({
+	root,
+	explicit: explicitTier,
+	deployEnv: process.env.DEPLOY_ENV,
+	devDb: process.env.DEV_DB,
+	available: await availableTiers(root, tierExists),
+	canAsk,
+	unanswered: "probe",
+	name: "with-env"
+});
+if (!resolution.ok) {
+	console.error(`with-env: ${resolution.reason}`);
+	process.exit(1);
+}
+if (canAsk && resolution.tier === "development" && resolution.devDatabase === "local" && !await probeLocalStack()) {
+	const { cancel, confirm, isCancel } = await import("@clack/prompts");
+	const start = await confirm({ message: "The local Supabase stack is not running. Start it now?" });
+	if (isCancel(start)) {
+		cancel("Cancelled.");
+		process.exit(1);
+	}
+	if (start) {
+		if (await new Promise((done) => {
+			spawn("pnpm", [
+				"devtools",
+				"db",
+				"start"
+			], {
+				cwd: root,
+				env: {
+					...process.env,
+					DEPLOY_ENV: "development",
+					DEV_DB: "local"
+				},
+				stdio: "inherit",
+				shell: process.platform === "win32"
+			}).on("error", () => done(1)).on("exit", (exitCode) => done(exitCode ?? 1));
+		}) !== 0) {
+			console.error("with-env: `pnpm devtools db start` failed; see above.");
+			process.exit(1);
+		}
+	}
+}
+if (opts.worker !== void 0) {
+	const confirmed = await confirmProduction({
+		tier: resolution.tier,
+		what: opts.worker,
+		yes: opts.yes === true,
+		isTTY: Boolean(process.stdin.isTTY)
+	});
+	if (!confirmed.ok) {
+		console.error(`with-env: ${confirmed.reason}`);
+		process.exit(1);
+	}
+}
+if (resolution.tier === "development" && resolution.devDatabase !== "remote") {
+	const generated = await ensureGeneratedEnv({
+		root,
+		probe: () => probeLocalStack()
+	});
+	if (generated.action === "written" || generated.action === "refreshed") console.error(`with-env: ${generated.action} ${generated.file} from \`supabase status -o env\`.`);
+	else if (generated.action === "failed") console.error(`with-env: could not write .env.generated (${generated.reason}).`);
+}
+const sessionLabel = resolution.devDatabase === void 0 ? resolution.tier : `${resolution.tier}:${resolution.devDatabase}`;
+let env;
+let envFiles;
+try {
+	const loaded = await loadEnvironment(resolution.tier, { devDatabase: resolution.devDatabase }, { root });
+	for (const warning of loaded.warnings) console.error(`with-env: ${warning}`);
+	console.error(`with-env: loaded ${loaded.files.join(" + ")} (${sessionLabel})`);
+	envFiles = loaded.files;
+	env = loaded.env;
+} catch (err) {
+	if (err instanceof MissingEnvFileError) {
+		console.error(`with-env: ${err.message}`);
+		console.error("with-env: continuing with no env file loaded.");
+		envFiles = [];
+		env = {};
+		for (const [key, value] of Object.entries(process.env)) if (value !== void 0) env[key] = value;
+		applyWranglerLocalDatabaseAlias(env);
+	} else if (err instanceof LocalStackOfflineError) {
+		console.error(`with-env: ${err.message}`);
+		process.exit(1);
+	} else if (err instanceof UnknownEnvironmentError) {
+		console.error(`with-env: ${err.message}`);
+		process.exit(1);
+	} else throw err;
+}
+applyDeployTierAliases(env, resolution.tier);
+env.DEPLOY_ENV = resolution.tier;
+if (resolution.devDatabase !== void 0) env.DEV_DB = resolution.devDatabase;
+/**
+* dotenvx's CLI entry point, resolved through its package rather than a `.bin`
+* shim: Node refuses to spawn `.cmd` without a shell, so the shim is not
+* something we can exec directly.
+*/
+function dotenvxCli() {
+	try {
+		const require = createRequire(import.meta.url);
+		const pkgPath = require.resolve("@dotenvx/dotenvx/package.json");
+		const { bin } = require("@dotenvx/dotenvx/package.json");
+		const entry = typeof bin === "string" ? bin : bin?.dotenvx;
+		if (!entry) throw new Error("no bin entry");
+		return join(dirname(pkgPath), entry);
+	} catch {
+		console.error("with-env: cannot find @dotenvx/dotenvx — run `pnpm install` at the repo root.");
+		process.exit(1);
+	}
+}
+if (shellMode && opts.c !== void 0) {
+	const [{ npath }, { execute }] = await Promise.all([import("@yarnpkg/fslib"), import("@yarnpkg/shell")]);
+	process.exit(await execute(opts.c, [], {
+		cwd: npath.toPortablePath(cwd),
+		env,
+		stdin: process.stdin,
+		stdout: process.stdout,
+		stderr: process.stderr
+	}));
+}
+const windows = process.platform === "win32";
+let workerEnvFile;
+if (opts.worker !== void 0) {
+	const [{ loadAppRegistry }, { buildWorkerEnv }, { writeWranglerEnvFile }] = await Promise.all([
+		import("./app-registry-BoAnenqC.js"),
+		import("./worker-env-CAFmquhW.js"),
+		import("./wrangler-env-BrlNe4pm.js")
+	]);
+	try {
+		const registry = await loadAppRegistry(cwd);
+		workerEnvFile = await writeWranglerEnvFile(buildWorkerEnv(opts.worker, env, "dev", registry).env);
+	} catch (err) {
+		console.error(`with-env: --worker ${opts.worker}: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+	env.WORKER_ENV_FILE = workerEnvFile.path;
+	for (let i = 0; i < args.length; i++) if (args[i] === "{env-file}") args[i] = workerEnvFile.path;
+}
+const child = spawn(windows ? process.execPath : args[0], windows ? [
+	dotenvxCli(),
+	"run",
+	"--quiet",
+	...envFiles.length === 0 ? ["--ignore=MISSING_ENV_FILE"] : [],
+	...envFiles.flatMap((f) => ["-f", join(root, f)]),
+	"--",
+	...args
+] : args.slice(1), {
+	cwd,
+	env,
+	stdio: "inherit"
+});
+child.on("error", (err) => {
+	workerEnvFile?.remove();
+	console.error(`with-env: ${err.message}`);
+	process.exit(1);
+});
+if (workerEnvFile !== void 0) for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => child.kill(signal));
+child.on("exit", (code, signal) => {
+	workerEnvFile?.remove();
+	if (signal) {
+		process.removeAllListeners(signal);
+		process.kill(process.pid, signal);
+	} else process.exit(code ?? 1);
+});
+//#endregion
+export {};

package/dist/worker-env-CAFmquhW.js

@@ -0,0 +1,36 @@
+//#region ../cli-core/src/env-runtime/worker-env.ts
+const WRANGLER_OWNED_KEYS = /* @__PURE__ */ new Set(["DEPLOY_ENV", "NODE_ENV"]);
+function buildWorkerEnv(app, environment, purpose, registry) {
+	const env = {};
+	const absent = [];
+	const minted = [];
+	const storable = new Set(registry.storableKeys());
+	const entriesByKey = purpose === "dev" ? [...registry.variables()].sort(([a], [b]) => a < b ? -1 : 1) : [...registry.variables()];
+	for (const [key, entries] of entriesByKey) {
+		if (purpose === "dev") {
+			if (!entries.some((e) => e.source === app)) continue;
+			if (WRANGLER_OWNED_KEYS.has(key)) continue;
+			const value = environment[key];
+			if (value !== void 0) env[key] = value;
+			continue;
+		}
+		if (!entries.some((e) => e.source === app && !e.client)) continue;
+		const meta = entries[0].meta;
+		if (meta.secrecy === "secret") {
+			if (!storable.has(key)) {
+				minted.push(key);
+				continue;
+			}
+		} else if (meta.secrecy !== "public") continue;
+		const value = environment[key];
+		if (value === void 0 || value === "") absent.push(key);
+		else env[key] = value;
+	}
+	return {
+		env,
+		absent,
+		minted
+	};
+}
+//#endregion
+export { buildWorkerEnv };

package/dist/wrangler-env-BrlNe4pm.js

@@ -0,0 +1,34 @@
+//#region ../cli-core/src/env-runtime/wrangler-env.ts
+/**
+* The mode-0600 env file `wrangler dev --env-file` reads, written to a fresh
+* private temp directory so a credential-bearing file never lands in the repo.
+*/
+/**
+* dotenv preserves single-quoted values byte-for-byte, including multiline
+* private keys and literal backslash sequences.
+*/
+function renderWranglerEnvFile(env) {
+	return Object.entries(env).map(([key, value]) => `${key}='${value}'`).join("\n") + "\n";
+}
+async function writeWranglerEnvFile(env) {
+	const [{ mkdtempSync, rmSync, writeFileSync }, { tmpdir }, { join }] = await Promise.all([
+		import("node:fs"),
+		import("node:os"),
+		import("node:path")
+	]);
+	const directory = mkdtempSync(join(tmpdir(), "with-env-wrangler-"));
+	const path = join(directory, ".dev.vars");
+	writeFileSync(path, renderWranglerEnvFile(env), {
+		encoding: "utf8",
+		mode: 384
+	});
+	return {
+		path,
+		remove: () => rmSync(directory, {
+			recursive: true,
+			force: true
+		})
+	};
+}
+//#endregion
+export { renderWranglerEnvFile, writeWranglerEnvFile };

package/env.ts

@@ -12,7 +12,7 @@
  * repository, refused storage because storing it defeats the thing it
  * protects. See the long-form reasoning in `src/bws/environments.ts`.
  */
-import { declare, define } from "@devdogsuga/env";
+import { declare, define } from "@devdogsuga/sdk/env";
 import { z } from "zod";
 
 declare({

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@devdogsuga/devtools",
-  "version": "0.1.50",
+  "version": "0.1.51-next.526",
   "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.",
+  "description": "Contributor CLI for DevDogs repositories (the platform monorepo, DogDays, DogPack): the real tools with the session's tier filled in, `setup`, `db sync`, `db types`, `dev-data`, a menu over them, the checks CI runs, and the `with-env` launcher. Ships built JS; run via `pnpm dlx @devdogsuga/devtools` or `npx @devdogsuga/devtools` (or the `devtools` bin once installed) from inside a clone.",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
-    "url": "https://github.com/DevDogsUGA/Backstage.git",
+    "url": "https://github.com/DevDogsUGA/DevDogsUGA.git",
     "directory": "packages/devtools"
   },
   "publishConfig": {
@@ -15,7 +15,8 @@
     "provenance": true
   },
   "bin": {
-    "devtools": "./bin/devtools.mjs"
+    "devtools": "./bin/devtools.mjs",
+    "with-env": "./bin/with-env.mjs"
   },
   "files": [
     "bin",
@@ -24,27 +25,19 @@
   ],
   "dependencies": {
     "@clack/prompts": "1.7.0",
+    "@dotenvx/dotenvx": "^2.21.0",
     "@sentry/core": "10.75.1",
     "@sentry/node": "10.75.1",
     "@supabase/supabase-js": "^2.112.3",
+    "@yarnpkg/fslib": "^3.1.5",
+    "@yarnpkg/shell": "^4.1.3",
+    "commander": "^14.0.3",
     "dotenv": "^17.4.2",
     "postgres": "^3.4.9",
     "tsx": "^4.23.12",
     "typescript": "^6.0.3",
     "zod": "4.4.3"
   },
-  "peerDependencies": {
-    "@devdogsuga/db": "*",
-    "@devdogsuga/env": "*"
-  },
-  "peerDependenciesMeta": {
-    "@devdogsuga/db": {
-      "optional": true
-    },
-    "@devdogsuga/env": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@vitest/coverage-v8": "^4.1.11",
@@ -52,10 +45,8 @@
     "tsdown": "^0.23.0",
     "vitest": "^4.1.11",
     "@devdogsuga/cli-core": "0.0.0",
-    "@devdogsuga/db": "0.1.5",
-    "@devdogsuga/env": "0.1.8",
-    "@devdogsuga/config": "0.1.3",
-    "@devdogsuga/telemetry": "0.1.5"
+    "@devdogsuga/config": "0.1.4-next.526",
+    "@devdogsuga/sdk": "0.1.0"
   },
   "scripts": {
     "build": "tsdown && node scripts/write-build-info.mjs && node ../../scripts/check-bundle-imports.mjs",