@devdogsuga/devtools 0.1.12 → 0.1.13

package/bin/devtools-ci.mjs

@@ -14,4 +14,18 @@ const launchCiEntry = join(
 );
 
 const { launchCi } = await import(launchCiEntry);
-await launchCi(process.argv.slice(2));
+try {
+  await launchCi(process.argv.slice(2));
+} catch (err) {
+  // Whatever escapes before a command is dispatched (repo discovery, tier
+  // resolution, env entry) — the dispatch itself reports its own. See
+  // `bin/devtools-ci-bare.mjs` for the same shape.
+  process.stderr.write(
+    `devtools-ci: ${err instanceof Error ? err.message : String(err)}\n`,
+  );
+  const { captureDevtoolsError } = await import(
+    join(dirname(fileURLToPath(import.meta.url)), "..", "dist", "telemetry.js")
+  );
+  await captureDevtoolsError(err);
+  process.exitCode = 1;
+}

package/bin/devtools.mjs

@@ -24,4 +24,18 @@ const launchEntry = join(
 );
 
 const { launch } = await import(launchEntry);
-await launch(process.argv.slice(2));
+try {
+  await launch(process.argv.slice(2));
+} catch (err) {
+  // Whatever escapes before a command is dispatched (repo discovery, tier
+  // resolution, env entry) — the dispatch itself reports its own. See
+  // `bin/devtools-ci-bare.mjs` for the same shape.
+  process.stderr.write(
+    `devtools: ${err instanceof Error ? err.message : String(err)}\n`,
+  );
+  const { captureDevtoolsError } = await import(
+    join(dirname(fileURLToPath(import.meta.url)), "..", "dist", "telemetry.js")
+  );
+  await captureDevtoolsError(err);
+  process.exitCode = 1;
+}

package/dist/catalog.d.ts

@@ -14,13 +14,15 @@
  * a copy of the reason list for people who are not at a terminal, but that copy
  * is maintained by hand and says so. This is what settles a disagreement.
  *
- * Both calls run as the seeded moderator rather than through an admin client.
+ * Both calls run through a moderator client rather than an admin client.
  * `list_content_types` is `security definer` behind a `canModerate` check, so
  * an anonymous or ordinary client sees nothing, and `list_report_reasons` is
- * `security invoker` and subject to RLS. Using a persona means what prints here
- * is what a moderator would actually see, rather than what a superuser can.
+ * `security invoker` and subject to RLS. Using a moderator means what prints
+ * here is what a moderator would actually see, rather than what a superuser
+ * can. `moderation.ts`'s `withTemporaryModerator` is what supplies that
+ * client — this module reads with it, it does not sign in on its own.
  */
