@devdogsuga/devtools 0.1.25 → 0.1.27

package/dist/cron/schema.d.ts

@@ -1,45 +0,0 @@
-/**
- * Zod schemas for the two cron-trigger exports an app's
- * `cloudflare/scheduled.ts` may declare: `CRON_ROUTES` (a schedule that fetches
- * one or more of the app's own routes) and the optional `WORKFLOW_CRONS`
- * (audit metadata for a native Cloudflare Workflow schedule).
- *
- * devtools enforces both at its import boundary (see `discovery.ts`): an app
- * that drifts from the shape fails the audit and a conformance test, rather
- * than reading as an empty (silently unaudited) map.
- *
- * Invariants, each a test rather than a hope:
- *   - Every route starts `/` and lives on the app's own origin.
- *   - `routes` is non-empty: a key that fires nothing is a config bug.
- *   - `label` is non-blank: the audit's English description; never empty.
- *   - Keyed by the cron expression exactly as wrangler carries it, so
- *     reconciliation is a set comparison, never a parse.
- */
-import { z } from "zod";
-declare const CronEntry: z.ZodObject<{
-    routes: z.ZodArray<z.ZodString>;
-    label: z.ZodString;
-}, z.core.$strip>;
-export declare const CronRoutes: z.ZodRecord<z.ZodString, z.ZodObject<{
-    routes: z.ZodArray<z.ZodString>;
-    label: z.ZodString;
-}, z.core.$strip>>;
-export type CronRoutes = z.infer<typeof CronRoutes>;
-export type CronEntry = z.infer<typeof CronEntry>;
-/**
- * A native workflow schedule. `binding` names the Workflows binding (e.g.
- * `SCRAPE_WORKFLOW`); `cron list` reconciles the expression against that
- * binding's `workflows[].schedules` in the tier's `wrangler.jsonc`. `label` is
- * the audit's English description, same contract as routes.
- */
-declare const WorkflowCronEntry: z.ZodObject<{
-    binding: z.ZodString;
-    label: z.ZodString;
-}, z.core.$strip>;
-export declare const WorkflowCrons: z.ZodRecord<z.ZodString, z.ZodObject<{
-    binding: z.ZodString;
-    label: z.ZodString;
-}, z.core.$strip>>;
-export type WorkflowCrons = z.infer<typeof WorkflowCrons>;
-export type WorkflowCronEntry = z.infer<typeof WorkflowCronEntry>;
-export {};

package/dist/cron/schema.js

@@ -1,35 +0,0 @@
-/**
- * Zod schemas for the two cron-trigger exports an app's
- * `cloudflare/scheduled.ts` may declare: `CRON_ROUTES` (a schedule that fetches
- * one or more of the app's own routes) and the optional `WORKFLOW_CRONS`
- * (audit metadata for a native Cloudflare Workflow schedule).
- *
- * devtools enforces both at its import boundary (see `discovery.ts`): an app
- * that drifts from the shape fails the audit and a conformance test, rather
- * than reading as an empty (silently unaudited) map.
- *
- * Invariants, each a test rather than a hope:
- *   - Every route starts `/` and lives on the app's own origin.
- *   - `routes` is non-empty: a key that fires nothing is a config bug.
- *   - `label` is non-blank: the audit's English description; never empty.
- *   - Keyed by the cron expression exactly as wrangler carries it, so
- *     reconciliation is a set comparison, never a parse.
- */
-import { z } from "zod";
-const CronRoute = z.string().startsWith("/");
-const CronEntry = z.object({
-    routes: z.array(CronRoute).min(1),
-    label: z.string().min(1),
-});
-export const CronRoutes = z.record(z.string(), CronEntry);
-/**
- * A native workflow schedule. `binding` names the Workflows binding (e.g.
- * `SCRAPE_WORKFLOW`); `cron list` reconciles the expression against that
- * binding's `workflows[].schedules` in the tier's `wrangler.jsonc`. `label` is
- * the audit's English description, same contract as routes.
- */
-const WorkflowCronEntry = z.object({
-    binding: z.string().min(1),
-    label: z.string().min(1),
-});
-export const WorkflowCrons = z.record(z.string(), WorkflowCronEntry);

package/dist/db/config-push.d.ts

