@smoothbricks/cli 0.10.2 → 0.10.4

package/src/release/orchestration.ts

@@ -30,14 +30,24 @@ export interface ReleaseNextShell<Package extends ReleasePackageInfo = ReleasePa
   bumpStablePackagesToNext(packages: Package[]): Promise<void>;
 }
 
-export interface ReleaseRepairShell<Package extends ReleasePackageInfo = ReleasePackageInfo>
-  extends ReleaseCompletionShell<Package> {
+export interface ReleaseTargetCheckoutShell<Package extends ReleasePackageInfo = ReleasePackageInfo> {
   checkout(ref: string): Promise<void>;
   withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T>;
   beforeRepairTarget?(target: ReleaseTarget<Package>): void;
   afterRepairTarget?(target: ReleaseTarget<Package>): void;
 }
 
+export interface ReleaseRepairShell<Package extends ReleasePackageInfo = ReleasePackageInfo>
+  extends ReleaseCompletionShell<Package>,
+    ReleaseTargetCheckoutShell<Package> {
+  prepareRepairTarget?(target: ReleaseTarget<Package>): Promise<void>;
+}
+
+export interface ReleaseRepairOutputsShell<Package extends ReleasePackageInfo = ReleasePackageInfo>
+  extends ReleaseTargetCheckoutShell<Package> {
+  collectRepairTargetOutputs(target: ReleaseTarget<Package>): Promise<void>;
+}
+
 export interface ReleaseVersionShell<Package extends ReleasePackageInfo = ReleasePackageInfo> {
   releasePackagesAtHead(): Promise<Package[]>;
   releaseVersionPackages(bump: string): Promise<Package[]>;
@@ -151,17 +161,59 @@ export async function repairPendingTargets<Package extends ReleasePackageInfo>(
       }
       shell.beforeRepairTarget?.(target);
       try {
-        summaries.push(await shell.withDevenvEnv(() => completeRepairTargetAtHead(shell, target, dryRun)));
+        summaries.push(
+          await shell.withDevenvEnv(async () => {
+            await shell.prepareRepairTarget?.(target);
+            return completeRepairTargetAtHead(shell, target, dryRun);
+          }),
+        );
       } finally {
         shell.afterRepairTarget?.(target);
       }
     }
   } finally {
     await shell.checkout(restoreRef);
+    if (targets.length > 0) {
+      // Loading devenv at a historical release can rebuild ignored tool outputs
+      // from that checkout. Refresh after restoring HEAD so later release phases
+      // cannot combine the current CLI with an older Nx plugin build.
+      await shell.withDevenvEnv(async () => undefined);
+    }
   }
   return summaries;
 }
 