-import { type Instance } from "./instance.js";
+import type { DevtoolsClient } from "./instance.js";
 export interface CatalogReason {
     reason: string;
     title: string;
@@ -43,7 +45,7 @@ export interface Catalog {
     reasons: CatalogReason[];
     contentTypes: CatalogContentType[];
 }
-export declare function readCatalog(instance: Instance): Promise<Catalog>;
+export declare function readCatalog(client: DevtoolsClient): Promise<Catalog>;
 /**
  * Formats the catalog for `note()`.
  *

package/dist/catalog.js

@@ -1,28 +1,4 @@
-/**
- * What can be reported on this instance, and for what reasons?
- *
- * Neither half of that question had an answer in the CLI before. `doctor` comes
- * closest, but it runs `conformance_check()` for a single app and reports
- * pass/fail per content type, a diagnostic rather than a listing, and it says
- * nothing about reasons at all.
- *
- * It matters more now than it used to, because both halves stopped being
- * editable at runtime. Content types are derived from each app's own schema and
- * report reasons are a platform-owned enum, so there is no configuration page
- * to open and look at. The database is the only source of truth, and this is
- * how a contributor reads it. `docs/platform/reporting-and-feedback.md` carries
- * a copy of the reason list for people who are not at a terminal, but that copy
- * is maintained by hand and says so. This is what settles a disagreement.
- *
- * Both calls run as the seeded moderator rather than through an admin client.
- * `list_content_types` is `security definer` behind a `canModerate` check, so
- * an anonymous or ordinary client sees nothing, and `list_report_reasons` is
- * `security invoker` and subject to RLS. Using a persona means what prints here
- * is what a moderator would actually see, rather than what a superuser can.
- */
-import { personaClient, PERSONAS } from "./instance.js";
-export async function readCatalog(instance) {
-    const client = await personaClient(instance, PERSONAS.moderator);
+export async function readCatalog(client) {
     const [reasons, contentTypes] = await Promise.all([
         client.rpc("list_report_reasons"),
         client.rpc("list_content_types"),

package/dist/cf/build.d.ts

@@ -0,0 +1,13 @@
+export declare function needsFrameworkBuild(app: string): boolean;
+/** Build only `app`'s workspace dependencies — all `vinext dev` needs, since
+ * it compiles the app itself on demand. */
+export declare function buildWorkspaceDeps(app: string): Promise<number>;
+/** The pnpm invocations `buildWorkerApp` runs, in order. */
+export declare function workerBuildCommands(app: string): string[][];
+/**
+ * Build `app` for a local `wrangler dev`. `env` applies to the framework
+ * build only — it bakes tier-scoped values (NEXT_PUBLIC_*, CLOUDFLARE_ENV)
+ * into the bundle; the dependency builds are tier-independent `tsc` runs.
+ * Resolves to the first non-zero exit code, or 0.
+ */
+export declare function buildWorkerApp(app: string, env?: NodeJS.ProcessEnv): Promise<number>;

package/dist/cf/build.js

@@ -0,0 +1,65 @@
+/**
+ * The build a Worker app needs before `wrangler dev` can boot it locally.
+ *
+ * The vinext apps' `wrangler.jsonc` is the PRE-build shape: `main` is
+ * `cloudflare/worker.ts`, which imports vinext's app-router entry and its
+ * `virtual:vinext-*` modules, and `assets.directory` is `dist/client`. Plain
+ * `wrangler dev` against that file can never work — esbuild cannot resolve
+ * Vite's virtual modules, and on a fresh clone `dist/client` does not exist
+ * yet ("The directory specified by the "assets.directory" field ... does not
+ * exist"). `vinext build` writes `dist/` plus the `.wrangler/deploy/
+ * config.json` redirect that points a bare `wrangler dev` at the built
+ * `dist/server/wrangler.json` instead.
+ *
+ * Building every time, rather than only when `dist/` is missing, also keeps
+ * a checkout from running a stale bundle — or one a previous `cf preview
+ * --tier staging` baked for another tier.
+ *
+ * `workflows run`/`serve` use `vinext dev` instead and need none of this
+ * except the dependency build (`buildWorkspaceDeps`).
+ *
+ * The app's workspace dependencies build first, the way `devtools run build`
+ * orders them (see `run/pick.ts`): their `exports` resolve to gitignored
+ * `dist/` output, so on a fresh clone `vinext build` fails to load
+ * `next.config.ts` without them.
+ */
+import { run } from "../db/run.js";
+/** Apps deployed without a framework build: Wrangler bundles `main` itself. */
+const NO_FRAMEWORK_BUILD = new Set(["sandbox"]);
+export function needsFrameworkBuild(app) {
+    return !NO_FRAMEWORK_BUILD.has(app);
+}
+function workspaceDepsBuildCommand(app) {
+    return ["-r", "--if-present", "--filter", `${app}^...`, "run", "build"];
+}
+/** Build only `app`'s workspace dependencies — all `vinext dev` needs, since
+ * it compiles the app itself on demand. */
+export function buildWorkspaceDeps(app) {
+    return run(workspaceDepsBuildCommand(app));
+}
+/** The pnpm invocations `buildWorkerApp` runs, in order. */
+export function workerBuildCommands(app) {
+    const commands = [workspaceDepsBuildCommand(app)];
+    if (needsFrameworkBuild(app)) {
+        commands.push(["--filter", app, "exec", "vinext", "build"]);
+    }
+    return commands;
+}
+/**
+ * Build `app` for a local `wrangler dev`. `env` applies to the framework
+ * build only — it bakes tier-scoped values (NEXT_PUBLIC_*, CLOUDFLARE_ENV)
+ * into the bundle; the dependency builds are tier-independent `tsc` runs.
+ * Resolves to the first non-zero exit code, or 0.
+ */
+export async function buildWorkerApp(app, env) {
+    const [, ...framework] = workerBuildCommands(app);
+    const depsCode = await buildWorkspaceDeps(app);
+    if (depsCode !== 0)
+        return depsCode;
+    for (const command of framework) {
+        const code = await run(command, env);
+        if (code !== 0)
+            return code;
+    }
+    return 0;
+}

package/dist/cf/commands.js

@@ -7,6 +7,7 @@
 import { confirm } from "@clack/prompts";
 import { loadEnvLoad } from "../repo/peers.js";
 import { run } from "../db/run.js";
+import { buildWorkerApp } from "./build.js";
 import { resolveTier } from "../tier.js";
 import { unwrap } from "../ui.js";
 import { isWorkerApp, workerApps } from "../workers.js";
@@ -88,19 +89,6 @@ export async function runCf(argv) {
                 throw err;
             }
         }
-        if (app === "sandbox") {
-            // No build step for the sandbox app: the tier only needs to reach
-            // Wrangler's materialized `--env-file`, below.
-            return withWranglerEnv(app, (envFile) => run([
-                "--filter",
-                app,
-                "exec",
-                "wrangler",
-                "dev",
-                "--env-file",
-                envFile,
-            ]), { env: loaded?.env });
-        }
         // The build bakes tier-scoped values (NEXT_PUBLIC_* and anything else
         // read at build time) into the bundle, exactly like `cf:build:<tier>`'s
         // `DEPLOY_ENV=<tier> with-env` does — so it gets both the tier's loaded
@@ -115,8 +103,10 @@ export async function runCf(argv) {
         // `CLOUDFLARE_ENV=<tier>` (see each app's `cf:build:<tier>` script) —
         // vinext bakes the target environment in at BUILD time, and `wrangler
         // dev` cross-checks it against `-e`/the env it resolves, erroring loudly
-        // on a mismatch rather than silently running the wrong tier.
-        const build = await run(["--filter", app, "exec", "vinext", "build"], tier && loaded
+        // on a mismatch rather than silently running the wrong tier. The sandbox
+        // app has no framework build; `buildWorkerApp` only builds its workspace
+        // dependencies.
+        const build = await buildWorkerApp(app, tier && loaded
             ? { ...loaded.env, DEPLOY_ENV: tier, CLOUDFLARE_ENV: tier }
             : undefined);
         if (build !== 0)
@@ -125,7 +115,7 @@ export async function runCf(argv) {
         // credential-bearing file exists, this prevents build-tool temp cleanup
         // from invalidating the path before Wrangler opens it.
         return withWranglerEnv(app, (envFile) => 
-        // `wrangler dev` auto-redirects to the just-built
+        // For a vinext app, `wrangler dev` auto-redirects to the just-built
         // `dist/server/wrangler.json` (a "config redirect" vinext writes to
         // `.wrangler/deploy/config.json`), so no `--config` flag is needed.
         // The bundle is already built above; invoke the project's Wrangler

package/dist/cf/local-env.d.ts

@@ -1,5 +1,19 @@
 import type { EnvEntry } from "@devdogsuga/env";
 export declare function renderWranglerEnvFile(keys: readonly string[], environment: NodeJS.ProcessEnv): string;
+/**
+ * The process env for a `vinext dev` child, scoped the way the temp
+ * `.dev.vars` is for `wrangler dev`.
+ *
+ * `@cloudflare/vite-plugin` has no `--env-file`: it reads the app dir's own
+ * `.dev.vars`/`.env`, or — with `CLOUDFLARE_INCLUDE_PROCESS_ENV` — its whole
+ * `process.env`, as Worker vars that override wrangler.jsonc's `vars`. So the
+ * scoping happens on the child's env instead: every key some OTHER app
+ * declares (and this app doesn't) is dropped, `NODE_ENV` is left to Vite, and
+ * `DEPLOY_ENV` is pinned to the tier rather than dropped, because the Vite
+ * process's own `next.config.ts` reads it too. Undeclared keys (PATH, HOME,
+ * pnpm's own) stay; the child needs them and they carry no app secrets.
+ */
+export declare function scopedProcessEnv(app: string, environment: NodeJS.ProcessEnv, tier: string, entries?: readonly EnvEntry[]): Promise<NodeJS.ProcessEnv>;
 /**
  * Runs `fn` with the path to an app-scoped, mode-0600 `.dev.vars` file, and
  * guarantees the file (and its containing directory) is gone before this

package/dist/cf/local-env.js

@@ -44,6 +44,35 @@ async function scopedKeys(app, entries) {
             .map((entry) => entry.key)),
     ].sort();
 }
+/**
+ * The process env for a `vinext dev` child, scoped the way the temp
+ * `.dev.vars` is for `wrangler dev`.
+ *
+ * `@cloudflare/vite-plugin` has no `--env-file`: it reads the app dir's own
+ * `.dev.vars`/`.env`, or — with `CLOUDFLARE_INCLUDE_PROCESS_ENV` — its whole
+ * `process.env`, as Worker vars that override wrangler.jsonc's `vars`. So the
+ * scoping happens on the child's env instead: every key some OTHER app
+ * declares (and this app doesn't) is dropped, `NODE_ENV` is left to Vite, and
+ * `DEPLOY_ENV` is pinned to the tier rather than dropped, because the Vite
+ * process's own `next.config.ts` reads it too. Undeclared keys (PATH, HOME,
+ * pnpm's own) stay; the child needs them and they carry no app secrets.
+ */
+export async function scopedProcessEnv(app, environment, tier, entries) {
+    if (!entries) {
+        await loadRegistry();
+        entries = (await loadEnv()).declarations();
+    }
+    const own = new Set(await scopedKeys(app, entries));
+    const scoped = { ...environment };
+    for (const entry of entries) {
+        if (entry.source !== app && !own.has(entry.key))
+            delete scoped[entry.key];
+    }
+    delete scoped.NODE_ENV;
+    scoped.DEPLOY_ENV = tier;
+    scoped.CLOUDFLARE_INCLUDE_PROCESS_ENV = "true";
+    return scoped;
+}
 /** Writes the mode-0600 `.dev.vars` into a fresh private temp directory. */
 function materializeEnvFile(keys, environment) {
     const directory = mkdtempSync(join(tmpdir(), "devtools-wrangler-env-"));

package/dist/ci.js

@@ -47,7 +47,7 @@ import { loadRegistry } from "./env/discovery.js";
 import { positionals } from "./args.js";
 import { findCiCommand, subcommandCiNames } from "./commands.js";
 import { isWorkerApp, workerApps } from "./workers.js";
-import { captureDevtoolsError, initDevtoolsTelemetry } from "./telemetry.js";
+import { captureDevtoolsError, initDevtoolsTelemetry, reportDevtoolsError, reportDevtoolsFailure, } from "./telemetry.js";
 function flagValue(rest, flag) {
     const index = rest.indexOf(flag);
     if (index === -1)
@@ -189,6 +189,10 @@ async function runAppDeploy(app, rest) {
     for (const step of steps) {
         const code = await step.fn();
         if (code !== 0) {
+            // A step is a subprocess (`pnpm … wrangler deploy`) whose output
+            // already explains itself in the job log; this is only the signal that
+            // a deploy broke, grouped per app and step.
+            reportDevtoolsFailure(`devtools-ci deploy ${app}: "${step.label}" failed`, { tier, exitCode: code });
             process.exitCode = code;
             return;
         }
@@ -271,6 +275,9 @@ async function runDeployCommand(rest) {
             : [
                 `devtools-ci deploy ${sub}: ${err instanceof Error ? err.message : String(err)}`,
             ]);
+        // Caught here, so `launch-ci.ts`'s capture never sees it. Every deploy
+        // step runs in CI, where a failure is never the reader's typo to fix.
+        reportDevtoolsError(err);
         process.exitCode = 1;
     }
 }