@@ -1,8 +0,0 @@
-/**
- * `config.toml` lives on a hosted project only — there is no local
- * `--project-ref` to push to — so this takes the ref directly rather than a
- * `Target`. The caller (`cli.ts`) resolves it from the tier, exactly like
- * every other remote db operation now does, instead of letting the supabase
- * CLI fall back to whatever project it has `--linked`.
- */
-export declare function runConfigPush(projectRef: string): Promise<number>;

package/dist/db/config-push.js

@@ -1,11 +0,0 @@
-import { supabase } from "./run.js";
-/**
- * `config.toml` lives on a hosted project only — there is no local
- * `--project-ref` to push to — so this takes the ref directly rather than a
- * `Target`. The caller (`cli.ts`) resolves it from the tier, exactly like
- * every other remote db operation now does, instead of letting the supabase
- * CLI fall back to whatever project it has `--linked`.
- */
-export async function runConfigPush(projectRef) {
-    return supabase("config", "push", "--project-ref", projectRef);
-}

package/dist/db/connection.d.ts

@@ -1,79 +0,0 @@
-/**
- * Resolves the database a `db` command acts on — from the SESSION, never
- * from a flag.
- *
- * There used to be two connection mechanisms here (`db/remote.ts`'s
- * `--target remote` tier resolver, and `db/local-env.ts`'s "whatever this
- * process entered"), joined by a `--target local|remote` flag that asked a
- * question the launcher had already answered: `launch.ts` settles a session
- * (`--tier development:local|development:remote|staging|production`, or the
- * picker) and enters its env BEFORE any command dispatches, so
- * `process.env.DB_URL` already names the one database this session means.
- * This module reads that — the same `DB_URL` every app and script uses —
- * and every mechanism-one caller now goes through it. `resolveLocalToolingEnv`
- * remains for the two commands that hand a whole ENVIRONMENT to a child
- * process rather than needing a connection of their own.
- *
- * What it adds over a raw `process.env.DB_URL` read is the two sanity
- * guards a session can still violate:
- *
- *   * development meaning the LOCAL stack, but `DB_URL` pointing somewhere
- *     that is not loopback — the stack went down after launch (the overlay
- *     is applied at entry; see `load.ts`'s probe table) or the degraded
- *     `db`-exempt entry ran without it. Refused with `db start`
- *     troubleshooting rather than letting `.env`'s hosted `DB_URL` answer
- *     for a command that asked for Docker.
- *   * a DEPLOYED tier whose `DB_URL` points AT loopback — the signature of
- *     inherited development values winning under `override: false` (see
- *     `launch.ts`). Refused rather than "migrating staging" against a local
- *     container.
- *
- * Reports the reason on stderr and returns `null` on every failure path —
- * never throws for an expected failure — so a caller can stop without
- * printing a second explanation of its own.
- *
- * ## `db connect` — plausibly vestigial
- *
- * `connectRemoteProject` (`stack.ts`) still runs `supabase link
- * --project-ref <ref>`, the pre-session way of naming "the remote project",
- * remembered by the supabase CLI on disk and read by nothing in this CLI:
- * every operation here passes `--db-url`/`--project-ref` explicitly. It may
- * still matter to someone driving the bare `supabase` CLI by hand, so
- * removing it is a separate decision from this refactor.
- */
-import type { DeployEnvironment } from "@devdogsuga/env";
-import type { DevDatabase } from "@devdogsuga/env/load";
-export declare function isLocalDbUrl(url: string): boolean;
-/** The hostname for messages — never the URL itself, which carries the
- * password. */
-export declare function dbHost(url: string): string;
-/** What the session resolved to: the one database every `db` data command
- * in this process acts on. `projectRef` is only validated where it is
- * actually needed (`seed buckets`, `config push`). */
-export interface DbConnection {
-    tier: DeployEnvironment;
-    /** The session's development qualifier, when one was entered. */
-    devDatabase: DevDatabase | undefined;
-    dbUrl: string;
-    projectRef: string | undefined;
-}
-/** Whether this connection is the Docker stack on this machine — the one
- * database whose erasure is routine rather than gated sternly. */
-export declare function isLocalConnection(conn: DbConnection): boolean;
-/**
- * How gates and reports name the target. Deliberately tier-and-host only —
- * never the DB_URL, which carries the password — and "remote development"
- * is spelled out because `staging`/`production` are also remote: the whole
- * reason the session vocabulary qualifies development.
- */
-export declare function describeDbTarget(conn: DbConnection): string;
-export interface ResolveDbConnectionOptions {
-    /** Stderr prefix, e.g. "devtools db reset". */
-    label?: string;
-    /** Injectable for tests; defaults to `process.env`. */
-    env?: NodeJS.ProcessEnv;
-    /** Suppress the stderr reason — for callers like `db status` that treat
-     * "no resolvable database" as an answer, not a failure. */
-    quiet?: boolean;
-}
-export declare function resolveDbConnection(opts?: ResolveDbConnectionOptions): Promise<DbConnection | null>;