+export async function collectRepairPlatformOutputs<Package extends ReleasePackageInfo>(
+  shell: ReleaseRepairOutputsShell<Package>,
+  targets: Array<ReleaseTarget<Package>>,
+  restoreRef: string,
+): Promise<void> {
+  const outputTargets = targets.filter((target) => target.npmPackages.length > 0);
+  if (outputTargets.length === 0) {
+    return;
+  }
+  try {
+    for (const target of outputTargets) {
+      await shell.checkout(target.sha);
+      if (target.packages.length === 0) {
+        // invariant throw: release target discovery must never yield a package-free target.
+        throw new Error(`Release commit ${target.sha} has no release packages after checkout.`);
+      }
+      shell.beforeRepairTarget?.(target);
+      try {
+        await shell.withDevenvEnv(() => shell.collectRepairTargetOutputs(target));
+      } finally {
+        shell.afterRepairTarget?.(target);
+      }
+    }
+  } finally {
+    await shell.checkout(restoreRef);
+    // Historical devenv activation may rebuild ignored tool outputs. Restore the
+    // dispatch environment before the macOS job performs any further work.
+    await shell.withDevenvEnv(async () => undefined);
+  }
+}
+
 function repairDryRunSummary<Package extends ReleasePackageInfo>(
   target: ReleaseTarget<Package>,
 ): ReleaseSummary<Package> {

package/src/wrangler/prepare-env.ts

@@ -20,13 +20,50 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { $ } from 'bun';
 import { type AST, getStaticTOMLValue, parseTOML } from 'toml-eslint-parser';
+import typia from 'typia';
 
-// ── runtime narrowing (wrangler JSON is external data — no casts) ─────────────
+// ── runtime narrowing (wrangler TOML/JSON is external data — no casts) ───────
 
-export function isRecord(v: unknown): v is Record<string, unknown> {
-  return typeof v === 'object' && v !== null && !Array.isArray(v);
+interface WranglerTomlRoot {
+  env?: Record<string, WranglerEnvBlock | undefined>;
 }
 
+interface WranglerEnvBlock {
+  vars?: Record<string, unknown>;
+  kv_namespaces?: WranglerKvRow[];
+  d1_databases?: WranglerD1Row[];
+  [key: string]: unknown;
+}
+
+interface WranglerKvRow {
+  binding?: string;
+  id?: string;
+}
+
+interface WranglerD1Row {
+  binding?: string;
+  database_id?: string;
+  database_name?: string;
+}
+
+interface WranglerSecretRow {
+  name?: string;
+}
+
+interface ShellErrorShape {
+  stderr?: unknown;
+  exitCode?: unknown;
+}
+
+const isWranglerTomlRoot = typia.createIs<WranglerTomlRoot>();
+const isWranglerEnvBlock = typia.createIs<WranglerEnvBlock>();
+const isWranglerKvRow = typia.createIs<WranglerKvRow>();
+const isWranglerD1Row = typia.createIs<WranglerD1Row>();
+const isWranglerSecretRow = typia.createIs<WranglerSecretRow>();
+const isKvNamespaceRow = typia.createIs<{ id: string; title: string }>();
+const isD1DatabaseRow = typia.createIs<{ uuid: string; name: string }>();
+const isShellErrorShape = typia.createIs<ShellErrorShape>();
+
 // ── wrangler.toml editors (CST: read via getStaticTOMLValue, write via
 // node-range splice — comment/format-preserving by construction, no regex) ─────
 
@@ -36,15 +73,14 @@ function tables(toml: string): AST.TOMLTable[] {
 }
 
 /** Whole doc as a JS object (comments/format dropped — reads only). */
-function tomlValue(toml: string): Record<string, unknown> {
-  const value = getStaticTOMLValue(parseTOML(toml));
-  return isRecord(value) ? value : {};
+function tomlValue(toml: string): WranglerTomlRoot {
+  const value: unknown = getStaticTOMLValue(parseTOML(toml));
+  return isWranglerTomlRoot(value) ? value : {};
 }
 
-function envRecord(toml: string, env: string): Record<string, unknown> | null {
-  const envs = tomlValue(toml).env;
-  const block = isRecord(envs) ? envs[env] : undefined;
-  return isRecord(block) ? block : null;
+function envRecord(toml: string, env: string): WranglerEnvBlock | null {
+  const block = tomlValue(toml).env?.[env];
+  return isWranglerEnvBlock(block) ? block : null;
 }
 
 function sameKey(a: (string | number)[], b: (string | number)[]): boolean {
@@ -68,8 +104,13 @@ function arrayTableKv(
   field: string,
 ): AST.TOMLKeyValue | null {
   const block = envRecord(toml, env);
-  const rows = isRecord(block) && Array.isArray(block[arrayKey]) ? block[arrayKey] : [];
-  const index = rows.findIndex((r) => isRecord(r) && r.binding === binding);
+  const rows = Array.isArray(block?.[arrayKey]) ? block[arrayKey] : [];
+  const index = rows.findIndex((row) => {
+    if (arrayKey === 'd1_databases') {
+      return isWranglerD1Row(row) && row.binding === binding;
+    }
+    return isWranglerKvRow(row) && row.binding === binding;
+  });
   if (index < 0) return null;
   const table = tables(toml).find((t) => t.kind === 'array' && sameKey(t.resolvedKey, ['env', env, arrayKey, index]));
   return table ? kvIn(toml, table, field) : null;
@@ -88,7 +129,7 @@ function endOfLine(toml: string, offset: number): number {
 /** First `[env.<name>]` (source order; also derived from a nested `[env.<name>.*]`), or null when no env declared. */
 export function firstWranglerEnv(toml: string): string | null {
   const envs = tomlValue(toml).env;
-  if (!isRecord(envs)) return null;
+  if (!envs) return null;
   const [first] = Object.keys(envs);
   return first ?? null;
 }
@@ -96,14 +137,12 @@ export function firstWranglerEnv(toml: string): string | null {
 /** True if the toml declares `[env.<env>]` (or any `[env.<env>.*]` sub-table). */
 export function hasEnvBlock(toml: string, env: string): boolean {
   const envs = tomlValue(toml).env;
-  return isRecord(envs) && env in envs;
+  return !!envs && env in envs;
 }
 
 /** A `[env.<env>.vars]` value, or null if unset/empty. Reads committed public config. */
 export function getVar(toml: string, env: string, name: string): string | null {
-  const block = envRecord(toml, env);
-  const vars = isRecord(block?.vars) ? block.vars : {};
-  const value = vars[name];
+  const value = envRecord(toml, env)?.vars?.[name];
   return typeof value === 'string' && value ? value : null;
 }
 
@@ -117,10 +156,8 @@ export function setVar(toml: string, env: string, name: string, value: string):
 
 /** The id written for `[[env.<env>.kv_namespaces]]` binding, or null if absent/empty. */
 export function getKvId(toml: string, env: string, binding: string): string | null {
-  const block = envRecord(toml, env);
-  const rows = isRecord(block) && Array.isArray(block.kv_namespaces) ? block.kv_namespaces : [];
-  for (const row of rows) {
-    if (isRecord(row) && row.binding === binding && typeof row.id === 'string') return row.id || null;
+  for (const row of envRecord(toml, env)?.kv_namespaces ?? []) {
+    if (row.binding === binding && typeof row.id === 'string') return row.id || null;
   }
   return null;
 }
@@ -166,21 +203,16 @@ export function blankKvIds(toml: string, env: string): string {
 
 /** The database_id written for `[[env.<env>.d1_databases]]` binding, or null if absent/empty. */
 export function getD1Id(toml: string, env: string, binding: string): string | null {
-  const block = envRecord(toml, env);
-  const rows = isRecord(block) && Array.isArray(block.d1_databases) ? block.d1_databases : [];
-  for (const row of rows) {
-    if (isRecord(row) && row.binding === binding && typeof row.database_id === 'string') return row.database_id || null;
+  for (const row of envRecord(toml, env)?.d1_databases ?? []) {
+    if (row.binding === binding && typeof row.database_id === 'string') return row.database_id || null;
   }
   return null;
 }
 
 /** The `database_name` for `[[env.<env>.d1_databases]]` binding, or null. Source of truth for which DB to create/reuse. */
 export function getD1Name(toml: string, env: string, binding: string): string | null {
-  const block = envRecord(toml, env);
-  const rows = isRecord(block) && Array.isArray(block.d1_databases) ? block.d1_databases : [];
-  for (const row of rows) {
-    if (isRecord(row) && row.binding === binding && typeof row.database_name === 'string')
-      return row.database_name || null;
+  for (const row of envRecord(toml, env)?.d1_databases ?? []) {
+    if (row.binding === binding && typeof row.database_name === 'string') return row.database_name || null;
   }
   return null;
 }
@@ -260,12 +292,13 @@ export function parseDevVarsExample(text: string): string[] {
 export function readManifest(root: string, env: string): Manifest {
   const toml = readFileSync(join(root, 'wrangler.toml'), 'utf8');
   const block = envRecord(toml, env);
-  const varsRec = isRecord(block?.vars) ? block.vars : {};
-  const vars = Object.keys(varsRec);
-  const kvRows = isRecord(block) && Array.isArray(block.kv_namespaces) ? block.kv_namespaces : [];
-  const kvBindings = kvRows.flatMap((row) => (isRecord(row) && typeof row.binding === 'string' ? [row.binding] : []));
-  const d1Rows = isRecord(block) && Array.isArray(block.d1_databases) ? block.d1_databases : [];
-  const d1Bindings = d1Rows.flatMap((row) => (isRecord(row) && typeof row.binding === 'string' ? [row.binding] : []));
+  const vars = Object.keys(block?.vars ?? {});
+  const kvBindings = (block?.kv_namespaces ?? []).flatMap((row) =>
+    typeof row.binding === 'string' ? [row.binding] : [],
+  );
+  const d1Bindings = (block?.d1_databases ?? []).flatMap((row) =>
+    typeof row.binding === 'string' ? [row.binding] : [],
+  );
   const examplePath = join(root, '.dev.vars.example');
   const secrets = existsSync(examplePath) ? parseDevVarsExample(readFileSync(examplePath, 'utf8')) : [];
   return { kvBindings, d1Bindings, vars, secrets };
@@ -300,25 +333,19 @@ export interface KvNamespace {
 
 function asKvNamespaces(json: unknown): KvNamespace[] {
   if (!Array.isArray(json)) return [];
-  const out: KvNamespace[] = [];
-  for (const row of json) {
-    if (isRecord(row) && typeof row.id === 'string' && typeof row.title === 'string') {
-      out.push({ id: row.id, title: row.title });
-    }
-  }
-  return out;
+  return json.filter(isKvNamespaceRow);
 }
 
 function asSecretNames(json: unknown): string[] {
   if (!Array.isArray(json)) return [];
-  return json.flatMap((row) => (isRecord(row) && typeof row.name === 'string' ? [row.name] : []));
+  return json.flatMap((row) => (isWranglerSecretRow(row) && typeof row.name === 'string' ? [row.name] : []));
 }
 
 /** Best-effort ERROR line from a Bun ShellError (thrown on non-zero exit). */
 export function errText(err: unknown): string {
-  if (!isRecord(err)) return 'unknown error';
-  const stderr = 'stderr' in err && err.stderr != null ? String(err.stderr) : '';
-  const exit = 'exitCode' in err ? String(err.exitCode) : '?';
+  if (!isShellErrorShape(err)) return 'unknown error';
+  const stderr = err.stderr != null ? String(err.stderr) : '';
+  const exit = err.exitCode != null ? String(err.exitCode) : '?';
   return stderr.split('\n').find((l) => l.includes('ERROR')) ?? `exit ${exit}`;
 }
 
@@ -358,13 +385,7 @@ export interface D1Database {
 
 function asD1Databases(json: unknown): D1Database[] {
   if (!Array.isArray(json)) return [];
-  const out: D1Database[] = [];
-  for (const row of json) {
-    if (isRecord(row) && typeof row.uuid === 'string' && typeof row.name === 'string') {
-      out.push({ uuid: row.uuid, name: row.name });
-    }
-  }
-  return out;
+  return json.filter(isD1DatabaseRow);
 }
 
 /** Live D1 databases on the account (`d1 list --json`); `[]` when offline/unauthenticated. */

package/src/wrangler/scaffold.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it, spyOn } from 'bun:test';
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { type PackageJson, parsePackageJsonText } from '../lib/json.js';
 import { scaffold } from './scaffold.js';
 
 describe('scaffold', () => {
@@ -164,27 +165,23 @@ async function createWorkspace(
   return root;
 }
 
-function nxTargets(pkg: Record<string, unknown>): Record<string, unknown> {
-  const nx = pkg.nx;
-  if (!isRecord(nx) || !isRecord(nx.targets)) {
+function nxTargets(pkg: PackageJson): NonNullable<NonNullable<PackageJson['nx']>['targets']> {
+  const targets = pkg.nx?.targets;
+  if (!targets) {
     throw new Error('nx.targets not found');
   }
-  return nx.targets;
+  return targets;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-async function readJson(path: string): Promise<Record<string, unknown>> {
-  const parsed: unknown = JSON.parse(await readFile(path, 'utf8'));
-  if (!isRecord(parsed)) {
+async function readJson(path: string): Promise<PackageJson> {
+  const parsed = parsePackageJsonText(await readFile(path, 'utf8'));
+  if (!parsed) {
     throw new Error('expected JSON object');
   }
   return parsed;
 }
 
-async function writeJson(path: string, value: Record<string, unknown>): Promise<void> {
+async function writeJson(path: string, value: PackageJson): Promise<void> {
   await mkdir(join(path, '..'), { recursive: true });
   await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
 }

package/src/wrangler/scaffold.ts

@@ -6,8 +6,8 @@
  * .dev.vars.example), so it never drifts from what the worker declares.
  */
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { getOrCreateRecord, recordProperty, writeJsonObject } from '../lib/json.js';
+import { join } from 'node:path';
+import { ensureNx, ensureNxTargets, type NxTargetConfig, type PackageJson, writeJsonObject } from '../lib/json.js';
 import { getWorkspacePackageManifests } from '../lib/workspace.js';
 
 export interface ScaffoldOptions {
@@ -19,22 +19,21 @@ export interface ScaffoldOptions {
 function resolveProject(
   root: string,
   project: string,
-): { dir: string; label: string; packageJsonPath: string; json: Record<string, unknown> } {
+): { dir: string; label: string; packageJsonPath: string; json: PackageJson } {
   const manifests = getWorkspacePackageManifests(root);
   const match = manifests.find((m) => {
-    const nx = recordProperty(m.json, 'nx');
-    const nxName = nx && typeof nx.name === 'string' ? nx.name : null;
-    return nxName === project || m.name === project || relative(root, m.path) === project;
+    const nxName = m.json.nx?.name;
+    return nxName === project || m.name === project || m.path === project;
   });
   if (!match) {
-    const known = manifests.map((m) => recordProperty(m.json, 'nx')?.name ?? m.name).join(', ');
+    const known = manifests.map((m) => m.json.nx?.name ?? m.name).join(', ');
     throw new Error(`project "${project}" not found. Known: ${known}`);
   }
-  const dir = match.path; // WorkspacePackageManifest.path is absolute
+  const dir = join(root, match.path);
   if (!existsSync(join(dir, 'wrangler.toml'))) {
     throw new Error(`"${project}" has no wrangler.toml — not a wrangler project`);
   }
-  return { dir, label: relative(root, dir), packageJsonPath: match.packageJsonPath, json: match.json };
+  return { dir, label: match.path, packageJsonPath: match.packageJsonPath, json: match.json };
 }
 
 /** The generated starter script — generic, manifest-driven, prompt-batteries included. */
@@ -226,13 +225,14 @@ export function scaffold(root: string, project: string, options: ScaffoldOptions
   console.log(`${existed ? 'overwrote' : 'created'}      ${label}/scripts/prepare-env.ts`);
 
   // Wire the nx target (idempotent).
-  const nx = getOrCreateRecord(json, 'nx');
-  const targets = getOrCreateRecord(nx, 'targets');
-  if (!recordProperty(targets, 'prepare-env')) {
-    targets['prepare-env'] = {
+  const nx = ensureNx(json);
+  const targets = ensureNxTargets(nx);
+  if (!targets['prepare-env']) {
+    const prepareEnvTarget: NxTargetConfig = {
       executor: 'nx:run-commands',
       options: { command: 'bun scripts/prepare-env.ts', cwd: '{projectRoot}' },
     };
+    targets['prepare-env'] = prepareEnvTarget;
     writeJsonObject(packageJsonPath, json);
     console.log(`updated       ${label}/package.json prepare-env target`);
   }