@smoothbricks/cli 0.1.0

package/src/monorepo/managed-files.ts

@@ -0,0 +1,153 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readPackageJson } from '../lib/workspace.js';
+
+type ManagedKind = 'raw' | 'template';
+
+interface ManagedFile {
+  kind: ManagedKind;
+  source: string;
+  target: string;
+  executable?: boolean;
+}
+
+export interface FileResult {
+  target: string;
+  action: 'created' | 'updated' | 'unchanged' | 'skipped-symlink' | 'drifted' | 'ok-symlink';
+}
+
+const managedFiles: ManagedFile[] = [
+  {
+    kind: 'raw',
+    source: 'tooling/direnv/github-actions-bootstrap.sh',
+    target: 'tooling/direnv/github-actions-bootstrap.sh',
+    executable: true,
+  },
+  {
+    kind: 'raw',
+    source: 'tooling/git-hooks/pre-commit.sh',
+    target: 'tooling/git-hooks/pre-commit.sh',
+    executable: true,
+  },
+  {
+    kind: 'raw',
+    source: 'tooling/git-hooks/commit-msg.sh',
+    target: 'tooling/git-hooks/commit-msg.sh',
+    executable: true,
+  },
+  {
+    kind: 'raw',
+    source: '.git-format-staged.yml',
+    target: '.git-format-staged.yml',
+  },
+  {
+    kind: 'template',
+    source: 'github/workflows/ci.yml',
+    target: '.github/workflows/ci.yml',
+  },
+  {
+    kind: 'template',
+    source: 'github/workflows/publish.yml',
+    target: '.github/workflows/publish.yml',
+  },
+  {
+    kind: 'template',
+    source: 'github/actions/cache-nix-devenv/action.yml',
+    target: '.github/actions/cache-nix-devenv/action.yml',
+  },
+  {
+    kind: 'template',
+    source: 'github/actions/setup-devenv/action.yml',
+    target: '.github/actions/setup-devenv/action.yml',
+  },
+  {
+    kind: 'template',
+    source: 'github/actions/save-nix-devenv/action.yml',
+    target: '.github/actions/save-nix-devenv/action.yml',
+  },
+  {
+    kind: 'template',
+    source: 'github/actions/cache-node-modules/action.yml',
+    target: '.github/actions/cache-node-modules/action.yml',
+  },
+  {
+    kind: 'template',
+    source: 'github/actions/cache-nx/action.yml',
+    target: '.github/actions/cache-nx/action.yml',
+  },
+];
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+export function applyManagedFiles(root: string, mode: 'update' | 'check' | 'diff'): FileResult[] {
+  return managedFiles.map((file) => applyManagedFile(root, file, mode));
+}
+
+function applyManagedFile(root: string, file: ManagedFile, mode: 'update' | 'check' | 'diff'): FileResult {
+  const target = resolve(root, file.target);
+  const content = getManagedContent(root, file);
+  if (existsSync(target)) {
+    const info = lstatSync(target);
+    if (info.isSymbolicLink()) {
+      return { target: file.target, action: mode === 'check' ? 'ok-symlink' : 'skipped-symlink' };
+    }
+    if (!info.isFile()) {
+      throw new Error(`${file.target} exists but is not a regular file or symlink`);
+    }
+    const current = readFileSync(target, 'utf8');
+    if (current === content) {
+      return { target: file.target, action: 'unchanged' };
+    }
+    if (mode === 'check' || mode === 'diff') {
+      return { target: file.target, action: 'drifted' };
+    }
+    writeManagedFile(target, content, file.executable === true);
+    return { target: file.target, action: 'updated' };
+  }
+  if (mode === 'check' || mode === 'diff') {
+    return { target: file.target, action: 'drifted' };
+  }
+  writeManagedFile(target, content, file.executable === true);
+  return { target: file.target, action: 'created' };
+}
+
+function getManagedContent(root: string, file: ManagedFile): string {
+  const sourceRoot = file.kind === 'raw' ? 'managed/raw' : 'managed/templates';
+  const sourcePath = join(packageRoot, sourceRoot, file.source);
+  const content = readFileSync(sourcePath, 'utf8');
+  if (file.kind === 'raw') {
+    return content;
+  }
+  return renderTemplate(root, content);
+}
+
+function renderTemplate(root: string, template: string): string {
+  const packageJson = readPackageJson(join(root, 'package.json'));
+  const repoName = packageJson?.name ?? 'monorepo';
+  const nodeModulesCacheKey = existsSync(join(root, 'bun.lock'))
+    ? `$${"{{ hashFiles('bun.lock', 'package.json', 'packages/*/package.json') }}"}`
+    : `$${"{{ hashFiles('bun.lockb', 'package.json', 'packages/*/package.json') }}"}`;
+  return template.replaceAll('{{REPO_NAME}}', repoName).replaceAll('{{NODE_MODULES_CACHE_KEY}}', nodeModulesCacheKey);
+}
+
+function writeManagedFile(path: string, content: string, executable: boolean): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, { mode: executable ? 0o755 : 0o644 });
+}
+
+export function printResults(results: FileResult[]): void {
+  for (const result of results) {
+    console.log(`${result.action.padEnd(15)} ${result.target}`);
+  }
+}
+
+export function validateManagedFiles(root: string): number {
+  const results = applyManagedFiles(root, 'check');
+  printResults(results);
+  const failures = results.filter((result) => result.action === 'drifted').length;
+  if (failures > 0) {
+    console.error('Managed monorepo files are out of date. Run: smoo monorepo update');
+  }
+  return failures;
+}