package/dist/db/connection.js

@@ -1,114 +0,0 @@
-import { loadEnv, loadEnvLoad } from "../repo/peers.js";
-/**
- * Hostnames that mean "the Docker stack on this machine". The same list
- * `docs/index-pages.ts` keeps for its delete-acknowledgment; duplicated
- * because that module answers a different question ("may I delete rows
- * here without --target remote?") and coupling the two would let a change
- * for one silently reshape the other.
- */
-const LOCAL_DB_HOSTS = [
-    "localhost",
-    "127.0.0.1",
-    "[::1]",
-    "host.docker.internal",
-];
-export function isLocalDbUrl(url) {
-    try {
-        return LOCAL_DB_HOSTS.includes(new URL(url).hostname);
-    }
-    catch {
-        return false;
-    }
-}
-/** The hostname for messages — never the URL itself, which carries the
- * password. */
-export function dbHost(url) {
-    try {
-        return new URL(url).hostname || "unknown host";
-    }
-    catch {
-        return "unknown host";
-    }
-}
-/** Whether this connection is the Docker stack on this machine — the one
- * database whose erasure is routine rather than gated sternly. */
-export function isLocalConnection(conn) {
-    return conn.tier === "development" && isLocalDbUrl(conn.dbUrl);
-}
-/**
- * How gates and reports name the target. Deliberately tier-and-host only —
- * never the DB_URL, which carries the password — and "remote development"
- * is spelled out because `staging`/`production` are also remote: the whole
- * reason the session vocabulary qualifies development.
- */
-export function describeDbTarget(conn) {
-    if (conn.tier !== "development")
-        return `the ${conn.tier} database`;
-    if (isLocalDbUrl(conn.dbUrl))
-        return "your local database";
-    return `the remote development database at ${dbHost(conn.dbUrl)}`;
-}
-export async function resolveDbConnection(opts = {}) {
-    const { DEPLOY_ENVIRONMENTS, fileFor, isDeployEnvironment } = await loadEnv();
-    const { DEV_DB_ENV, isDevDatabase } = await loadEnvLoad();
-    const env = opts.env ?? process.env;
-    const label = opts.label ?? "devtools db";
-    const report = (message) => {
-        if (!opts.quiet)
-            process.stderr.write(message);
-    };
-    const rawTier = env.DEPLOY_ENV;
-    let tier;
-    if (rawTier === undefined || rawTier === "") {
-        tier = "development";
-    }
-    else if (isDeployEnvironment(rawTier)) {
-        tier = rawTier;
-    }
-    else {
-        report(`${label}: DEPLOY_ENV="${rawTier}" is not one of ${DEPLOY_ENVIRONMENTS.join(", ")}.\n`);
-        return null;
-    }
-    let devDatabase;
-    const rawDevDb = env[DEV_DB_ENV];
-    if (tier === "development" && rawDevDb !== undefined && rawDevDb !== "") {
-        if (!isDevDatabase(rawDevDb)) {
-            report(`${label}: ${DEV_DB_ENV}="${rawDevDb}" is not one of: local, remote.\n`);
-            return null;
-        }
-        devDatabase = rawDevDb;
-    }
-    const dbUrl = env.DB_URL;
-    if (dbUrl === undefined || dbUrl === "") {
-        if (tier !== "development") {
-            report(`${label}: ${fileFor(tier)} has no DB_URL.\n`);
-        }
-        else if (devDatabase === "remote") {
-            report(`${label}: this session targets the remote development database, but .env has no DB_URL.\n`);
-        }
-        else {
-            report(`${label}: no DB_URL in this session — the local Supabase stack is ` +
-                "not running. Run `pnpm devtools db start`, or relaunch with " +
-                "`--tier development:remote` (or staging/production) to act on a " +
-                "hosted database.\n");
-        }
-        return null;
-    }
-    if (tier === "development" &&
-        devDatabase !== "remote" &&
-        !isLocalDbUrl(dbUrl)) {
-        report(`${label}: DB_URL points at ${dbHost(dbUrl)}, not the local stack — ` +
-            "it is offline (or .env.generated is stale). Run `pnpm devtools db " +
-            "start`, or relaunch with `--tier development:remote` if you mean " +
-            "that database.\n");
-        return null;
-    }
-    if (tier !== "development" && isLocalDbUrl(dbUrl)) {
-        report(`${label}: the session tier is ${tier} but DB_URL points at ` +
-            `${dbHost(dbUrl)} — a local address, the signature of inherited ` +
-            "development values. Relaunch with `pnpm devtools --tier " +
-            `${tier}\` from a clean shell.\n`);
-        return null;
-    }
-    return { tier, devDatabase, dbUrl, projectRef: env.PROJECT_REF };
-}

