@ontrails/trails 1.0.0-beta.4 → 1.0.0-beta.42

package/src/release/pack-coherence.ts

@@ -0,0 +1,455 @@
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { escapeRegExp } from '@ontrails/core';
+
+export interface ReleasePackCoherenceInput {
+  readonly branchName?: string | undefined;
+  readonly changedFiles: readonly string[];
+}
+
+export interface ReleasePackCoherenceWorkspace {
+  readonly name: string;
+  readonly path: string;
+  readonly version?: string | undefined;
+}
+
+export interface ReleasePackCoherenceLockfileWorkspace {
+  readonly name?: string | undefined;
+  readonly version?: string | undefined;
+}
+
+export interface ReleasePackCoherenceLockfileInput {
+  readonly lockfileWorkspaces: Readonly<
+    Record<string, ReleasePackCoherenceLockfileWorkspace | undefined>
+  >;
+  readonly sourceWorkspaces: readonly ReleasePackCoherenceWorkspace[];
+}
+
+export interface ReleasePackCoherenceLockfileSyncResult {
+  readonly text: string;
+  readonly updates: readonly string[];
+}
+
+interface RootPackageJson {
+  readonly workspaces?: readonly string[] | undefined;
+}
+
+interface WorkspacePackageJson {
+  readonly name?: string | undefined;
+  readonly version?: string | undefined;
+}
+
+interface BunLockfile {
+  readonly workspaces?:
+    | Readonly<
+        Record<string, ReleasePackCoherenceLockfileWorkspace | undefined>
+      >
+    | undefined;
+}
+
+const RELEASE_BRANCH_NAME = 'changeset-release/main';
+const REPO_ROOT = process.cwd();
+
+export const isReleasePackCoherenceFile = (path: string): boolean =>
+  path === 'bun.lock' ||
+  path === '.changeset/pre.json' ||
+  path === 'package.json' ||
+  path.endsWith('/package.json') ||
+  path.endsWith('/CHANGELOG.md');
+
+export const shouldRunReleasePackCoherenceCheck = ({
+  branchName,
+  changedFiles,
+}: ReleasePackCoherenceInput): boolean =>
+  branchName === RELEASE_BRANCH_NAME ||
+  changedFiles.some(isReleasePackCoherenceFile);
+
+const commandText = (cmd: readonly string[]): string => cmd.join(' ');
+
+const spawnCapture = async (cmd: readonly string[]): Promise<string> => {
+  const proc = Bun.spawn(cmd as string[], {
+    stderr: 'pipe',
+    stdin: 'ignore',
+    stdout: 'pipe',
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(
+      [
+        `Command failed: ${commandText(cmd)}`,
+        `exit: ${exitCode}`,
+        stdout.trim() ? `stdout:\n${stdout}` : undefined,
+        stderr.trim() ? `stderr:\n${stderr}` : undefined,
+      ]
+        .filter((line): line is string => typeof line === 'string')
+        .join('\n')
+    );
+  }
+  return stdout;
+};
+
+const spawnInherit = async (cmd: readonly string[]): Promise<number> =>
+  await Bun.spawn(cmd as string[], {
+    env: { ...process.env, GIT_PAGER: 'cat' },
+    stderr: 'inherit',
+    stdin: 'inherit',
+    stdout: 'inherit',
+  }).exited;
+
+const currentBranchName = async (): Promise<string | undefined> => {
+  const output = await spawnCapture(['git', 'branch', '--show-current']);
+  const branch = output.trim();
+  return branch.length > 0 ? branch : undefined;
+};
+
+const changedFilesFromGit = async (): Promise<readonly string[]> => {
+  const mergeBaseOutput = await spawnCapture([
+    'git',
+    'merge-base',
+    'origin/main',
+    'HEAD',
+  ]);
+  const mergeBase = mergeBaseOutput.trim();
+  const output = await spawnCapture([
+    'git',
+    'diff',
+    '--name-only',
+    '--diff-filter=ACMRT',
+    `${mergeBase}...HEAD`,
+  ]);
+  return output
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+};
+
+const changedFilesFromPath = async (
+  path: string
+): Promise<readonly string[]> => {
+  const text = await readFile(path, 'utf8');
+  return text
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+};
+
+const removeJsonTrailingCommas = (text: string): string =>
+  text.replaceAll(/,(\s*[}\]])/gu, '$1');
+
+const readJson = async <T>(path: string): Promise<T> =>
+  JSON.parse(await readFile(path, 'utf8')) as T;
+
+const readJsonc = async <T>(path: string): Promise<T> =>
+  JSON.parse(removeJsonTrailingCommas(await readFile(path, 'utf8'))) as T;
+
+const discoverWorkspaceDirs = async (
+  patterns: readonly string[]
+): Promise<string[]> => {
+  const dirs: string[] = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith('/*')) {
+      const parent = join(REPO_ROOT, pattern.slice(0, -2));
+      let names: string[] = [];
+      try {
+        const entries = await readdir(parent, { withFileTypes: true });
+        names = entries
+          .filter((entry) => entry.isDirectory())
+          .map((entry) => entry.name);
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        const dir = join(parent, name);
+        if (await Bun.file(join(dir, 'package.json')).exists()) {
+          dirs.push(dir);
+        }
+      }
+      continue;
+    }
+
+    const dir = join(REPO_ROOT, pattern);
+    if (await Bun.file(join(dir, 'package.json')).exists()) {
+      dirs.push(dir);
+    }
+  }
+  return dirs;
+};
+
+const discoverSourceWorkspaces = async (): Promise<
+  ReleasePackCoherenceWorkspace[]
+> => {
+  const root = await readJson<RootPackageJson>(join(REPO_ROOT, 'package.json'));
+  if (!root.workspaces || root.workspaces.length === 0) {
+    throw new Error('Root package.json has no "workspaces" field');
+  }
+
+  const dirs = await discoverWorkspaceDirs(root.workspaces);
+  const workspaces: ReleasePackCoherenceWorkspace[] = [];
+  for (const dir of dirs) {
+    const pkg = await readJson<WorkspacePackageJson>(join(dir, 'package.json'));
+    if (!pkg.name) {
+      continue;
+    }
+    workspaces.push({
+      name: pkg.name,
+      path: relative(REPO_ROOT, dir),
+      version: pkg.version,
+    });
+  }
+  return workspaces;
+};
+
+export const findLockfileWorkspaceMetadataMismatches = ({
+  lockfileWorkspaces,
+  sourceWorkspaces,
+}: ReleasePackCoherenceLockfileInput): string[] => {
+  const mismatches: string[] = [];
+  for (const workspace of sourceWorkspaces) {
+    const lockWorkspace = lockfileWorkspaces[workspace.path];
+    if (!lockWorkspace) {
+      mismatches.push(
+        `${workspace.path}/package.json is missing from bun.lock workspaces`
+      );
+      continue;
+    }
+
+    if (lockWorkspace.name !== workspace.name) {
+      mismatches.push(
+        `${workspace.path}/package.json has name ${workspace.name}, but bun.lock records ${lockWorkspace.name ?? '(missing)'}`
+      );
+    }
+
+    if (
+      typeof workspace.version === 'string' &&
+      lockWorkspace.version !== workspace.version
+    ) {
+      mismatches.push(
+        `${workspace.path}/package.json has version ${workspace.version}, but bun.lock records ${lockWorkspace.version ?? '(missing)'}`
+      );
+    }
+  }
+  return mismatches;
+};
+
+const findWorkspaceBlockRange = (
+  text: string,
+  workspacePath: string
+): { readonly start: number; readonly end: number } | undefined => {
+  const keyMatch = new RegExp(
+    `^    "${escapeRegExp(workspacePath)}": \\{`,
+    'mu'
+  ).exec(text);
+  if (!keyMatch) {
+    return undefined;
+  }
+
+  const openBrace = text.indexOf('{', keyMatch.index);
+  if (openBrace === -1) {
+    return undefined;
+  }
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = openBrace; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === '\\') {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === '{') {
+      depth += 1;
+      continue;
+    }
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        return { end: index + 1, start: openBrace };
+      }
+    }
+  }
+
+  return undefined;
+};
+
+export const syncLockfileWorkspaceMetadataText = (
+  text: string,
+  sourceWorkspaces: readonly ReleasePackCoherenceWorkspace[]
+): ReleasePackCoherenceLockfileSyncResult => {
+  let nextText = text;
+  const updates: string[] = [];
+
+  for (const workspace of sourceWorkspaces) {
+    if (typeof workspace.version !== 'string') {
+      continue;
+    }
+
+    const range = findWorkspaceBlockRange(nextText, workspace.path);
+    if (!range) {
+      continue;
+    }
+
+    const block = nextText.slice(range.start, range.end);
+    const versionMatch = /^(\s*"version":\s*")([^"]*)(",?)$/mu.exec(block);
+    if (!versionMatch || versionMatch[2] === workspace.version) {
+      continue;
+    }
+
+    const replacement = `${versionMatch[1]}${workspace.version}${versionMatch[3]}`;
+    const blockStart = range.start + versionMatch.index;
+    const valueEnd = blockStart + versionMatch[0].length;
+    nextText =
+      nextText.slice(0, blockStart) + replacement + nextText.slice(valueEnd);
+    updates.push(
+      `${workspace.path}/package.json: ${versionMatch[2]} -> ${workspace.version}`
+    );
+  }
+
+  return { text: nextText, updates };
+};
+
+const loadBunLockfile = async (): Promise<BunLockfile> =>
+  await readJsonc<BunLockfile>(join(REPO_ROOT, 'bun.lock'));
+
+const syncLockfileWorkspaceMetadata = async (): Promise<void> => {
+  const lockfilePath = join(REPO_ROOT, 'bun.lock');
+  const [lockfile, sourceWorkspaces] = await Promise.all([
+    readFile(lockfilePath, 'utf8'),
+    discoverSourceWorkspaces(),
+  ]);
+  const { text, updates } = syncLockfileWorkspaceMetadataText(
+    lockfile,
+    sourceWorkspaces
+  );
+
+  if (updates.length === 0) {
+    console.error('release-pack: bun.lock workspace metadata already synced');
+    return;
+  }
+
+  await writeFile(lockfilePath, text);
+  console.error('release-pack: synced bun.lock workspace metadata');
+  for (const update of updates) {
+    console.error(`  ${update}`);
+  }
+};
+
+const runLockfileWorkspaceMetadataCheck = async (): Promise<number> => {
+  const lockfile = await loadBunLockfile();
+  if (!lockfile.workspaces) {
+    throw new Error('bun.lock has no "workspaces" object');
+  }
+
+  const mismatches = findLockfileWorkspaceMetadataMismatches({
+    lockfileWorkspaces: lockfile.workspaces,
+    sourceWorkspaces: await discoverSourceWorkspaces(),
+  });
+
+  if (mismatches.length === 0) {
+    console.error('release-pack: bun.lock workspace metadata is coherent');
+    return 0;
+  }
+
+  console.error('release-pack: bun.lock workspace metadata is stale');
+  for (const mismatch of mismatches) {
+    console.error(`  ${mismatch}`);
+  }
+  return 1;
+};
+
+export interface ReleasePackCoherenceParsedArgs {
+  readonly branchName?: string | undefined;
+  readonly changedFilesPath?: string | undefined;
+  readonly fixLockfile: boolean;
+  readonly lockfileOnly: boolean;
+}
+
+export const parseReleasePackCoherenceArgs = (
+  args: readonly string[]
+): ReleasePackCoherenceParsedArgs => {
+  let branchName: string | undefined;
+  let changedFilesPath: string | undefined;
+  let fixLockfile = false;
+  let lockfileOnly = false;
+  const readValue = (index: number, flag: string): string => {
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) {
+      throw new Error(
+        `Missing value for release pack coherence argument: ${flag}`
+      );
+    }
+    return value;
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--branch') {
+      branchName = readValue(index, arg);
+      index += 1;
+    } else if (arg === '--changed-files') {
+      changedFilesPath = readValue(index, arg);
+      index += 1;
+    } else if (arg === '--lockfile-only') {
+      lockfileOnly = true;
+    } else if (arg === '--fix-lockfile') {
+      fixLockfile = true;
+    } else {
+      throw new Error(`Unknown release pack coherence argument: ${arg}`);
+    }
+  }
+  return { branchName, changedFilesPath, fixLockfile, lockfileOnly };
+};
+
+export const runReleasePackCoherenceCli = async (
+  args: readonly string[] = process.argv.slice(2)
+): Promise<number> => {
+  try {
+    const parsed = parseReleasePackCoherenceArgs(args);
+    if (parsed.fixLockfile) {
+      await syncLockfileWorkspaceMetadata();
+      console.error('release-pack: checking bun.lock workspace metadata');
+      return await runLockfileWorkspaceMetadataCheck();
+    }
+
+    const [branchName, changedFiles] = await Promise.all([
+      parsed.branchName
+        ? Promise.resolve(parsed.branchName)
+        : currentBranchName(),
+      parsed.changedFilesPath
+        ? changedFilesFromPath(parsed.changedFilesPath)
+        : changedFilesFromGit(),
+    ]);
+
+    if (!shouldRunReleasePackCoherenceCheck({ branchName, changedFiles })) {
+      console.error(
+        'release-pack: skipped; no package release metadata changed'
+      );
+      return 0;
+    }
+
+    if (parsed.lockfileOnly) {
+      console.error('release-pack: checking bun.lock workspace metadata');
+      return await runLockfileWorkspaceMetadataCheck();
+    }
+
+    console.error('release-pack: checking packed workspace metadata');
+    return await spawnInherit(['bun', 'run', 'publish:check']);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+};

package/src/release/packed-artifacts-smoke.ts

@@ -0,0 +1,236 @@
+/* oxlint-disable eslint-plugin-jest/require-hook, max-statements -- end-to-end package smoke with temp consumer setup */
+/**
+ * Packs public first-party packages into tarballs, installs them into a
+ * scratch consumer with first-party overrides, and runs the Warden/Trails CLI
+ * from the packed artifacts.
+ */
+
+import { mkdir, mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+
+const REPO_ROOT = resolve(process.cwd());
+
+interface PackedSmokePackageJson {
+  readonly name?: string;
+  readonly private?: boolean;
+  readonly version?: string;
+  readonly workspaces?: readonly string[];
+}
+
+interface PackedSmokeWorkspace {
+  readonly name: string;
+  readonly path: string;
+}
+
+export interface PackedArtifactsSmokeResult {
+  readonly check: 'packed-artifacts';
+  readonly message: string;
+  readonly packageCount: number;
+  readonly passed: true;
+}
+
+const commandText = (cmd: readonly string[]): string => cmd.join(' ');
+
+const readJson = async <T>(path: string): Promise<T> =>
+  (await Bun.file(path).json()) as T;
+
+const lastOutputLine = (output: string): string => {
+  const line = output
+    .split(/\r?\n/)
+    .map((item) => item.trim())
+    .findLast((item) => item.length > 0);
+  if (line === undefined) {
+    throw new Error('Expected command output, received none');
+  }
+  return line;
+};
+
+const runCapture = async (
+  cmd: readonly string[],
+  cwd: string
+): Promise<string> => {
+  const proc = Bun.spawn(cmd as string[], {
+    cwd,
+    stderr: 'pipe',
+    stdin: 'ignore',
+    stdout: 'pipe',
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(
+      [
+        `Command failed in ${cwd}: ${commandText(cmd)}`,
+        `exit: ${exitCode}`,
+        stdout.trim() ? `stdout:\n${stdout}` : undefined,
+        stderr.trim() ? `stderr:\n${stderr}` : undefined,
+      ]
+        .filter((line): line is string => typeof line === 'string')
+        .join('\n')
+    );
+  }
+  return stdout || stderr;
+};
+
+const workspaceDirs = async (): Promise<readonly string[]> => {
+  const rootPackage = await readJson<PackedSmokePackageJson>(
+    join(REPO_ROOT, 'package.json')
+  );
+  const dirs: string[] = [];
+  for (const pattern of rootPackage.workspaces ?? []) {
+    if (!pattern.endsWith('/*')) {
+      throw new Error(`Unsupported workspace pattern: ${pattern}`);
+    }
+    const base = join(REPO_ROOT, pattern.slice(0, -2));
+    for (const entry of await readdir(base, { withFileTypes: true })) {
+      const dir = join(base, entry.name);
+      if (
+        entry.isDirectory() &&
+        (await Bun.file(join(dir, 'package.json')).exists())
+      ) {
+        dirs.push(dir);
+      }
+    }
+  }
+  return dirs.toSorted((a, b) => a.localeCompare(b));
+};
+
+const publicFirstPartyWorkspaces = async (): Promise<
+  readonly PackedSmokeWorkspace[]
+> => {
+  const workspaces: PackedSmokeWorkspace[] = [];
+  for (const path of await workspaceDirs()) {
+    const packageJson = await readJson<PackedSmokePackageJson>(
+      join(path, 'package.json')
+    );
+    if (
+      packageJson.private !== true &&
+      packageJson.name?.startsWith('@ontrails/') &&
+      packageJson.version !== undefined
+    ) {
+      workspaces.push({
+        name: packageJson.name,
+        path,
+      });
+    }
+  }
+  return workspaces.toSorted((a, b) => a.name.localeCompare(b.name));
+};
+
+const packWorkspace = async (
+  workspace: PackedSmokeWorkspace,
+  packRoot: string
+): Promise<string> => {
+  const output = await runCapture(
+    ['bun', 'pm', 'pack', '--destination', packRoot, '--quiet'],
+    workspace.path
+  );
+  const tarball = lastOutputLine(output);
+  const destinationPath = isAbsolute(tarball)
+    ? tarball
+    : join(packRoot, tarball);
+  if (await Bun.file(destinationPath).exists()) {
+    return destinationPath;
+  }
+  throw new Error(
+    `bun pm pack did not create expected tarball for ${workspace.name}: ${destinationPath} (destination: ${packRoot})`
+  );
+};
+
+const writeConsumerManifest = async (
+  consumerRoot: string,
+  tarballsByName: ReadonlyMap<string, string>
+): Promise<void> => {
+  const tarballDependencies = Object.fromEntries(
+    [...tarballsByName.entries()].map(([name, tarball]) => [
+      name,
+      `file:${tarball}`,
+    ])
+  );
+  await writeFile(
+    join(consumerRoot, 'package.json'),
+    `${JSON.stringify(
+      {
+        dependencies: tarballDependencies,
+        overrides: tarballDependencies,
+        private: true,
+        type: 'module',
+      },
+      null,
+      2
+    )}\n`
+  );
+};
+
+const binPath = (consumerRoot: string, name: 'trails' | 'warden'): string =>
+  join(consumerRoot, 'node_modules', '.bin', name);
+
+export const runPackedArtifactsSmoke =
+  async (): Promise<PackedArtifactsSmokeResult> => {
+    const tempRoot = await mkdtemp(join(tmpdir(), 'trails-packed-dogfood-'));
+    const packRoot = join(tempRoot, 'pack');
+    const consumerRoot = join(tempRoot, 'consumer');
+    let succeeded = false;
+
+    try {
+      await Promise.all([
+        mkdir(packRoot, { recursive: true }),
+        mkdir(consumerRoot, { recursive: true }),
+      ]);
+
+      const workspaces = await publicFirstPartyWorkspaces();
+      const tarballsByName = new Map<string, string>();
+      for (const workspace of workspaces) {
+        tarballsByName.set(
+          workspace.name,
+          await packWorkspace(workspace, packRoot)
+        );
+      }
+
+      await writeConsumerManifest(consumerRoot, tarballsByName);
+      await runCapture(['bun', 'install', '--silent'], consumerRoot);
+
+      await runCapture(
+        [
+          binPath(consumerRoot, 'warden'),
+          '--root-dir',
+          REPO_ROOT,
+          '--lock',
+          'skip',
+          '--format',
+          'summary',
+        ],
+        REPO_ROOT
+      );
+      await runCapture([binPath(consumerRoot, 'trails'), '--help'], REPO_ROOT);
+      await runCapture(
+        [binPath(consumerRoot, 'trails'), 'warden', '--lock', 'skip'],
+        REPO_ROOT
+      );
+
+      succeeded = true;
+      return {
+        check: 'packed-artifacts',
+        message: `Packed artifact smoke passed for ${workspaces.length} @ontrails/* packages.`,
+        packageCount: workspaces.length,
+        passed: true,
+      };
+    } finally {
+      if (succeeded) {
+        await rm(tempRoot, { force: true, recursive: true });
+      } else {
+        console.error(
+          `Packed dogfood temp root kept for inspection: ${tempRoot}`
+        );
+      }
+    }
+  };
+
+if (import.meta.main) {
+  const result = await runPackedArtifactsSmoke();
+  console.log(result.message);
+}