package/src/monorepo/nx-sync.ts

@@ -0,0 +1,6 @@
+import { runStatus } from '../lib/run.js';
+
+export async function validateNxSync(root: string): Promise<number> {
+  const status = await runStatus('nx', ['sync:check'], root);
+  return status === 0 ? 0 : 1;
+}

package/src/monorepo/package-hygiene.ts

@@ -0,0 +1,14 @@
+import { run, runStatus } from '../lib/run.js';
+
+export async function fixPackageHygiene(root: string): Promise<void> {
+  await run('sherif', ['--fix', '--select', 'highest'], root);
+}
+
+export async function validatePackageHygiene(root: string): Promise<number> {
+  const status = await runStatus('sherif', [], root);
+  if (status !== 0) {
+    console.error('sherif package hygiene validation failed');
+    return 1;
+  }
+  return 0;
+}

package/src/monorepo/package-policy.ts

@@ -0,0 +1,307 @@
+import { join } from 'node:path';
+import {
+  getOrCreateRecord,
+  hasOwnString,
+  isRecord,
+  readJsonObject,
+  recordProperty,
+  requiredJsonObject,
+  setMissingStringProperty,
+  setStringProperty,
+  stringProperty,
+  writeJsonObject,
+} from '../lib/json.js';
+import {
+  getWorkspacePackages,
+  listPackageJsonRecords,
+  listPublicPackages,
+  repositoryInfo,
+  workspaceDependencyFields,
+} from '../lib/workspace.js';
+
+export function applyPublicPackageDefaults(root: string): void {
+  const rootPackage = requiredJsonObject(join(root, 'package.json'));
+  const rootLicense = stringProperty(rootPackage, 'license');
+  const rootRepository = repositoryInfo(rootPackage);
+  if (!rootLicense) {
+    throw new Error('Root package.json must define license before public package defaults can be applied.');
+  }
+  if (!rootRepository) {
+    throw new Error('Root package.json must define repository.url before public package defaults can be applied.');
+  }
+
+  for (const pkg of listPublicPackages(root)) {
+    let changed = false;
+    changed = setMissingStringProperty(pkg.json, 'license', rootLicense) || changed;
+    const publishConfig = getOrCreateRecord(pkg.json, 'publishConfig');
+    changed = setStringProperty(publishConfig, 'access', 'public') || changed;
+
+    const repository = getOrCreateRecord(pkg.json, 'repository');
+    changed = setStringProperty(repository, 'type', rootRepository.type) || changed;
+    changed = setStringProperty(repository, 'url', rootRepository.url) || changed;
+    changed = setStringProperty(repository, 'directory', pkg.path.replaceAll('\\', '/')) || changed;
+    changed = normalizeExportConditionOrder(pkg.json.exports) || changed;
+    if (hasDevelopmentSourceExport(pkg.json.exports)) {
+      changed = addFileEntry(pkg.json, 'src') || changed;
+    }
+
+    if (changed) {
+      writeJsonObject(pkg.packageJsonPath, pkg.json);
+      console.log(`updated        ${pkg.path}/package.json public metadata`);
+    } else {
+      console.log(`unchanged      ${pkg.path}/package.json public metadata`);
+    }
+  }
+}
+
+export function applyWorkspaceDependencyDefaults(root: string): void {
+  const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
+  for (const pkg of listPackageJsonRecords(root)) {
+    const changed = fixWorkspaceDependencyRanges(pkg.json, workspaceNames);
+    if (changed) {
+      writeJsonObject(pkg.packageJsonPath, pkg.json);
+      console.log(`updated        ${pkg.path}/package.json workspace dependency ranges`);
+    } else {
+      console.log(`unchanged      ${pkg.path}/package.json workspace dependency ranges`);
+    }
+  }
+}
+
+export function validateRootPackagePolicy(root: string): number {
+  const rootPackage = readJsonObject(join(root, 'package.json'));
+  if (!rootPackage) {
+    console.error('package.json not found or invalid');
+    return 1;
+  }
+  let failures = 0;
+  if (!stringProperty(rootPackage, 'name')) {
+    console.error('package.json must define name');
+    failures++;
+  }
+  if (!stringProperty(rootPackage, 'license')) {
+    console.error('package.json must define repo-wide license');
+    failures++;
+  }
+  if (!repositoryInfo(rootPackage)) {
+    console.error('package.json must define repository.url');
+    failures++;
+  }
+  const packageManager = stringProperty(rootPackage, 'packageManager');
+  if (!packageManager?.startsWith('bun@')) {
+    console.error('package.json packageManager must use bun@<version>');
+    failures++;
+  }
+  const bunVersion = packageManager?.startsWith('bun@') ? packageManager.slice('bun@'.length) : null;
+  const devDependencies = recordProperty(rootPackage, 'devDependencies');
+  if (!bunVersion || !devDependencies || devDependencies['@types/bun'] !== bunVersion) {
+    console.error('package.json devDependencies.@types/bun must match packageManager bun version');
+    failures++;
+  }
+  const engines = recordProperty(rootPackage, 'engines');
+  if (!engines || !stringProperty(engines, 'node')) {
+    console.error('package.json engines.node must be defined');
+    failures++;
+  }
+  return failures;
+}
+
+export function validateNxReleaseConfig(root: string): number {
+  const nxJson = readJsonObject(join(root, 'nx.json'));
+  if (!nxJson) {
+    console.error('nx.json not found or invalid');
+    return 1;
+  }
+  const release = recordProperty(nxJson, 'release');
+  const version = release ? recordProperty(release, 'version') : null;
+  let failures = 0;
+  if (!release) {
+    console.error('nx.json release config is missing');
+    failures++;
+  }
+  if (release && stringProperty(release, 'projectsRelationship') !== 'independent') {
+    console.error('nx.json release.projectsRelationship must be independent');
+    failures++;
+  }
+  if (!version) {
+    console.error('nx.json release.version config is missing');
+    failures++;
+  }
+  if (version && stringProperty(version, 'specifierSource') !== 'conventional-commits') {
+    console.error('nx.json release.version.specifierSource must be conventional-commits');
+    failures++;
+  }
+  // Nx requires git-tag as the primary resolver when deriving versions from
+  // conventional commits. Disk is only a fallback for initial untagged packages.
+  if (version && stringProperty(version, 'currentVersionResolver') !== 'git-tag') {
+    console.error('nx.json release.version.currentVersionResolver must be git-tag');
+    failures++;
+  }
+  if (version && stringProperty(version, 'fallbackCurrentVersionResolver') !== 'disk') {
+    console.error('nx.json release.version.fallbackCurrentVersionResolver must be disk');
+    failures++;
+  }
+  if (version && !stringProperty(version, 'preVersionCommand')) {
+    console.error('nx.json release.version.preVersionCommand must be defined');
+    failures++;
+  }
+  return failures;
+}
+
+export function validatePublicTags(root: string): number {
+  let failures = 0;
+  for (const pkg of getWorkspacePackages(root)) {
+    const hasPublicTag = pkg.tags.includes('npm:public');
+    if (pkg.private && hasPublicTag) {
+      console.error(`${pkg.path}: private package must not have nx tag npm:public`);
+      failures++;
+    }
+    if (!pkg.private && !hasPublicTag) {
+      console.error(`${pkg.path}: public package must have nx tag npm:public`);
+      failures++;
+    }
+  }
+  if (failures > 0) {
+    return failures;
+  }
+  console.log('npm:public tags are valid.');
+  return 0;
+}
+
+export function validatePublicPackageMetadata(root: string): number {
+  const rootPackage = readJsonObject(join(root, 'package.json'));
+  const rootRepository = rootPackage ? repositoryInfo(rootPackage) : null;
+  let failures = 0;
+  for (const pkg of listPublicPackages(root)) {
+    if (!stringProperty(pkg.json, 'license')) {
+      console.error(`${pkg.path}: public package must define license`);
+      failures++;
+    }
+    const publishConfig = recordProperty(pkg.json, 'publishConfig');
+    if (!publishConfig || stringProperty(publishConfig, 'access') !== 'public') {
+      console.error(`${pkg.path}: public package must define publishConfig.access = public`);
+      failures++;
+    }
+    const repository = recordProperty(pkg.json, 'repository');
+    const packageRepository = repository ? repositoryInfo(pkg.json) : null;
+    if (!rootRepository || !packageRepository || packageRepository.url !== rootRepository.url) {
+      console.error(`${pkg.path}: public package repository.url must match root package.json repository.url`);
+      failures++;
+    }
+    if (!repository || stringProperty(repository, 'directory') !== pkg.path.replaceAll('\\', '/')) {
+      console.error(`${pkg.path}: public package repository.directory must be ${pkg.path.replaceAll('\\', '/')}`);
+      failures++;
+    }
+    if (!Array.isArray(pkg.json.files)) {
+      console.error(`${pkg.path}: public package must define files`);
+      failures++;
+    }
+    if (!isRecord(pkg.json.exports) && !isRecord(pkg.json.bin)) {
+      console.error(`${pkg.path}: public package must define exports or bin`);
+      failures++;
+    }
+    if (!hasOwnString(pkg.json, 'types') && !isRecord(pkg.json.bin)) {
+      console.error(`${pkg.path}: public library package must define types`);
+      failures++;
+    }
+  }
+  return failures;
+}
+
+export function validateWorkspaceDependencies(root: string): number {
+  const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
+  let failures = 0;
+  for (const pkg of listPackageJsonRecords(root)) {
+    for (const field of workspaceDependencyFields) {
+      const dependencies = recordProperty(pkg.json, field);
+      if (!dependencies) {
+        continue;
+      }
+      for (const [name, range] of Object.entries(dependencies)) {
+        if (workspaceNames.has(name) && range !== 'workspace:*') {
+          console.error(`${pkg.path}: ${field}.${name} must use workspace:*`);
+          failures++;
+        }
+      }
+    }
+  }
+  if (failures === 0) {
+    console.log('Workspace dependency ranges are valid.');
+  }
+  return failures;
+}
+
+function fixWorkspaceDependencyRanges(pkg: Record<string, unknown>, workspaceNames: Set<string>): boolean {
+  let changed = false;
+  for (const field of workspaceDependencyFields) {
+    const dependencies = recordProperty(pkg, field);
+    if (!dependencies) {
+      continue;
+    }
+    for (const name of Object.keys(dependencies)) {
+      if (workspaceNames.has(name) && dependencies[name] !== 'workspace:*') {
+        dependencies[name] = 'workspace:*';
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+
+function normalizeExportConditionOrder(value: unknown): boolean {
+  if (!isRecord(value)) {
+    return false;
+  }
+  let changed = false;
+  for (const child of Object.values(value)) {
+    changed = normalizeExportConditionOrder(child) || changed;
+  }
+  const keys = Object.keys(value);
+  if (!keys.includes('types') && !keys.includes('default')) {
+    return changed;
+  }
+  const ordered = [
+    ...(keys.includes('types') ? ['types'] : []),
+    ...keys.filter((key) => key !== 'types' && key !== 'default'),
+    ...(keys.includes('default') ? ['default'] : []),
+  ];
+  if (keys.join('\n') === ordered.join('\n')) {
+    return changed;
+  }
+  const entries = new Map(keys.map((key) => [key, value[key]]));
+  for (const key of keys) {
+    delete value[key];
+  }
+  for (const key of ordered) {
+    value[key] = entries.get(key);
+  }
+  return true;
+}
+
+function hasDevelopmentSourceExport(value: unknown): boolean {
+  if (!isRecord(value)) {
+    return false;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if ((key === 'development' || key === 'bun') && typeof child === 'string' && child.startsWith('./src/')) {
+      return true;
+    }
+    if (hasDevelopmentSourceExport(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function addFileEntry(pkg: Record<string, unknown>, entry: string): boolean {
+  const files = pkg.files;
+  if (!Array.isArray(files) || files.includes(entry)) {
+    return false;
+  }
+  const firstNegated = files.findIndex((file) => typeof file === 'string' && file.startsWith('!'));
+  if (firstNegated === -1) {
+    files.push(entry);
+  } else {
+    files.splice(firstNegated, 0, entry);
+  }
+  return true;
+}

package/src/monorepo/packed-package.ts

@@ -0,0 +1,101 @@
+import { readFileSync, rmSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { publint } from 'publint';
+import { formatMessage } from 'publint/utils';
+import { isRecord } from '../lib/json.js';
+import { runStatus } from '../lib/run.js';
+import type { PackageInfo } from '../lib/workspace.js';
+import { listPublicPackages } from '../lib/workspace.js';
+
+export async function validatePackedPublicPackages(root: string): Promise<number> {
+  let failures = 0;
+  for (const pkg of listPublicPackages(root)) {
+    failures += await validatePackedPublicPackage(root, pkg);
+  }
+  return failures;
+}
+
+async function validatePackedPublicPackage(root: string, pkg: PackageInfo): Promise<number> {
+  let failures = 0;
+  const packed = await packPackage(root, pkg);
+  try {
+    const lint = await publint({ pack: { tarball: packed.arrayBuffer }, level: 'warning', strict: true });
+    for (const message of lint.messages) {
+      console.error(`${pkg.path}: publint ${message.type} ${message.code}: ${formatMessage(message, lint.pkg)}`);
+      failures++;
+    }
+
+    const attwArgs = [
+      packed.path,
+      '--format',
+      'ascii',
+      '--no-color',
+      '--profile',
+      'node16',
+      '--ignore-rules',
+      'cjs-resolves-to-esm',
+      ...attwExcludedEntrypointArgs(pkg),
+    ];
+    const attwStatus = await runStatus('attw', ['--quiet', ...attwArgs], root, true);
+    if (attwStatus !== 0) {
+      await runStatus('attw', attwArgs, root);
+      console.error(`${pkg.path}: are-the-types-wrong validation failed`);
+      failures++;
+    } else {
+      console.log(`${pkg.path}: are-the-types-wrong valid.`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${pkg.path}: packed package validation failed: ${message}`);
+    failures++;
+  } finally {
+    unlinkSync(packed.path);
+  }
+  if (failures === 0) {
+    console.log(`${pkg.path}: packed package is valid.`);
+  }
+  return failures;
+}
+
+function attwExcludedEntrypointArgs(pkg: PackageInfo): string[] {
+  const excluded = wasmExportEntrypoints(pkg.json.exports);
+  return excluded.length === 0 ? [] : ['--exclude-entrypoints', ...excluded];
+}
+
+function wasmExportEntrypoints(exports: unknown): string[] {
+  if (!isRecord(exports)) {
+    return [];
+  }
+  return Object.entries(exports)
+    .filter(([key, value]) => key.startsWith('.') && exportPointsToWasm(value))
+    .map(([key]) => key);
+}
+
+function exportPointsToWasm(value: unknown): boolean {
+  if (typeof value === 'string') {
+    return value.endsWith('.wasm');
+  }
+  return isRecord(value) && Object.values(value).some(exportPointsToWasm);
+}
+
+async function packPackage(root: string, pkg: PackageInfo): Promise<{ path: string; arrayBuffer: ArrayBuffer }> {
+  const packageDir = join(root, pkg.path);
+  const tarballName = `.smoo-${process.pid}-${Date.now()}.tgz`;
+  const tarballPath = join(root, tarballName);
+  try {
+    const status = await runStatus(
+      'bun',
+      ['pm', 'pack', '--filename', tarballName, '--ignore-scripts', '--quiet'],
+      packageDir,
+      true,
+    );
+    if (status !== 0) {
+      throw new Error(`bun pm pack failed with exit code ${status}`);
+    }
+    const bytes = new Uint8Array(readFileSync(tarballPath));
+    return { path: tarballPath, arrayBuffer: bytes.slice().buffer };
+  } catch (error) {
+    rmSync(tarballPath, { force: true });
+    throw error;
+  }
+}

package/src/monorepo/packs/index.ts

@@ -0,0 +1,115 @@
+import { chmodSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { validateManagedFiles } from '../managed-files.js';
+import { validateNxSync } from '../nx-sync.js';
+import { fixPackageHygiene, validatePackageHygiene } from '../package-hygiene.js';
+import {
+  applyPublicPackageDefaults,
+  applyWorkspaceDependencyDefaults,
+  validateNxReleaseConfig,
+  validatePublicPackageMetadata,
+  validatePublicTags,
+  validateRootPackagePolicy,
+  validateWorkspaceDependencies,
+} from '../package-policy.js';
+import { validatePackedPublicPackages } from '../packed-package.js';
+import { syncRootRuntimeVersions } from '../runtime.js';
+
+export interface MonorepoContext {
+  root: string;
+  syncRuntime: boolean;
+}
+
+export interface ValidatePackOptions {
+  failFast?: boolean;
+}
+
+interface MonorepoPack {
+  name: string;
+  init?(ctx: MonorepoContext): Promise<void> | void;
+  validate?(ctx: MonorepoContext): Promise<number> | number;
+}
+
+const packs: MonorepoPack[] = [
+  {
+    name: 'core',
+    async init(ctx) {
+      ensureLocalSmooShim(ctx.root);
+      if (ctx.syncRuntime) {
+        await syncRootRuntimeVersions(ctx.root);
+      } else {
+        console.log('skip           root runtime versions (outside devenv; pass --sync-runtime to force)');
+      }
+    },
+    async validate(ctx) {
+      return (
+        validateManagedFiles(ctx.root) +
+        validateRootPackagePolicy(ctx.root) +
+        validateNxReleaseConfig(ctx.root) +
+        (await validateNxSync(ctx.root))
+      );
+    },
+  },
+  {
+    name: 'publishing',
+    init(ctx) {
+      applyPublicPackageDefaults(ctx.root);
+    },
+    validate(ctx) {
+      return validatePublicTags(ctx.root) + validatePublicPackageMetadata(ctx.root);
+    },
+  },
+  {
+    name: 'workspace-dependencies',
+    async init(ctx) {
+      applyWorkspaceDependencyDefaults(ctx.root);
+      await fixPackageHygiene(ctx.root);
+    },
+    async validate(ctx) {
+      return validateWorkspaceDependencies(ctx.root) + (await validatePackageHygiene(ctx.root));
+    },
+  },
+  {
+    name: 'packed-packages',
+    validate(ctx) {
+      return validatePackedPublicPackages(ctx.root);
+    },
+  },
+];
+
+export async function runInitPacks(ctx: MonorepoContext): Promise<void> {
+  for (const pack of packs) {
+    await pack.init?.(ctx);
+  }
+}
+
+export async function runValidatePacks(ctx: MonorepoContext, options: ValidatePackOptions = {}): Promise<number> {
+  let failures = 0;
+  let checkedPacks = 0;
+  for (const pack of packs) {
+    if (!pack.validate) {
+      continue;
+    }
+    console.log(`${checkedPacks === 0 ? '' : '\n'}== ${pack.name} ==`);
+    checkedPacks++;
+    const packFailures = await pack.validate(ctx);
+    failures += packFailures;
+    if (packFailures > 0 && options.failFast) {
+      break;
+    }
+  }
+  return failures;
+}
+
+function ensureLocalSmooShim(root: string): void {
+  const shim = join(root, 'tooling', 'smoo');
+  if (!existsSync(shim)) {
+    return;
+  }
+  if ((statSync(shim).mode & 0o755) === 0o755) {
+    console.log('unchanged      tooling/smoo executable bit');
+    return;
+  }
+  chmodSync(shim, 0o755);
+  console.log('updated        tooling/smoo executable bit');
+}