package/dist/db/exec.d.ts

@@ -1 +0,0 @@
-export declare function runDbExec(args: string[]): Promise<number>;

package/dist/db/exec.js

@@ -1,11 +0,0 @@
-/**
- * `db exec -- <args…>` — the escape hatch.
- *
- * Everything after `--` passes straight to the Supabase CLI, unmodified. Same
- * stance as `bw` and `cf exec`: the wrapped CLI owns its own targeting and its
- * own flags, so this declares no subcommands and does no parsing of its own.
- */
-import { supabase } from "./run.js";
-export async function runDbExec(args) {
-    return supabase(...args);
-}

package/dist/db/generate-types.d.ts

@@ -1 +0,0 @@
-export declare function runGenerateTypes(dbUrl: string): Promise<number>;

package/dist/db/generate-types.js

@@ -1,4 +0,0 @@
-import { generateTypes } from "./run.js";
-export async function runGenerateTypes(dbUrl) {
-    return generateTypes(dbUrl);
-}

package/dist/db/generated-env.d.ts

@@ -1,69 +0,0 @@
-import type { DeployEnvironment } from "@devdogsuga/env";
-import type { DevDatabase } from "@devdogsuga/env/load";
-export interface EnsureGeneratedEnvDeps {
-    /** Is anything listening on the local stack port? Injected so tests never
-     *  open a real socket. */
-    probeLocalStack: () => boolean | Promise<boolean>;
-    /** File existence, relative to `repoRoot`. Injected so tests never touch
-     *  a real filesystem. */
-    exists: (file: string) => boolean;
-    /** `supabase status -o env`'s stdout, or a rejection when the CLI fails —
-     *  most commonly because the stack on 54321 belongs to a different
-     *  project. Injected so tests never spawn the real CLI. */
-    captureStatus: () => Promise<string>;
-    /** Writes `.env.generated`'s full path. Injected so tests never touch a
-     *  real filesystem. */
-    write: (path: string, contents: string) => Promise<void>;
-    /** `docker ps --format '{{.Names}}'`, pre-split — or `null` when Docker
-     *  could not be read. Injected so tests never spawn a real subprocess. */
-    listContainerNames: () => string[] | null;
-    /** This checkout's own `project_id`, or `null` if unreadable. Injected so
-     *  tests never touch a real filesystem. */
-    projectId: () => string | null;
-    /** Used only to build the path `write` receives. */
-    repoRoot: string;
-}
-export type EnsureGeneratedEnvResult = {
-    outcome: "skipped";
-} | {
-    outcome: "wrote";
-    line: string;
-} | {
-    outcome: "foreign";
-    projectId: string;
-    line: string;
-} | {
-    outcome: "unreachable";
-};
-/**
- * Regenerates `.env.generated` from a running local stack when THIS
- * checkout's own copy is missing.
- *
- * A no-op (`"skipped"`) unless every one of these holds: `tier` is
- * `"development"`, `devDatabase` is not `"remote"` (an explicit `"local"`
- * or the probe-decides `undefined` both qualify), the file is genuinely
- * absent, and something answers the local stack's port. That last check
- * also covers "the file is missing because the stack is genuinely down" —
- * nothing here runs `supabase status` against a stack that is not there;
- * the existing `LocalStackOfflineError`/warning handling covers that case
- * exactly as before.
- *
- * `"foreign"` and `"unreachable"` both mean `supabase status -o env`
- * itself failed — the port answered, but the CLI could not produce a
- * connection block. `"foreign"` is the case a running Docker container's
- * name resolves to: another project's stack holds the port.
- * `"unreachable"` is everything else (an unreadable `config.toml`, an
- * unreadable `docker ps`, a container name that matches nobody) — the
- * caller falls through to its existing offline handling either way, since
- * `.env.generated` is still missing on disk.
- */
-export declare function ensureGeneratedEnvFile(tier: DeployEnvironment, devDatabase: DevDatabase | undefined, deps: EnsureGeneratedEnvDeps): Promise<EnsureGeneratedEnvResult>;
-/**
- * The production wiring for `EnsureGeneratedEnvDeps`, shared by
- * `../env-entry.ts` (via `realEnvEntryDeps`) and `../stack.ts`'s `db
- * status`. `probeLocalStack` is passed in rather than resolved here because
- * both callers already hold the loaded `@devdogsuga/env/load` peer their
- * own dispatch needs anyway — resolving it again here would mean two
- * different copies of the same optional peer in play.
- */
-export declare function realEnsureGeneratedEnvDeps(probeLocalStack: () => boolean | Promise<boolean>): EnsureGeneratedEnvDeps;

