import { existsSync } from "node:fs";import { mkdir, readdir, readFile, rename, rm } from "node:fs/promises";import { dirname, join, resolve } from "node:path";import { fileURLToPath } from "node:url"; type ReleaseChannel = "latest" | "beta"; type ReleaseMode = "full" | "dry-run" | "stage-only" | "publish-only"; type ReleaseCliOptions = {  readonly mode: ReleaseMode;  readonly skipBuild: boolean;}; type CommandInput = {  readonly command: string;  readonly args: ReadonlyArray<string>;  readonly cwd: string;  readonly captureOutput?: boolean;}; type CommandOutput = {  readonly stdout: string;  readonly stderr: string;}; const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");const cliRoot = resolve(repoRoot, "apps/cli");const distDir = resolve(cliRoot, "dist");const releaseDir = resolve(distDir, "release");const wrapperDir = resolve(distDir, "executor");const versionPackagePath = resolve(cliRoot, "package.json");const semverPattern =  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/; const parseArgs = (argv: ReadonlyArray<string>): ReleaseCliOptions => {  let mode: ReleaseMode = "full";  let skipBuild = false;   for (const arg of argv) {    if (arg === "--skip-build") {      skipBuild = true;      continue;    }     const next: ReleaseMode | null =      arg === "--dry-run"        ? "dry-run"        : arg === "--stage-only"          ? "stage-only"          : arg === "--publish-only"            ? "publish-only"            : null;    if (next === null) {      throw new Error(`Unknown argument: ${arg}`);    }    if (mode !== "full") {      throw new Error(`--${next} conflicts with --${mode}; pass at most one mode flag`);    }    mode = next;  }   if (mode === "publish-only" && skipBuild) {    throw new Error("--skip-build is implied by --publish-only; drop it");  }  if (mode === "dry-run" && skipBuild) {    throw new Error("--skip-build with --dry-run would validate artifacts and do nothing else");  }   return { mode, skipBuild };}; const runCommand = async (input: CommandInput): Promise<CommandOutput> => {  const proc = Bun.spawn([input.command, ...input.args], {    cwd: input.cwd,    env: process.env,    stdio: input.captureOutput ? ["ignore", "pipe", "pipe"] : ["ignore", "inherit", "inherit"],  });   const exitCode = await proc.exited;  const stdout = input.captureOutput && proc.stdout ? await new Response(proc.stdout).text() : "";  const stderr = input.captureOutput && proc.stderr ? await new Response(proc.stderr).text() : "";   if (exitCode !== 0) {    throw new Error(      [        `${input.command} ${input.args.join(" ")} exited with code ${exitCode}`,        stdout.trim().length > 0 ? `stdout:\n${stdout.trim()}` : null,        stderr.trim().length > 0 ? `stderr:\n${stderr.trim()}` : null,      ]        .filter((part) => part !== null)        .join("\n\n"),    );  }   return {    stdout: stdout.trim(),    stderr: stderr.trim(),  };}; const readVersion = async (): Promise<string> => {  const pkg = (await Bun.file(versionPackagePath).json()) as { version?: string };  const version = pkg.version?.trim();   if (!version) {    throw new Error(`Missing version in ${versionPackagePath}`);  }   return version;}; const validateVersion = (version: string): void => {  if (!semverPattern.test(version)) {    throw new Error(`${versionPackagePath} version is not valid semver: ${version}`);  }}; const resolveChannel = (version: string): ReleaseChannel =>  version.includes("-") ? "beta" : "latest"; const resolveTagFromEnvironment = (): string | undefined => {  const refName = process.env.GITHUB_REF_NAME?.trim();  if (process.env.GITHUB_REF_TYPE === "tag" && refName) {    return refName;  }   const ref = process.env.GITHUB_REF?.trim();  if (ref?.startsWith("refs/tags/")) {    return ref.slice("refs/tags/".length);  }   return undefined;}; const resolveGitHubRepository = (): string => {  const repository = process.env.GH_REPO?.trim() || process.env.GITHUB_REPOSITORY?.trim();  if (!repository) {    throw new Error("Set GH_REPO or GITHUB_REPOSITORY before creating a GitHub release.");  }   return repository;}; const packWrapperPackage = async (): Promise<string> => {  if (!existsSync(wrapperDir)) {    throw new Error(`Wrapper package directory not found: ${wrapperDir}`);  }   await mkdir(releaseDir, { recursive: true });   const before = new Set((await readdir(wrapperDir)).filter((entry) => entry.endsWith(".tgz")));  await runCommand({    command: "bun",    args: ["pm", "pack"],    cwd: wrapperDir,  });   const after = (await readdir(wrapperDir)).filter((entry) => entry.endsWith(".tgz"));  const archiveName = after.find((entry) => !before.has(entry)) ?? after[0];   if (!archiveName) {    throw new Error(`bun pm pack did not create a .tgz archive in ${wrapperDir}`);  }   const sourcePath = join(wrapperDir, archiveName);  const destinationPath = join(releaseDir, archiveName);   await rm(destinationPath, { force: true });  await rename(sourcePath, destinationPath);   return destinationPath;}; const collectReleaseAssetPaths = async (  wrapperArchivePath: string,): Promise<ReadonlyArray<string>> => {  const assetNames = (await readdir(distDir))    .filter((entry) => /^executor-.*\.(?:tar\.gz|zip)$/.test(entry))    .sort();   return [wrapperArchivePath, ...assetNames.map((entry) => join(distDir, entry))];}; const githubReleaseExists = async (tag: string, repository: string): Promise<boolean> => {  const proc = Bun.spawn(["gh", "release", "view", tag, "--repo", repository], {    cwd: repoRoot,    env: process.env,    stdio: ["ignore", "ignore", "ignore"],  });   return (await proc.exited) === 0;}; /** The CHANGELOG section Changesets generated for `version` (compiled from *  `.changeset/*.md` bodies at Version Packages time) — the GitHub Release *  body. Returns null when the section is missing so the caller can fall back *  to GitHub's auto-generated notes. */const changelogSectionForVersion = async (version: string): Promise<string | null> => {  const changelogPath = resolve(cliRoot, "CHANGELOG.md");  if (!existsSync(changelogPath)) return null;  const lines = (await readFile(changelogPath, "utf8")).split("\n");  const start = lines.findIndex((line) => line.trim() === `## ${version}`);  if (start === -1) return null;  let end = lines.length;  for (let i = start + 1; i < lines.length; i += 1) {    if (/^## /.test(lines[i] ?? "")) {      end = i;      break;    }  }  const body = lines    .slice(start + 1, end)    .join("\n")    .trim();  return body.length > 0 ? body : null;}; const syncGitHubRelease = async (input: {  readonly tag: string;  readonly channel: ReleaseChannel;  readonly assetPaths: ReadonlyArray<string>;}): Promise<void> => {  if (!process.env.GH_TOKEN?.trim()) {    throw new Error("GH_TOKEN is required to create or update a GitHub release.");  }   const repository = resolveGitHubRepository();   if (await githubReleaseExists(input.tag, repository)) {    await runCommand({      command: "gh",      args: [        "release",        "upload",        input.tag,        ...input.assetPaths,        "--repo",        repository,        "--clobber",      ],      cwd: repoRoot,    });    return;  }   const notes = await changelogSectionForVersion(input.tag.replace(/^v/, ""));   // Draft until publish-desktop.yml finishes uploading installers and flips  // it; otherwise /releases/latest/download/<desktop-asset> 404s during the  // desktop build window.  const args = [    "release",    "create",    input.tag,    ...input.assetPaths,    "--repo",    repository,    "--title",    input.tag,    ...(notes ? ["--notes", notes] : ["--generate-notes"]),    "--verify-tag",    "--draft",  ];   if (input.channel === "beta") {    args.push("--prerelease");  }   await runCommand({    command: "gh",    args,    cwd: repoRoot,  });}; /** Locate the wrapper archive a previous build of this exact version left in *  dist/release. Used by --skip-build and --publish-only so a run that just *  built (release:check's dry-run, or a --stage-only step) is not repeated. *  Fails hard on any mismatch — reusing stale artifacts must never be a *  silent fallback. */const locateBuiltArtifacts = async (version: string): Promise<string> => {  const wrapperPkgPath = join(wrapperDir, "package.json");  if (!existsSync(wrapperPkgPath)) {    throw new Error(`No built wrapper package at ${wrapperPkgPath}; run without --skip-build.`);  }   const wrapperPkg = (await Bun.file(wrapperPkgPath).json()) as {    version?: string;    optionalDependencies?: Record<string, string>;  };  if (wrapperPkg.version !== version) {    throw new Error(      `Built wrapper version ${wrapperPkg.version} does not match ${version}; run without --skip-build.`,    );  }   const expectedArchive = join(releaseDir, `executor-${version}.tgz`);  if (!existsSync(expectedArchive)) {    throw new Error(`Missing packed wrapper ${expectedArchive}; run without --skip-build.`);  }   // The wrapper's optionalDependencies are the source of truth for which  // platform variants this release ships. `build.ts publish` globs the  // dist/executor-*/ directories and publishes whatever it finds, so a  // missing dir would ship a wrapper referencing a variant that never  // reached npm, and an extra stale dir (say a leftover beta variant)  // would be published alongside. Require the exact set, each at the exact  // aliased version, each with its release archive present.  const optional = wrapperPkg.optionalDependencies ?? {};  const expectedVariants = Object.keys(optional).sort();  if (expectedVariants.length === 0) {    throw new Error(`Built wrapper has no optionalDependencies; run without --skip-build.`);  }   const variantDirs = [...new Bun.Glob("executor-*/package.json").scanSync({ cwd: distDir })]    .map((entry) => dirname(entry))    .sort();  if (variantDirs.join(",") !== expectedVariants.join(",")) {    throw new Error(      `Platform variant dirs [${variantDirs.join(", ")}] do not match the wrapper's ` +        `optionalDependencies [${expectedVariants.join(", ")}]; run without --skip-build.`,    );  }   for (const name of expectedVariants) {    const spec = optional[name]!;    const aliasPrefix = "npm:executor@";    if (!spec.startsWith(aliasPrefix)) {      throw new Error(`Unexpected optionalDependency spec for ${name}: ${spec}`);    }    const aliasVersion = spec.slice(aliasPrefix.length);     const variantPkg = (await Bun.file(join(distDir, name, "package.json")).json()) as {      version?: string;    };    if (variantPkg.version !== aliasVersion) {      throw new Error(        `${name} version ${variantPkg.version} does not match the wrapper's ` +          `${aliasVersion}; run without --skip-build.`,      );    }     if (!existsSync(join(distDir, `${name}.tar.gz`)) && !existsSync(join(distDir, `${name}.zip`))) {      throw new Error(        `Missing release archive for ${name} in ${distDir}; run without --skip-build.`,      );    }  }   return expectedArchive;}; const main = async () => {  const options = parseArgs(process.argv.slice(2));  const version = await readVersion();  const tag = `v${version}`;  const refTag = resolveTagFromEnvironment();  const channel = resolveChannel(version);   validateVersion(version);   if (refTag && refTag !== tag) {    throw new Error(`GitHub tag ${refTag} does not match ${versionPackagePath} version ${version}`);  }   if (options.mode === "publish-only") {    await locateBuiltArtifacts(version);    await runCommand({      command: "bun",      args: ["run", "src/build.ts", "publish", channel],      cwd: cliRoot,    });    return;  }   let wrapperArchivePath: string;  if (options.skipBuild) {    wrapperArchivePath = await locateBuiltArtifacts(version);  } else {    await rm(releaseDir, { recursive: true, force: true });    await mkdir(releaseDir, { recursive: true });     await runCommand({      command: "bun",      args: ["run", "src/build.ts", "binary"],      cwd: cliRoot,    });     await runCommand({      command: "bun",      args: ["run", "src/build.ts", "release-assets"],      cwd: cliRoot,    });     wrapperArchivePath = await packWrapperPackage();  }   const assetPaths = await collectReleaseAssetPaths(wrapperArchivePath);   console.log(`Prepared executor@${version} for ${channel}`);  for (const assetPath of assetPaths) {    console.log(`- ${assetPath}`);  }   if (options.mode === "dry-run") {    return;  }   await syncGitHubRelease({    tag,    channel,    assetPaths,  });   if (options.mode === "stage-only") {    return;  }   await runCommand({    command: "bun",    args: ["run", "src/build.ts", "publish", channel],    cwd: cliRoot,  });}; await main();