package/dist/db/generated-env.js

@@ -1,113 +0,0 @@
-/**
- * Regenerating `.env.generated` from a Supabase stack that is ALREADY
- * running — started by `db start` in THIS checkout, sure, but just as
- * often by another workspace (a different clone or worktree of the
- * DevDogsUGA repo) that shares this repo's `project_id`. `supabase status`
- * finds containers by project id, not by which checkout ran `db start`, so
- * a stack a sibling workspace brought up answers for THIS checkout too —
- * except `.env.generated` (the connection block `startLocalStack`,
- * `../stack.ts`, writes) only ever lands in the workspace that actually ran
- * it. Left alone, this checkout sees port 54321 listening with the file
- * missing, and `@devdogsuga/env/load`'s `selectEnvFiles` either warns (an
- * unqualified session) or throws `LocalStackOfflineError` (an explicit
- * `development:local` one) — both of which used to mean the contributor
- * ran `supabase status -o env > .env.generated` by hand.
- *
- * `ensureGeneratedEnvFile` does that automatically, before a session's env
- * files ever load: `enterSessionEnvironment` (`../env-entry.ts`) calls it on
- * every command dispatch, and `db status` (`../stack.ts`) calls it to
- * report the file's state accurately instead of trusting a stale absence.
- * Both are read-only from THIS checkout's point of view — nothing here
- * starts, stops, or resets anything; it only reads a port, a file, and
- * (best-effort) the stack's own connection block.
- *
- * The other failure this covers: `supabase status -o env` itself fails
- * because what is listening on 54321 belongs to a DIFFERENT Supabase
- * project — a stack this repo's own `project_id` rename left orphaned, or
- * an unrelated project entirely. That is reported (`"foreign"`) rather than
- * silently falling through to the existing offline handling, which would
- * otherwise just repeat "nothing is listening" advice for a port that very
- * much has something listening on it.
- */
-import { existsSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { supabaseCapture } from "./run.js";
-import { findRepoRoot } from "../repo/root.js";
-import { foreignStackMessage, foreignStackProjectId, listContainerNames, STACK_API_PORT, readProjectId, } from "../repo/supabase-project.js";
-/** The file this module writes and checks — see `@devdogsuga/env/load`'s
- *  `GENERATED_FILE`, duplicated as a literal rather than imported so this
- *  module never has to load the `@devdogsuga/env` peer just for one
- *  constant. Keep in sync if that constant's value ever changes. */
-const GENERATED_FILE = ".env.generated";
-/**
- * Regenerates `.env.generated` from a running local stack when THIS
- * checkout's own copy is missing.
- *
- * A no-op (`"skipped"`) unless every one of these holds: `tier` is
- * `"development"`, `devDatabase` is not `"remote"` (an explicit `"local"`
- * or the probe-decides `undefined` both qualify), the file is genuinely
- * absent, and something answers the local stack's port. That last check
- * also covers "the file is missing because the stack is genuinely down" —
- * nothing here runs `supabase status` against a stack that is not there;
- * the existing `LocalStackOfflineError`/warning handling covers that case
- * exactly as before.
- *
- * `"foreign"` and `"unreachable"` both mean `supabase status -o env`
- * itself failed — the port answered, but the CLI could not produce a
- * connection block. `"foreign"` is the case a running Docker container's
- * name resolves to: another project's stack holds the port.
- * `"unreachable"` is everything else (an unreadable `config.toml`, an
- * unreadable `docker ps`, a container name that matches nobody) — the
- * caller falls through to its existing offline handling either way, since
- * `.env.generated` is still missing on disk.
- */
-export async function ensureGeneratedEnvFile(tier, devDatabase, deps) {
-    if (tier !== "development" || devDatabase === "remote") {
-        return { outcome: "skipped" };
-    }
-    if (deps.exists(GENERATED_FILE))
-        return { outcome: "skipped" };
-    if (!(await deps.probeLocalStack()))
-        return { outcome: "skipped" };
-    try {
-        const env = await deps.captureStatus();
-        await deps.write(join(deps.repoRoot, GENERATED_FILE), env);
-        return {
-            outcome: "wrote",
-            line: "devtools: wrote .env.generated from the running local stack",
-        };
-    }
-    catch {
-        const names = deps.listContainerNames();
-        const foreign = names === null ? null : foreignStackProjectId(names, deps.projectId());
-        if (foreign !== null) {
-            return {
-                outcome: "foreign",
-                projectId: foreign,
-                line: `devtools: ${foreignStackMessage(foreign)}`,
-            };
-        }
-        return { outcome: "unreachable" };
-    }
-}
-/**
- * The production wiring for `EnsureGeneratedEnvDeps`, shared by
- * `../env-entry.ts` (via `realEnvEntryDeps`) and `../stack.ts`'s `db
- * status`. `probeLocalStack` is passed in rather than resolved here because
- * both callers already hold the loaded `@devdogsuga/env/load` peer their
- * own dispatch needs anyway — resolving it again here would mean two
- * different copies of the same optional peer in play.
- */
-export function realEnsureGeneratedEnvDeps(probeLocalStack) {
-    const repoRoot = findRepoRoot();
-    return {
-        probeLocalStack,
-        exists: (file) => existsSync(join(repoRoot, file)),
-        captureStatus: () => supabaseCapture("status", "-o", "env"),
-        write: (path, contents) => writeFile(path, contents),
-        listContainerNames: () => listContainerNames(STACK_API_PORT),
-        projectId: () => readProjectId(repoRoot),
-        repoRoot,
-    };
-}

package/dist/db/introspect.d.ts

@@ -1 +0,0 @@
-export declare function runIntrospect(app?: string): Promise<number>;

package/dist/db/introspect.js

@@ -1,122 +0,0 @@
-/**
- * `db introspect --app <slug>` — pull an app's live schema into its generated
- * Drizzle files, then apply post-pull fixups.
- *
- * Replicates the old `db:pull` package script chain:
- *   1. drizzle-kit pull --config drizzle-introspection.config.ts  (auth/storage schemas)
- *   2. drizzle-kit pull --config drizzle.config.ts                (platform schema)
- *   3. Post-pull fixups on the generated schema.ts:
- *      a. Delete relations.ts (we maintain hand-written relations)
- *      b. Re-inject the cross-schema FK-target import (auth.users etc.)
- *      c. Append InPlatform-suffix aliases so existing imports stay stable
- *
- * `DB_URL` comes from `resolveLocalToolingEnv` — the tier this process
- * already entered (`launch.ts`, before `cli.ts` ever dispatched this
- * command), `.env.generated` overlay included — and is injected into the
- * subprocess environment. See `db/local-env.ts`'s header for why this is
- * NOT a raw `.env` parse.
- */
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { findRepoRoot } from "../repo/root.js";
-import { resolveLocalToolingEnv } from "./local-env.js";
-const APP_CONFIGS = {
-    platform: {
-        configs: ["drizzle-introspection.config.ts", "drizzle.config.ts"],
-        schemaFile: "src/server/db/schema/generated/schema.ts",
-        schemaSuffix: "InPlatform",
-        crossSchemaImport: 'import { usersInAuth as users, oauthClientsInAuth as oauthClients } from "~/supabase/drizzle/schema"',
-    },
-    "schedule-builder": {
-        configs: ["drizzle-introspection.config.ts", "drizzle.config.ts"],
-        schemaFile: "src/server/db/schema/generated/schema.ts",
-        schemaSuffix: "InScheduleBuilder",
-        // schedule_builder's own tables carry no foreign keys into another
-        // schema (its `userId` columns are bare uuids, not FK-constrained to
-        // auth.users), so there is nothing to re-inject here.
-        crossSchemaImport: null,
-    },
-};
-// ── drizzle-kit pull ──────────────────────────────────────────────────────────
-function runDrizzlePull(appDir, configFile, env) {
-    return new Promise((resolve) => {
-        const child = spawn("pnpm", ["exec", "drizzle-kit", "pull", "--config", configFile], { stdio: "inherit", cwd: appDir, env });
-        child.on("exit", (code) => resolve(code ?? 1));
-    });
-}
-// ── Post-pull fixups ──────────────────────────────────────────────────────────
-function applyPostPullFixups(appDir, cfg) {
-    const schemaPath = join(appDir, cfg.schemaFile);
-    const relationsPath = join(appDir, cfg.schemaFile.replace("schema.ts", "relations.ts"));
-    // 1. Delete relations.ts
-    if (existsSync(relationsPath))
-        rmSync(relationsPath);
-    if (!existsSync(schemaPath))
-        return;
-    let src = readFileSync(schemaPath, "utf8");
-    // 2. Re-inject cross-schema FK-target import (idempotent)
-    const IMPORT_MARKER = "// Cross-schema FK targets";
-    if (cfg.crossSchemaImport && !src.includes(IMPORT_MARKER)) {
-        const lines = src.split("\n");
-        let insertAt = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i] ?? "";
-            if (line.startsWith("import ") && line.includes("drizzle-orm")) {
-                insertAt = i + 1;
-            }
-            else if (line.trim() !== "" && !line.startsWith("import ")) {
-                break;
-            }
-        }
-        lines.splice(insertAt, 0, `${IMPORT_MARKER} — re-injected by devtools db introspect after each drizzle-kit pull`, cfg.crossSchemaImport);
-        src = lines.join("\n");
-    }
-    // 3. Append base-name aliases for every `<name><suffix>` export (idempotent)
-    const ALIAS_MARKER = "// Schema-suffix aliases";
-    if (cfg.schemaSuffix && !src.includes(ALIAS_MARKER)) {
-        const names = new Set();
-        const re = new RegExp(`export const (\\w+)${cfg.schemaSuffix}\\b`, "g");
-        for (const m of src.matchAll(re))
-            if (m[1])
-                names.add(m[1]);
-        if (names.size > 0) {
-            const aliases = [...names]
-                .sort()
-                .map((n) => `export { ${n}${cfg.schemaSuffix} as ${n} };`)
-                .join("\n");
-            src = `${src.trimEnd()}\n\n${ALIAS_MARKER} — appended by devtools db introspect\n${aliases}\n`;
-        }
-    }
-    writeFileSync(schemaPath, src);
-    process.stdout.write(`[introspect] patched ${cfg.schemaFile}\n`);
-}
-// ── Entry ─────────────────────────────────────────────────────────────────────
-export async function runIntrospect(app) {
-    if (!app) {
-        process.stderr.write("devtools db introspect: --app <slug> is required.\n");
-        return 1;
-    }
-    const cfg = APP_CONFIGS[app];
-    if (!cfg) {
-        const valid = Object.keys(APP_CONFIGS).join(", ");
-        process.stderr.write(`devtools db introspect: unknown app "${app}". Expected: ${valid}.\n`);
-        return 1;
-    }
-    const appDir = join(findRepoRoot(), "apps", app);
-    const env = await resolveLocalToolingEnv();
-    if (!env["DB_URL"]) {
-        process.stderr.write("devtools db introspect: DB_URL is not set. Run " +
-            "`pnpm devtools db start` first (for local — its connection string " +
-            "lives in .env.generated once the stack is up), or set DB_URL in " +
-            "the deploy tier's env file this process entered.\n");
-        return 1;
-    }
-    for (const configFile of cfg.configs) {
-        const code = await runDrizzlePull(appDir, configFile, env);
-        if (code !== 0)
-            return code;
-    }
-    applyPostPullFixups(appDir, cfg);
-    return 0;
-}