mopub 0.0.1

package/dist/cli.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import * as trpcServer from '@trpc/server';
+import * as trpcCli from 'trpc-cli';
+import { z } from 'zod';
+import { releaseNotes, ReleaseNotesInput, publish, PublishInput, PrebuiltInput, publishPrebuilt, Ctx } from './publish.js';
+const t = trpcServer.initTRPC.meta().create();
+const router = t.router({
+    publish: t.procedure
+        .meta({ default: true })
+        .input(PublishInput) //
+        .mutation(async ({ input }) => {
+        await publish(input);
+    }),
+    prebuilt: t.procedure
+        .input(PrebuiltInput) //
+        .mutation(async ({ input }) => publishPrebuilt(input)),
+    releaseNotes: t.procedure
+        .meta({
+        description: `Creates a GitHub release notes draft in markdown format, and opens it in the default browser. It does not perform any side-effects - if you're happy with the draft, just click "Create release" on GitHub. That will create the release and the git tag.`,
+    })
+        .input(ReleaseNotesInput) //
+        .mutation(async ({ input }) => {
+        return releaseNotes(input);
+    }),
+    local: t.procedure
+        .meta({
+        description: 'Preps packages for local installation. Builds and packs all packages, and replaces dependencies with local versions using the file protocol. Prints install commands to stdout.',
+    })
+        .input(z.object({
+        prebuilt: z
+            .string()
+            .describe('path to prebuilt folder. if ommitted a dry-run publish will be done to build and pack packages into a temp folder.\nNOTE: if you provide this value, dependencies in this folder will be replaced with local versions using the file protocol.')
+            .optional(),
+    }))
+        .mutation(async ({ input: options }) => {
+        const date = new Date(Number(options.prebuilt?.match(/\b\d{13}$/)?.[0] || Date.now()));
+        const dateVersion = date.toISOString().split('T')[0].split('-').join('.').replaceAll('.0', '.') + String(-date.getTime());
+        const ctx = options.prebuilt
+            ? Ctx.parse(JSON.parse(fs.readFileSync(options.prebuilt + '/context.json').toString()))
+            : await publish({
+                version: dateVersion,
+                publish: false,
+                skipRegistryPull: true,
+            });
+        for (const pkg of ctx.packages) {
+            const packagePath = path.join(pkg.folder, 'right/package');
+            const packageJsonPath = path.join(packagePath, 'package.json');
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString());
+            packageJson.version = dateVersion;
+            const warning = `ONLY INTENDED FOR LOCAL INSTALLATION VIA 'file:' PROTOCOL. DO NOT PUBLISH!`;
+            packageJson.description = [warning, packageJson.description].filter(Boolean).join('\n\n');
+            for (const dep of Object.keys(packageJson.dependencies || {})) {
+                const foundDep = ctx.packages.find(p => p.name === dep);
+                if (foundDep) {
+                    packageJson.dependencies[dep] = `file:${path.join(foundDep.folder, 'right/package')}`;
+                }
+            }
+            for (const peerDep of Object.keys(packageJson.peerDependencies || {})) {
+                const foundPeerDep = ctx.packages.find(p => p.name === peerDep);
+                if (foundPeerDep) {
+                    packageJson.peerDependencies[foundPeerDep.name] = dateVersion;
+                }
+            }
+            fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        }
+        for (const pkg of ctx.packages) {
+            const packagePath = path.join(pkg.folder, 'right/package');
+            const packageManager = process.env.npm_config_user_agent?.split(/\W/)[0] || 'npm';
+            // eslint-disable-next-line no-console
+            console.log(`${packageManager} add file:${packagePath}`);
+        }
+    }),
+});
+const cli = trpcCli.createCli({ router });
+void cli.run();

package/dist/publish.js

@@ -0,0 +1,1188 @@
+import { ListrEnquirerPromptAdapter } from '@listr2/prompt-adapter-enquirer';
+import { execa } from 'execa';
+import { findUpSync } from 'find-up';
+import * as fs from 'fs';
+import { Listr } from 'listr2';
+import * as path from 'path';
+import * as semver from 'semver';
+import { z } from 'zod';
+const VERSION_ZERO = '0.0.0';
+/** "left" folder i.e. base for comparison - usually from the registry */
+const LHS_FOLDER = 'left';
+/** "right" folder i.e. head for publishing - usually build from local source */
+const RHS_FOLDER = 'right';
+export const PublishInput = z
+    .object({
+    publish: z
+        .boolean()
+        .describe('actually publish packages - if not provided the tool will run in dry-run mode and create a directory containing the packages to be published.')
+        .optional(),
+    otp: z.string().describe('npm otp - needed with --publish. If not provided you will be prompted for it').optional(),
+    bump: z
+        .enum(['major', 'minor', 'patch', 'premajor', 'preminor', 'prepatch', 'prerelease', 'other', 'independent'])
+        .describe('semver "bump" strategy - if not provided you will be prompted for it. Do not use with --version.')
+        .optional(),
+    version: z.string().describe('specify an exact version to bump to. Do not use with --bump.').optional(),
+    skipRegistryPull: z
+        .boolean()
+        .optional()
+        .describe('skip pulling registry packages. Note: if publishing, the full history will appear in changelogs'),
+    scope: z
+        .string()
+        .regex(/^@[\w-_.]+$/)
+        .describe('change the scope of the package before publishing')
+        .optional(),
+})
+    .refine(obj => !(obj.bump && obj.version), { message: `Don't use --bump and --version together` });
+export const setupContextTasks = [
+    {
+        title: 'Set working directory',
+        task: async () => process.chdir(getWorkspaceRoot()),
+    },
+    ...Object.keys(loadPackageJson(path.join(getWorkspaceRoot(), 'package.json'))?.scripts || {})
+        .filter(s => s.match(/^(build)$/))
+        .map((s) => ({
+        title: `Running ${s} script`,
+        task: async (_ctx, task) => {
+            const isPnpmMonorepo = fs.existsSync('pnpm-workspace.yaml');
+            const buildArgs = [s];
+            if (isPnpmMonorepo)
+                buildArgs.unshift('--workspace-root');
+            await pipeExeca(task, 'pnpm', buildArgs);
+        },
+    })),
+    {
+        title: 'Get temp directory',
+        rendererOptions: { persistentOutput: true },
+        task: async (ctx, task) => {
+            const list = await execa('pnpm', ['list', '--json', '--depth', '0', '--filter', '.']);
+            let projectName = JSON.parse(list.stdout)?.[0]?.name;
+            if (!projectName) {
+                projectName = path.basename(getWorkspaceRoot());
+            }
+            if (!projectName)
+                throw new Error(`Couldn't get package name from pnpm list output: ${list.stdout}`);
+            ctx.tempDir = path.join('/tmp/npmono', projectName, Date.now().toString());
+            task.output = ctx.tempDir;
+            fs.mkdirSync(ctx.tempDir, { recursive: true });
+        },
+    },
+    {
+        title: 'Collecting packages',
+        rendererOptions: { persistentOutput: true },
+        task: async (ctx, task) => {
+            const listResult = await execa('pnpm', ['list', '--json', '--recursive', '--only-projects', '--prod']);
+            const firstResult = listResult.stdout.split('\n\n')[0]; // pnpm can find unrelated packages that live in the repo, but they're returned in a separate json object after two newlines
+            // e.g. for pnpm first it lists just the `np` package.json, but then it finds various test packages like `test/fixtures/foo/package.json` etc.
+            try {
+                ctx.packages = JSON.parse(firstResult);
+            }
+            catch {
+                throw new Error(`Failed to parse pnpm list output as JSON: ${firstResult}`);
+            }
+            ctx.packages = ctx.packages.filter(pkg => !pkg.private);
+            const pwdsCommand = await execa('pnpm', ['recursive', 'exec', 'pwd']); // use `pnpm recursive exec` to get the correct topological sort order // https://github.com/pnpm/pnpm/issues/7716
+            const pwdIndexMap = Object.fromEntries(pwdsCommand.stdout.split('\n').map((s, i) => [s.trim(), i]));
+            // sort topologically, alphabetically as a tiebreaker. note that this implementation relies on there being fewer than one million packages in the repo. if this affects you, congratulations. i will fix it. the bug bounty for the fix is $100 per package.
+            ctx.packages.sort((a, b) => pwdIndexMap[a.path] - pwdIndexMap[b.path] + a.name.localeCompare(b.name) / 1_000_000);
+            ctx.packages.forEach((pkg, i, { length }) => {
+                const number = Number(`1${'0'.repeat(length.toString().length + 1)}`) + i;
+                pkg.folder = path.join(ctx.tempDir, `${number}.${pkg.name.replace('/', '__')}`);
+            });
+            task.output = ctx.packages.map(pkg => `${pkg.name}`).join(', ');
+            return `Found ${ctx.packages.length} packages to publish`;
+        },
+    },
+    {
+        title: 'Getting published versions',
+        task: (ctx, task) => {
+            return task.newListr(ctx.packages.map(pkg => ({
+                title: `Getting published versions for ${pkg.name}`,
+                task: async (_ctx) => {
+                    fs.mkdirSync(path.join(pkg.folder, LHS_FOLDER), { recursive: true });
+                    pkg.publishedVersions = await getRegistryVersions(pkg);
+                },
+            })), { concurrent: true });
+        },
+    },
+];
+async function getRegistryVersions(pkg) {
+    const registryVersionsResult = await execa('npm', ['view', pkg.name, 'versions', '--json'], { reject: false });
+    const StdoutShape = z.union([
+        z.array(z.string()).nonempty(), // success
+        z.object({ error: z.object({ code: z.literal('E404') }) }), // not found - package doesn't exist (yet!). this is ok. other errors are not.
+    ]);
+    const registryVersionsStdout = StdoutShape.parse(JSON.parse(registryVersionsResult.stdout));
+    return Array.isArray(registryVersionsStdout) ? registryVersionsStdout : [];
+}
+const _breakpoint = (why = 'hmm') => ({
+    title: `wait a bit because ${why}`,
+    task: async (ctx, task) => {
+        await task.prompt(ListrEnquirerPromptAdapter).run({
+            type: 'Input',
+            message: `press enter to continue past ${why}`,
+        });
+    },
+});
+export const publish = async (input) => {
+    const { sortPackageJson } = await import('sort-package-json');
+    const tasks = new Listr([
+        ...setupContextTasks,
+        {
+            title: `Writing local packages`,
+            task: (ctx, task) => {
+                return task.newListr(ctx.packages.map(pkg => ({
+                    title: `Packing ${pkg.name}`,
+                    task: async (_ctx, subtask) => {
+                        const toBePublishedFolderPath = path.join(pkg.folder, RHS_FOLDER);
+                        await pipeExeca(subtask, 'pnpm', ['pack', '--pack-destination', toBePublishedFolderPath], {
+                            cwd: pkg.path,
+                        });
+                        const tgzFileName = () => fs.readdirSync(toBePublishedFolderPath).at(0);
+                        await fs.promises.rename(path.join(toBePublishedFolderPath, tgzFileName()), path.join(toBePublishedFolderPath, `${pkg.name.replace('@', '').replace('/', '-')}-local.tgz`));
+                        await pipeExeca(subtask, 'tar', ['-xvzf', tgzFileName()], { cwd: toBePublishedFolderPath });
+                    },
+                })), { concurrent: true });
+            },
+        },
+        {
+            title: 'Get version strategy',
+            rendererOptions: { persistentOutput: true },
+            task: async (ctx, task) => {
+                const allVersions = [
+                    ...ctx.packages.map(pkg => pkg.version),
+                    ...ctx.packages.flatMap(pkg => pkg.publishedVersions.slice()),
+                ];
+                const maxVersion = allVersions.sort(semver.compare).at(-1) || VERSION_ZERO;
+                if (!maxVersion)
+                    throw new Error(`No versions found`);
+                let bumpedVersion;
+                if (input.bump) {
+                    bumpedVersion = bumpChoices(maxVersion).find(c => c.type === input.bump)?.value || input.bump;
+                }
+                else if (input.version) {
+                    bumpedVersion = input.version;
+                }
+                bumpedVersion ||= await task.prompt(ListrEnquirerPromptAdapter).run({
+                    type: 'Select',
+                    message: `Select semver increment for all packages, specify new version, or publish packages independently`,
+                    hint: `Current latest version across all packageas is ${maxVersion}`,
+                    choices: [
+                        ...bumpChoices(maxVersion),
+                        {
+                            message: 'Independent (each package will have its own version)',
+                            value: 'independent',
+                        },
+                    ],
+                });
+                if (bumpedVersion === 'independent') {
+                    const bumpMethod = await task.prompt(ListrEnquirerPromptAdapter).run({
+                        type: 'Select',
+                        message: 'Select semver increment for each package',
+                        choices: [
+                            ...allReleaseTypes.map(type => ({ message: type, value: type })),
+                            {
+                                message: 'Ask for each package',
+                                value: 'ask',
+                            },
+                        ],
+                    });
+                    ctx.versionStrategy = {
+                        type: 'independent',
+                        bump: bumpMethod === 'ask' ? null : bumpMethod,
+                    };
+                }
+                else {
+                    if (bumpedVersion === 'other') {
+                        bumpedVersion = await task.prompt(ListrEnquirerPromptAdapter).run({
+                            type: 'Input',
+                            message: `Enter a custom version (must be greater than ${maxVersion})`,
+                            validate: (v) => getBumpedVersionValidation(maxVersion, v),
+                        });
+                    }
+                    ensureValidBumpedVersion(maxVersion, bumpedVersion);
+                    ctx.versionStrategy = {
+                        type: 'fixed',
+                        version: bumpedVersion,
+                    };
+                }
+                task.output = Object.entries(ctx.versionStrategy)
+                    .map(e => e.join(': '))
+                    .join(', ');
+            },
+        },
+        {
+            title: `Pulling registry packages`,
+            rendererOptions: { persistentOutput: true },
+            skip: input.skipRegistryPull,
+            task: (ctx, task) => {
+                return task.newListr(ctx.packages.map(pkg => ({
+                    title: `Pulling ${pkg.name}`,
+                    rendererOptions: { persistentOutput: true },
+                    task: async (_ctx, subtask) => {
+                        const registryVersions = pkg.publishedVersions;
+                        const publishedAlreadyFolder = path.join(pkg.folder, LHS_FOLDER);
+                        const publishedVersionForComparison = registryVersions
+                            .slice()
+                            .reverse()
+                            .find(v => ctx.versionStrategy.type === 'independent' || // independent mode: compare to prerelease versions
+                            ctx.versionStrategy.version.includes('-') || // fixed mode prerelease version wanted: compare to prerelease versions
+                            !v.includes('-'));
+                        if (!publishedVersionForComparison) {
+                            return;
+                        }
+                        // note: `npm pack foobar` will actually pull foobar.1-2-3.tgz from the registry. It's not actually doing a "pack" at all. `pnpm pack` does not do the same thing - it packs the local directory
+                        await pipeExeca(subtask, 'npm', ['pack', `${pkg.name}@${publishedVersionForComparison}`], {
+                            reject: false,
+                            cwd: publishedAlreadyFolder,
+                        });
+                        const tgzFileName = fs.readdirSync(publishedAlreadyFolder).at(0);
+                        if (!tgzFileName) {
+                            const msg = `No tgz file found in ${publishedAlreadyFolder}, even though a last release was found. Registry versions: ${registryVersions.join(', ')}`;
+                            throw new Error(msg);
+                        }
+                        await pipeExeca(subtask, 'tar', ['-xvzf', tgzFileName], { cwd: publishedAlreadyFolder });
+                        const leftPackageJson = loadLHSPackageJson(pkg);
+                        if (leftPackageJson) {
+                            const leftPackageJsonPath = packageJsonFilepath(pkg, LHS_FOLDER);
+                            fs.writeFileSync(leftPackageJsonPath, 
+                            // avoid churn on package.json field ordering, which npm seems to mess with
+                            sortPackageJson(JSON.stringify(leftPackageJson, null, 2)));
+                        }
+                    },
+                })), { concurrent: true });
+            },
+        },
+        {
+            title: 'Set target versions',
+            task: async function setTargetVersions(ctx, task) {
+                const { stdout: rightSha } = await execa('git', ['log', '-n', '1', '--pretty=format:%h', '--', '.']);
+                for (const pkg of ctx.packages) {
+                    pkg.shas = {
+                        left: await getPackageLastPublishRef(pkg, task),
+                        right: rightSha,
+                    };
+                }
+                for (const pkg of ctx.packages) {
+                    const changelog = await getChangelog(ctx, pkg);
+                    if (ctx.versionStrategy.type === 'fixed') {
+                        pkg.targetVersion = ctx.versionStrategy.version;
+                        continue;
+                    }
+                    const currentVersion = [loadRHSPackageJson(pkg)?.version, pkg.version]
+                        .sort((a, b) => semver.compare(a || VERSION_ZERO, b || VERSION_ZERO))
+                        .at(-1);
+                    if (ctx.versionStrategy.bump) {
+                        pkg.targetVersion = semver.inc(currentVersion || VERSION_ZERO, ctx.versionStrategy.bump);
+                        continue;
+                    }
+                    const choices = bumpChoices(currentVersion || VERSION_ZERO);
+                    if (changelog) {
+                        choices.push({ type: 'none', message: `Do not publish (note: package is changed)`, value: 'none' });
+                    }
+                    else {
+                        choices.unshift({ type: 'none', message: `Do not publish (package is unchanged)`, value: 'none' });
+                    }
+                    let newVersion = await task.prompt(ListrEnquirerPromptAdapter).run({
+                        type: 'Select',
+                        message: `Select semver increment for ${pkg.name} or specify new version (current latest is ${currentVersion})`,
+                        choices,
+                    });
+                    if (newVersion === 'none') {
+                        continue;
+                    }
+                    if (newVersion === 'other') {
+                        newVersion = await task.prompt(ListrEnquirerPromptAdapter).run({
+                            type: 'Input',
+                            message: `Enter a custom version (must be greater than ${currentVersion})`,
+                            validate: (v) => getBumpedVersionValidation(currentVersion || VERSION_ZERO, v),
+                        });
+                    }
+                    ensureValidBumpedVersion(currentVersion || VERSION_ZERO, newVersion);
+                    pkg.targetVersion = newVersion;
+                    pkg.changeTypes = new Set(Array.from(changelog?.matchAll(/data-change-type="(\w+)"/g) || []).map(m => m[1]));
+                }
+                if (ctx.versionStrategy.type === 'fixed')
+                    return;
+                if (ctx.versionStrategy.type === 'independent' && !ctx.versionStrategy.bump)
+                    return;
+                const include = await task.prompt(ListrEnquirerPromptAdapter).run({
+                    type: 'MultiSelect',
+                    message: 'Select packages',
+                    hint: 'Press <space> to toggle, <a> to toggle all, <i> to invert selection',
+                    initial: ctx.packages.flatMap((pkg, i) => (pkg.changeTypes?.size ? [i] : [])),
+                    choices: ctx.packages.map(pkg => {
+                        const changeTypes = [...(pkg.changeTypes || [])];
+                        return {
+                            name: `${pkg.name} ${changeTypes.length ? `(changes: ${changeTypes.join(', ')})` : '(unchanged)'}`.trim(),
+                            value: pkg.name,
+                        };
+                    }),
+                    validate: (values) => {
+                        const names = values.map(v => v.split(' ')[0]);
+                        const problems = [];
+                        for (const name of names) {
+                            const pkg = ctx.packages.find(p => p.name === name);
+                            if (!pkg) {
+                                problems.push(`Package ${name} not found`);
+                                continue;
+                            }
+                            const dependencies = workspaceDependencies(pkg, ctx);
+                            const missing = dependencies.filter(d => !names.includes(d.name));
+                            problems.push(...missing.map(m => `Package ${name} depends on ${m.name}`));
+                        }
+                        if (problems.length > 0)
+                            return `Can't publish that selection of packages:\n` + problems.join('\n');
+                        return true;
+                    },
+                });
+                const includeSet = new Set(include.map(inc => inc.split(' ')[0]));
+                ctx.packages = ctx.packages.filter(pkg => includeSet.has(pkg.name));
+            },
+        },
+        {
+            title: `Modify local packages`,
+            task: (ctx, task) => {
+                return task.newListr(ctx.packages.map(pkg => ({
+                    title: `Modify ${pkg.name}`,
+                    task: async (_ctx, _subtask) => {
+                        if (!pkg.targetVersion || !semver.valid(pkg.targetVersion)) {
+                            throw new Error(`Invalid version for ${pkg.name}: ${pkg.targetVersion}`);
+                        }
+                        const sha = await execa('git', ['log', '-n', '1', '--pretty=format:%h', '--', '.'], {
+                            cwd: pkg.path,
+                        });
+                        const packageJson = loadRHSPackageJson(pkg);
+                        packageJson.version = pkg.targetVersion;
+                        packageJson.git = {
+                            ...packageJson.git,
+                            sha: sha.stdout,
+                        };
+                        if (input.scope) {
+                            const name = packageJson.name.split('/').at(-1);
+                            packageJson.name = `${input.scope}/${name}`;
+                        }
+                        const bumped = await getBumpedDependencies(ctx, { pkg });
+                        packageJson.dependencies = bumped.dependencies;
+                        packageJson.peerDependencies = bumped.peerDependencies;
+                        packageJson.optionalDependencies = bumped.optionalDependencies;
+                        fs.writeFileSync(packageJsonFilepath(pkg, RHS_FOLDER), sortPackageJson(JSON.stringify(packageJson, null, 2)));
+                    },
+                })));
+            },
+        },
+        {
+            title: 'Write changelogs',
+            task: async (ctx, task) => {
+                return task.newListr(ctx.packages.map(pkg => ({
+                    title: `Write ${pkg.name} changelog`,
+                    task: async () => getOrCreateChangelog(ctx, pkg),
+                })), { concurrent: true });
+            },
+        },
+        {
+            title: 'Diff packages',
+            task: (ctx, task) => task.newListr(ctx.packages.map(pkg => ({
+                title: `Diff ${pkg.name}`,
+                task: async (_ctx, subtask) => {
+                    const leftFolderPath = path.dirname(packageJsonFilepath(pkg, LHS_FOLDER));
+                    const rightFolderPath = path.dirname(packageJsonFilepath(pkg, RHS_FOLDER));
+                    const changesFolder = path.join(pkg.folder, 'changes');
+                    await fs.promises.mkdir(changesFolder, { recursive: true });
+                    const leftPackageJson = loadLHSPackageJson(pkg);
+                    const rightPackageJson = loadRHSPackageJson(pkg);
+                    if (!leftPackageJson) {
+                        subtask.output = 'No published version';
+                        return;
+                    }
+                    await execa('git', ['diff', '--no-index', leftFolderPath, rightFolderPath], {
+                        reject: false, // git diff --no-index implies --exit-code. So when there are changes it exits with 1
+                        stdout: {
+                            file: path.join(changesFolder, 'package.diff'),
+                        },
+                    });
+                    const leftRef = leftPackageJson.git?.sha;
+                    const rightRef = rightPackageJson?.git?.sha;
+                    if (!rightRef) {
+                        throw new Error(`No ref found for package.json preparing to be plubished for ${pkg.name}`);
+                    }
+                    if (leftRef && rightRef) {
+                        await execa('git', ['diff', leftRef, rightRef, '--', '.'], {
+                            cwd: pkg.path,
+                            stdout: {
+                                file: path.join(changesFolder, 'source.diff'),
+                            },
+                        });
+                    }
+                },
+            })), { concurrent: true }),
+        },
+        {
+            title: 'Write changelogs',
+            task: async (ctx, task) => {
+                return task.newListr(ctx.packages.map(pkg => ({
+                    title: `Write ${pkg.name} changelog`,
+                    task: async () => getOrCreateChangelog(ctx, pkg),
+                })), { concurrent: true });
+            },
+        },
+        {
+            title: 'Write context',
+            task: async (ctx) => {
+                fs.writeFileSync(path.join(ctx.tempDir, 'context.json'), JSON.stringify(ctx, null, 2));
+            },
+        },
+        {
+            title: ['Publish packages', !input.publish && '(dry run)'].filter(Boolean).join(' '),
+            rendererOptions: { persistentOutput: true },
+            task: async (ctx, task) => {
+                const shouldActuallyPublish = input.publish;
+                let otp = input.otp;
+                if (shouldActuallyPublish) {
+                    otp ||= await task.prompt(ListrEnquirerPromptAdapter).run({
+                        message: 'Enter npm OTP (press enter to try publishing without MFA)',
+                        type: 'Input',
+                        validate: v => v === '' || (typeof v === 'string' && /^\d{6}$/.test(v)),
+                    });
+                    if (otp.length === 0) {
+                        task.output = 'No OTP provided - publish will likely error unless you have disabled MFA.';
+                    }
+                }
+                const publishTasks = createPublishTasks(ctx, { otp });
+                if (!shouldActuallyPublish)
+                    publishTasks.forEach(t => (t.skip = true));
+                return task.newListr(publishTasks, { rendererOptions: { collapseSubtasks: false } });
+            },
+        },
+        {
+            title: 'Dry run complete',
+            enabled: !input.publish,
+            rendererOptions: { persistentOutput: true },
+            task: async (ctx, task) => {
+                task.output = `To publish, run the following command:`;
+                task.output += `\n\n`;
+                task.output += `pnpm npmono prebuilt ${ctx.tempDir}`;
+            },
+        },
+    ], { ctx: {} });
+    return tasks.run();
+};
+function loadContext(folderPath) {
+    const contextFilepath = path.join(folderPath, 'context.json');
+    if (!fs.existsSync(contextFilepath))
+        throw new Error(`No context found at ${contextFilepath}`);
+    const ctxString = fs.readFileSync(contextFilepath).toString();
+    try {
+        const json = JSON.parse(ctxString);
+        return Ctx.parse(json);
+    }
+    catch (e) {
+        throw new Error(`Invalid context at ${contextFilepath}: ${String(e)}`);
+    }
+}
+export const PrebuiltInput = z.tuple([
+    z.string().describe('Path to the prebuilt publishable folder'),
+    z.object({
+        otp: z.string().describe('OTP for publishing. If not provided, you will be prompted for it.').optional(),
+    }),
+]);
+export async function publishPrebuilt([folder, options]) {
+    const me = await execa('npm', ['whoami']);
+    if (me.exitCode)
+        throw new Error(`Failed to get npm username: ${me.stderr}`);
+    console.log(me.stdout, '<<<<<<< npm whoami');
+    const ctx = loadContext(folder);
+    const tasks = new Listr([
+        {
+            title: 'Get OTP',
+            enabled: !options.otp,
+            task: async (_ctx, task) => {
+                options.otp = await task.prompt(ListrEnquirerPromptAdapter).run({
+                    message: 'Enter npm OTP',
+                    type: 'Input',
+                    validate: v => v === '' || (typeof v === 'string' && /^\d{6}$/.test(v)),
+                });
+                if (options.otp === '') {
+                    const confirmed = await task.prompt(ListrEnquirerPromptAdapter).run({
+                        message: 'This will fail unless you have disabled MFA, which is not recommended.',
+                        type: 'confirm',
+                    });
+                    if (!confirmed) {
+                        throw new Error('OTP not provided');
+                    }
+                }
+            },
+        },
+        ...createPublishTasks(ctx, options),
+    ], { ctx });
+    await tasks.run();
+}
+function createPublishTasks(ctx, options) {
+    return [
+        ...ctx.packages.map((pkg) => {
+            const lhsPackageJson = loadLHSPackageJson(pkg);
+            const rhsPackageJson = loadRHSPackageJson(pkg);
+            ensureValidBumpedVersion(lhsPackageJson?.version || VERSION_ZERO, rhsPackageJson?.version);
+            return {
+                title: `Publish ${pkg.name} ${lhsPackageJson?.version || '✨NEW!✨'} -> ${rhsPackageJson?.version}`,
+                task: async (_ctx, subtask) => {
+                    const publishArgs = ['--access', 'public'];
+                    if (options.otp)
+                        publishArgs.push('--otp', options.otp);
+                    if (rhsPackageJson && semver.prerelease(rhsPackageJson.version)) {
+                        const first = semver.prerelease(rhsPackageJson.version)?.[0];
+                        const tag = typeof first === 'string' ? first : 'next';
+                        publishArgs.push('--tag', tag);
+                    }
+                    await pipeExeca(subtask, 'pnpm', ['publish', ...publishArgs], {
+                        cwd: path.dirname(packageJsonFilepath(pkg, RHS_FOLDER)),
+                        env: {
+                            ...process.env,
+                            COREPACK_ENABLE_AUTO_PIN: '0',
+                        },
+                    });
+                },
+            };
+        }),
+        {
+            title: 'Publish complete',
+            rendererOptions: { persistentOutput: true },
+            task: async (_ctx, task) => {
+                task.output = `To open a release draft, run the following command:`;
+                task.output += `\n\n`;
+                task.output += `pnpm npmono release-notes`;
+            },
+        },
+    ];
+}
+export const ReleaseNotesInput = z.object({
+    comparison: z
+        .string()
+        .regex(/^\S+\.{2,3}\S+$/)
+        .transform((s, ctx) => {
+        const [left, right, ...{ length: excess }] = s.split(/\.{2,3}/);
+        if (excess > 0) {
+            ctx.addIssue({ code: 'custom', message: `Invalid comparison (too many ellipses): ${s}` });
+            return z.NEVER;
+        }
+        return { left, right, original: s };
+    })
+        .optional()
+        .describe('The comparison to use for the release notes. Format: `left...right` e.g. `1.0.0...1.0.1`'),
+    mode: z
+        .enum(['individual', 'unified'])
+        .describe(`Only relevant in a monorepo - 'unified' mode drafts one release with all packages' changes, 'individual' drafts one release per package.`)
+        .default('unified'),
+    scope: z
+        .string()
+        .regex(/^@[\w-_.]+$/)
+        .describe('check for packages with this scope too')
+        .optional(),
+});
+async function pullRegistryPackage(subtask, pkg, { version, folder }) {
+    // note: `npm pack foobar` will actually pull foobar.1-2-3.tgz from the registry. It's not actually doing a "pack" at all. `pnpm pack` does not do the same thing - it packs the local directory
+    await pipeExeca(subtask, 'npm', ['pack', `${pkg.name}@${version}`], { cwd: folder });
+    const tgzFileName = fs.readdirSync(folder).at(0);
+    if (!tgzFileName) {
+        throw new Error(`No tgz file found in ${folder}, tried to pull ${pkg.name}@${version}`);
+    }
+    await pipeExeca(subtask, 'tar', ['-xvzf', tgzFileName], { cwd: folder });
+    const filepath = path.join(folder, 'package', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(filepath).toString());
+    return packageJson;
+}
+async function openReleaseDraft(repoUrl, params) {
+    const getUrl = () => `${repoUrl}/releases/new?${new URLSearchParams(params).toString()}`;
+    if (getUrl().length > 8192) {
+        // copy body to clipboard using clipboardy
+        const clipboardy = await import('clipboardy');
+        await clipboardy.default.write(params.body);
+        params = { ...params, body: '<!-- body copied to clipboard -->' };
+    }
+    await execa('open', [getUrl()]);
+}
+function packageJsonFilepath(pkg, type) {
+    return path.join(pkg.folder, type, 'package', 'package.json');
+}
+function loadPackageJson(filepath) {
+    const packageJson = JSON.parse(fs.readFileSync(filepath).toString());
+    return packageJson;
+}
+function loadLHSPackageJson(pkg) {
+    const filepath = packageJsonFilepath(pkg, LHS_FOLDER);
+    if (!fs.existsSync(filepath))
+        return null;
+    return JSON.parse(fs.readFileSync(filepath).toString());
+}
+function loadRHSPackageJson(pkg) {
+    const filepath = packageJsonFilepath(pkg, RHS_FOLDER);
+    if (!fs.existsSync(filepath))
+        return null;
+    return JSON.parse(fs.readFileSync(filepath).toString());
+}
+function bumpChoices(oldVersion) {
+    const releaseTypes = allReleaseTypes.filter(r => r !== 'prerelease');
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    semver.prerelease(oldVersion) ? releaseTypes.unshift('prerelease') : releaseTypes.push('prerelease');
+    return [
+        ...releaseTypes.map(type => {
+            const result = semver.inc(oldVersion, type);
+            return {
+                type: type,
+                message: `${type} ${result}`,
+                value: result,
+            };
+        }),
+        {
+            type: 'other',
+            message: 'Other (please specify)',
+            value: 'other',
+        },
+    ];
+}
+function ensureValidBumpedVersion(lowerBoundVersion, v) {
+    const validation = getBumpedVersionValidation(lowerBoundVersion, v);
+    if (validation !== true)
+        throw new Error(`Invalid bumped version ${v}: ${validation || 'invalid'}`);
+}
+function getBumpedVersionValidation(lowerBoundVersion, v) {
+    if (typeof v !== 'string')
+        return 'Must be a string';
+    if (!semver.valid(v))
+        return 'Must be a valid semver version';
+    if (!semver.gt(v, lowerBoundVersion || VERSION_ZERO))
+        return `Must be greater than the current version ${lowerBoundVersion}`;
+    return true;
+}
+function getWorkspaceRoot() {
+    return path.dirname(findUpSync('pnpm-workspace.yaml') || findUpSync('pnpm-lock.yaml') || findUpOrThrow('.git', { type: 'directory' }));
+}
+/** "Pessimistic" comparison ref. Tries to use the registry package.json's `git.sha` property, falls back to a matching version tag, and if neither exists prompts the user (with the first commit to the package folder as the default). */
+async function getPackageLastPublishRef(pkg, task) {
+    const packageJson = loadLHSPackageJson(pkg);
+    return first7(await getPackageJsonGitSha(pkg, packageJson, task));
+}
+const first7 = (s) => s.slice(0, 7);
+async function getPackageJsonGitSha(pkg, packageJson, task) {
+    const explicitSha = packageJson?.git?.sha;
+    if (explicitSha)
+        return explicitSha;
+    const tagSha = await getPackageJsonShaFromVersionTag(pkg, packageJson);
+    if (tagSha)
+        return tagSha;
+    const firstRef = await getFirstRef(pkg);
+    const { stdout: recentCommits } = await execa('git', ['log', '-n', '20', '--pretty=format:%h %s', '--', '.'], { cwd: pkg.path, reject: false });
+    const commitLines = recentCommits.split('\n').filter(Boolean);
+    if (packageJson?.version) {
+        const versionCommitMessage = `version ${packageJson.version}`;
+        const match = commitLines.find(line => line.slice(line.indexOf(' ') + 1) === versionCommitMessage);
+        if (match)
+            return match.split(' ', 1)[0];
+    }
+    const oldestShownSha = commitLines.at(-1)?.split(' ', 1)[0];
+    const repoUrl = getPackageJsonRepository(loadRHSPackageJson(pkg) || loadLHSPackageJson(pkg) || loadPackageJson(path.join(getWorkspaceRoot(), 'package.json')));
+    const olderUrl = repoUrl && oldestShownSha ? `\nOlder commits: ${repoUrl}/commits/${oldestShownSha}` : '';
+    const recentList = commitLines.length ? `\nRecent commits in ${pkg.path}:\n${commitLines.join('\n')}${olderUrl}\n` : '';
+    const promptAnswer = await task.prompt(ListrEnquirerPromptAdapter).run({
+        type: 'Input',
+        message: `Couldn't find a git sha for the last published version of ${pkg.name}.${recentList}\nEnter the sha to diff from (leave empty to use ${firstRef.slice(0, 7)}, the first commit in ${pkg.path}):`,
+        validate: (v) => {
+            if (typeof v !== 'string')
+                return 'Enter a sha, or leave empty to use the first commit.';
+            if (!v.trim())
+                return true;
+            return /^[0-9a-f]{4,40}$/i.test(v.trim()) ? true : 'Enter a valid git sha (4-40 hex chars) or leave empty.';
+        },
+    });
+    return promptAnswer.trim() || firstRef;
+}
+async function getPackageJsonShaFromVersionTag(pkg, packageJson) {
+    // throw new Error(
+    //   `Getting ${pkg.name} (${packageJson?.version}) sha from version tag. v[] thing: ${packageJson?.version ? (await execa('git', ['log', '-n', '1', `v${packageJson?.version}`], {cwd: pkg.path})).stdout : JSON.stringify({pkg, packageJson}, null, 2)}`,
+    // )
+    if (!packageJson?.version)
+        return null;
+    const { stdout: vTagSha } = await execa('git', ['rev-list', '-n', '1', `v${packageJson.version}`], {
+        cwd: pkg.path,
+        reject: false,
+    });
+    if (vTagSha)
+        return vTagSha;
+    const { stdout: tagSha } = await execa('git', ['rev-list', '-n', '1', packageJson.version], {
+        cwd: pkg.path,
+        reject: false,
+    });
+    return tagSha;
+}
+async function getFirstRef(pkg) {
+    const { stdout: commitsOldestFirst } = await execa('git', ['log', '--reverse', '--pretty=format:%h', '--', '.'], {
+        cwd: pkg.path,
+    });
+    return commitsOldestFirst.split('\n')[0];
+}
+const DEP_SECTIONS = ['dependencies', 'peerDependencies', 'optionalDependencies'];
+/**
+ * For a particular package, get the `dependencies` / `peerDependencies` / `optionalDependencies`
+ * objects with any necessary version bumps. Each workspace dep is written back to whichever
+ * section it was originally in, so peer/optional deps aren't silently promoted to regular deps.
+ */
+async function getBumpedDependencies(ctx, params) {
+    const leftPackageJson = loadLHSPackageJson(params.pkg);
+    const rightPackageJson = loadRHSPackageJson(params.pkg);
+    const bumped = {
+        dependencies: rightPackageJson?.dependencies && { ...rightPackageJson.dependencies },
+        peerDependencies: rightPackageJson?.peerDependencies && { ...rightPackageJson.peerDependencies },
+        optionalDependencies: rightPackageJson?.optionalDependencies && { ...rightPackageJson.optionalDependencies },
+    };
+    const updates = {};
+    for (const depName of Object.keys(params.pkg.dependencies || {})) {
+        const foundDep = ctx.packages.find(other => other.name === depName);
+        if (!foundDep)
+            throw new Error(`Package ${params.pkg.name} depends on ${depName} but ${depName} is not found in the workspace`);
+        let expected = foundDep.targetVersion;
+        if (!expected) {
+            const dependencyPackageJsonOnRHS = loadRHSPackageJson(foundDep);
+            expected = dependencyPackageJsonOnRHS?.version || null;
+        }
+        if (!expected) {
+            throw new Error(`Package ${params.pkg.name} depends on ${depName} but ${depName} is not published, and no target version was set for publishing now. Did you opt to skip publishing ${depName}? If so, please re-run and make sure to publish ${depName}. You can't publish ${params.pkg.name} until you do that.`);
+        }
+        const section = DEP_SECTIONS.find(s => rightPackageJson?.[s]?.[depName]) ||
+            DEP_SECTIONS.find(s => leftPackageJson?.[s]?.[depName]) ||
+            'dependencies';
+        const currentVersionInSection = rightPackageJson?.[section]?.[depName];
+        let prefix = ['^', '~', ''].find(p => currentVersionInSection?.startsWith(p)) || '';
+        if (semver.prerelease(expected)) {
+            prefix = '';
+        }
+        const newVersion = prefix + expected;
+        bumped[section] = { ...bumped[section], [depName]: newVersion };
+        const leftVersion = leftPackageJson?.dependencies?.[depName] ||
+            leftPackageJson?.peerDependencies?.[depName] ||
+            leftPackageJson?.optionalDependencies?.[depName];
+        updates[depName] = `${leftVersion || '(new)'} -> ${newVersion}`;
+    }
+    if (Object.keys(updates).length === 0) {
+        // keep reference equality, avoid `undefined` -> `{}` churn
+        return {
+            updated: updates,
+            dependencies: rightPackageJson?.dependencies,
+            peerDependencies: rightPackageJson?.peerDependencies,
+            optionalDependencies: rightPackageJson?.optionalDependencies,
+        };
+    }
+    return { updated: updates, ...bumped };
+}
+/** Get a markdown formatted list of commits for a package. */
+async function getPackageRevList(pkg) {
+    // const fromRef = await getPackageLastPublishRef(pkg)
+    // const {stdout: localRef} = await execa('git', ['log', '-n', '1', '--pretty=format:%h', '--', '.'])
+    const fromRef = pkg.shas.left;
+    const localRef = pkg.shas.right;
+    const { stdout } = await execa('git', ['rev-list', '--ancestry-path', `${fromRef}...${localRef}`, '--format=oneline', '--abbrev-commit', '--', '.'], { cwd: pkg.path });
+    const { stdout: mergeBase } = await execa('git', ['merge-base', fromRef, localRef]);
+    let mergeBaseNote = '';
+    if (mergeBase.slice(0, 7) !== fromRef.slice(0, 7)) {
+        const { stdout: mergeBaseSummary } = await execa('git', ['log', '-n', '1', '--format=%h %s (%ad)', mergeBase]);
+        mergeBaseNote = `\n🚧🚧 NOTE 🚧🚧: ${localRef} (current) is not a descendant of ${fromRef} (last publish). The last publish may have beendone on a separate branch. The merge base is:\n${mergeBaseSummary}`;
+    }
+    const { stdout: uncommitedChanges } = await execa('git', ['status', '--porcelain', '--', '.'], {
+        cwd: pkg.path,
+    });
+    const commitBullets = stdout
+        .split('\n')
+        .filter(Boolean)
+        .map(line => `- ${line}`);
+    const sections = [
+        commitBullets.length > 0 && `<h3 data-commits>Commits</h3>\n`,
+        ...commitBullets,
+        uncommitedChanges.trim() && 'Uncommitted changes:\n' + uncommitedChanges,
+        mergeBaseNote,
+    ];
+    return {
+        commitBullets,
+        // commitComparisonString,
+        // versionComparisonString,
+        markdown: sections.filter(Boolean).join('\n').trim() ||
+            `No commits to ${pkg.name} between found between ${fromRef.slice(0, 7)} (last publish) and ${localRef.slice(0, 7)} (current).`,
+    };
+}
+const changelogFilepath = (pkg) => path.join(pkg.folder, 'changes/changelog.md');
+function workspaceDependencies(pkg, ctx, depth = 0) {
+    return Object.keys(pkg.dependencies || {}).flatMap(name => {
+        const dep = ctx.packages.find(p => p.name === name);
+        return dep ? [dep, ...(depth > 0 ? workspaceDependencies(dep, ctx, depth - 1) : [])] : [];
+    });
+}
+/**
+ * Creates a changelog.md and returns its content. If one already exists, its content is returned without being regenerated.
+ * Note: this recursively calls itself on finding workspace dependencies so will cause stack overflows if there are dependency loops.
+ * It's important that this is called in toplogical order, so that dependency changelogs are accurate.
+ */
+async function getOrCreateChangelog(ctx, pkg) {
+    const changelogFile = changelogFilepath(pkg);
+    if (fs.existsSync(changelogFile)) {
+        const existingContent = fs.readFileSync(changelogFile).toString();
+        // hack: sometimes we get a changelog a bit early before the targetVersion is set. Check that the existing version doesn't include 'undefined' so we can try again after the targetVersion is set.
+        if (!existingContent.includes('undefined')) {
+            return existingContent;
+        }
+    }
+    const changelogContent = await getChangelog(ctx, pkg);
+    fs.mkdirSync(path.dirname(changelogFile), { recursive: true });
+    fs.writeFileSync(changelogFile, changelogContent);
+    return changelogContent;
+}
+async function getChangelog(ctx, pkg) {
+    const sourceChanges = await getPackageRevList(pkg);
+    const npmVersionLink = (packageJson) => {
+        const version = packageJson?.version;
+        return `[${version || 'unknown'}](https://npmjs.com/package/${pkg.name}${version ? `/v/${version}` : ''})`;
+    };
+    const repoUrl = getPackageJsonRepository(loadRHSPackageJson(pkg) ||
+        loadLHSPackageJson(pkg) ||
+        loadPackageJson(path.join(getWorkspaceRoot(), 'package.json')));
+    const changes = [];
+    if (sourceChanges) {
+        changes.push([
+            `<!-- data-change-type="source" data-pkg="${pkg.name}" -->`, // break
+            `# ${pkg.name}`,
+            '',
+            '|old version|new version|compare|',
+            '|-|-|-|',
+            `|${npmVersionLink(loadLHSPackageJson(pkg))} | ${npmVersionLink(loadRHSPackageJson(pkg))} | [${pkg.shas.left}...${pkg.shas.right}](${repoUrl}/compare/${pkg.shas.left}...${pkg.shas.right})`,
+            '',
+            sourceChanges.markdown,
+        ].join('\n'));
+    }
+    const bumpedDeps = await getBumpedDependencies(ctx, { pkg });
+    // reverse order of pkg dependencies so the most interesting ones go first
+    for (const depPkg of workspaceDependencies(pkg, ctx).slice().reverse()) {
+        const dep = depPkg.name;
+        if (bumpedDeps.updated[dep]) {
+            const depChanges = await getChangelog(ctx, depPkg);
+            const verb = depChanges?.includes('data-commits') ? 'changed' : 'bumped';
+            const newMessage = [
+                '<!-- data-change-type="dependencies" -->',
+                `<details>`,
+                `<summary>Dependency ${depPkg.name} ${verb} (${bumpedDeps.updated[dep]})</summary>`,
+                '',
+                '<blockquote>',
+                depChanges
+                    .split('\n')
+                    .filter(line => !/^<!-- data-change-type=".*" -->$/.test(line))
+                    .map(line => (line.trim() ? `${line}` : line))
+                    .join('\n') || `${bumpedDeps.updated[dep]} (Version bump)`,
+                '</blockquote>',
+                '</details>',
+            ].join('\n');
+            changes.push(newMessage);
+        }
+    }
+    const changelogContent = changes.filter(Boolean).join('\n\n');
+    return changelogContent;
+}
+/** lovely algorith which i think supports all the ways a repository can be specified */
+function getPackageJsonRepository(packageJson) {
+    let repoString;
+    if (!packageJson.repository)
+        return null;
+    if (typeof packageJson.repository === 'object' && packageJson.repository.type !== 'git') {
+        throw new Error(`Unsupported repository type ${packageJson.repository.type}`);
+    }
+    // mmkal
+    // eslint-disable-next-line unicorn/prefer-ternary
+    if (typeof packageJson.repository === 'object') {
+        repoString = packageJson.repository.url;
+    }
+    else {
+        // must be a string
+        repoString = packageJson.repository;
+    }
+    if (repoString.startsWith('git+')) {
+        repoString = repoString.replace('git+', '');
+    }
+    if (repoString.startsWith('github:')) {
+        repoString = repoString.replace('github:', 'https://github.com/');
+    }
+    if (repoString.startsWith('gitlab:')) {
+        repoString = repoString.replace('gitlab:', 'https://gitlab.com/');
+    }
+    if (repoString.startsWith('bitbucket:')) {
+        repoString = repoString.replace('bitbucket:', 'https://bitbucket.org/');
+    }
+    if (repoString.endsWith('.git')) {
+        repoString = repoString.slice(0, -4);
+    }
+    if (/^[\w-.]+\/[\w-.]+$/.test(repoString)) {
+        repoString = `https://github.com/${repoString}`;
+    }
+    const url = new URL(repoString);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new Error(`Unsupported repository protocol ${url.protocol}`);
+    }
+    return repoString;
+}
+const allReleaseTypes = [
+    'patch',
+    'minor',
+    'major',
+    'prepatch',
+    'preminor',
+    'premajor',
+    'prerelease',
+];
+const PackageJson = z.object({
+    name: z.string(),
+    version: z.string(),
+    dependencies: z.record(z.string(), z.string()).optional(),
+    peerDependencies: z.record(z.string(), z.string()).optional(),
+    optionalDependencies: z.record(z.string(), z.string()).optional(),
+    scripts: z.record(z.string(), z.string()).optional(),
+    /**
+     * not an official package.json field, but there is a library that does something similar to this: https://github.com/Metnew/git-hash-package
+     * having git.sha point to a commit hash seems pretty useful to me, even if it's not standard.
+     * tagging versions in git is still a good best practice but there are many different ways, e.g. `1.2.3` vs `v1.2.3` vs `mypkg@1.2.3` vs `mypkg@v1.2.3`
+     * plus, that's only useful in going from git to npm, not npm to git.
+     */
+    git: z.object({ sha: z.string().optional() }).optional(),
+    repository: z
+        .object({
+        type: z.string(),
+        url: z.string(),
+    })
+        .optional(),
+});
+const PkgMeta = z.object({
+    folder: z.string(),
+    targetVersion: z.string().nullable(),
+    changeTypes: z.set(z.string()).optional(),
+    shas: z.object({
+        left: z.string(),
+        right: z.string(),
+    }),
+});
+const Pkg = PkgMeta.extend({
+    name: z.string(),
+    version: z.string(),
+    path: z.string(),
+    private: z.boolean(),
+    publishedVersions: z.array(z.string()),
+    dependencies: z
+        .record(z.string(), z.object({
+        from: z.string(),
+        version: z.string(),
+        path: z.string(),
+    }))
+        .optional(),
+});
+export const Ctx = z.object({
+    tempDir: z.string(),
+    versionStrategy: z.union([
+        z.object({ type: z.literal('fixed'), version: z.string() }).readonly(),
+        z
+            .object({
+            type: z.literal('independent'),
+            bump: z.union([
+                z.enum(['patch', 'minor', 'major', 'prepatch', 'preminor', 'premajor', 'prerelease']),
+                z.null(),
+            ]),
+        })
+            .readonly(),
+    ]),
+    packages: z.array(Pkg),
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function pipeExeca(task, file, args, options) {
+    const cmd = execa(file, args, {
+        ...options,
+        env: {
+            ...options?.env,
+            COREPACK_ENABLE_STRICT: '0',
+        },
+    });
+    cmd.stdout.pipe(task.stdout());
+    return cmd;
+}
+function findUpOrThrow(file, options) {
+    const result = findUpSync(file, options);
+    if (!result) {
+        throw new Error(`Could not find ${file}`);
+    }
+    return result;
+}
+export async function releaseNotes(input) {
+    const tasks = new Listr([
+        ...setupContextTasks,
+        {
+            title: `Get comparison`,
+            enabled: () => !input.comparison,
+            task: async (ctx, task) => {
+                const pkgVersions = await Promise.all(ctx.packages.map(async (pkg) => ({
+                    name: pkg.name,
+                    versions: await getRegistryVersions(pkg),
+                })));
+                if (pkgVersions.some(v => v.versions.length === 0)) {
+                    throw new Error(`No versions found for some packages: ${JSON.stringify({ pkgVersions }, null, 2)}`);
+                }
+                const lasts = pkgVersions.map(v => v.versions.at(-1).slice());
+                const latest = lasts.sort((a, b) => semver.compare(a, b)).at(-1);
+                const all = pkgVersions.flatMap(v => v.versions).sort((a, b) => semver.compare(a, b));
+                const left = all
+                    .slice(0, -1)
+                    .reverse()
+                    .find(v => {
+                    if (v === latest)
+                        return false;
+                    if (semver.prerelease(latest))
+                        return true; // if RHS is prerelease, then we whichever version was immediately before it
+                    return !semver.prerelease(v); // if RHS was a proper release, then we want the last proper release
+                }) || all[0];
+                input.comparison = { left, right: latest, original: `${left}...${latest}` };
+                task.output = `Using ${input.comparison.original} for release notes`;
+            },
+            rendererOptions: { persistentOutput: true },
+        },
+        {
+            title: 'Write packages locally',
+            task: async (ctx, task) => {
+                return task.newListr(ctx.packages.map(pkg => ({
+                    title: `Write ${pkg.name} locally`,
+                    task: async (_ctx, subtask) => {
+                        if (!input.comparison)
+                            throw new Error('No comparison provided');
+                        const pullables = [
+                            { str: input.comparison.left, folder: path.join(pkg.folder, LHS_FOLDER), side: 'left' },
+                            { str: input.comparison.right, folder: path.join(pkg.folder, RHS_FOLDER), side: 'right' },
+                        ];
+                        for (const pullable of pullables) {
+                            fs.mkdirSync(pullable.folder, { recursive: true });
+                            if (semver.valid(pullable.str)) {
+                                if (pullable.side === 'right')
+                                    pkg.targetVersion = pullable.str;
+                                subtask.output = `Pulling ${pullable.str} for ${pkg.name}`;
+                                const packageJson = await pullRegistryPackage(subtask, pkg, {
+                                    version: pullable.str,
+                                    folder: pullable.folder,
+                                })
+                                    .catch(e => {
+                                    if (`${e}`.includes('No matching version found') && input.scope) {
+                                        const scopedPkg = { ...pkg, name: `${input.scope}/${pkg.name}` };
+                                        return pullRegistryPackage(subtask, scopedPkg, {
+                                            version: pullable.str,
+                                            folder: pullable.folder,
+                                        });
+                                    }
+                                    throw e;
+                                })
+                                    .catch(async (e) => {
+                                    if (`${e}`.includes('No matching version found')) {
+                                        // if the version doesn't exist on the registry, we might have passed a comparison string from before it existed (can happen with fixed versioning)
+                                        const versions = await getRegistryVersions(pkg);
+                                        return pullRegistryPackage(subtask, pkg, {
+                                            version: pullable.side === 'left' ? versions[0] : versions.at(-1),
+                                            folder: pullable.folder,
+                                        });
+                                    }
+                                    throw e;
+                                });
+                                pkg.shas ||= {};
+                                pkg.shas[pullable.side] = await getPackageJsonGitSha(pkg, packageJson, subtask);
+                            }
+                            else if (/^[\da-f]+/.test(pullable.str)) {
+                                // actually it's a sha
+                                pkg.shas ||= {};
+                                pkg.shas[pullable.side] = pullable.str;
+                                const versions = await getRegistryVersions(pkg);
+                                for (const version of versions.slice().reverse()) {
+                                    subtask.output = `Pulling ${version} for ${pkg.name}`;
+                                    const packedPackageJson = await pullRegistryPackage(subtask, pkg, {
+                                        version,
+                                        folder: pullable.folder,
+                                    });
+                                    if (packedPackageJson.git?.sha === pullable.str) {
+                                        if (pullable.side === 'right')
+                                            pkg.targetVersion = packedPackageJson.version;
+                                        break;
+                                    }
+                                }
+                            }
+                            else {
+                                throw new Error(`Unknown release ${pullable.str} for ${pkg.name}`);
+                            }
+                        }
+                    },
+                })), { concurrent: true });
+            },
+        },
+        {
+            title: 'Write changelogs',
+            task: async (ctx, task) => {
+                return task.newListr(ctx.packages.map(pkg => ({
+                    title: `Write ${pkg.name} changelog`,
+                    task: async () => getOrCreateChangelog(ctx, pkg),
+                })), { concurrent: true });
+            },
+        },
+        {
+            title: 'Generate release notes',
+            rendererOptions: { persistentOutput: true },
+            task: async (ctx, task) => {
+                const allChangelogs = await Promise.all(ctx.packages.map(async (pkg) => ({
+                    pkg,
+                    changelog: await getOrCreateChangelog(ctx, pkg),
+                })));
+                const rootPackageJson = loadPackageJson(path.join(getWorkspaceRoot(), 'package.json'));
+                const repoUrl = getPackageJsonRepository(rootPackageJson);
+                if (!repoUrl) {
+                    const message = 'No repository URL found in root package.json - please add a repository field like `"repository": {"type": "git", "url": "https://githbu.com/foo/bar"}`';
+                    throw new Error(message);
+                }
+                const versions = [
+                    ...new Set(ctx.packages.map(p => (p.targetVersion ? `v${p.targetVersion}` : '')).filter(Boolean)),
+                ];
+                if (input.mode === 'unified') {
+                    if (versions.length !== 1) {
+                        throw new Error('Unified mode requires exactly one version');
+                    }
+                    const unified = allChangelogs.map(p => p.changelog).join('\n\n---\n\n');
+                    const doRelease = await task.prompt(ListrEnquirerPromptAdapter).run({
+                        type: 'confirm',
+                        message: unified + '\n\nDraft release?',
+                    });
+                    if (doRelease) {
+                        const releaseParams = {
+                            tag: versions[0],
+                            title: versions[0],
+                            body: unified,
+                        };
+                        // await execa('open', [`${repoUrl}/releases/new?${new URLSearchParams(releaseParams).toString()}`])
+                        await openReleaseDraft(repoUrl, releaseParams);
+                        task.output = 'Release draft opened';
+                    }
+                    else {
+                        task.output = 'Skipping release';
+                    }
+                }
+                else {
+                    for (const pkg of ctx.packages) {
+                        const body = await getOrCreateChangelog(ctx, pkg);
+                        const title = `${pkg.name}@v${pkg.targetVersion}`;
+                        const tag = `${pkg.name}@v${pkg.targetVersion}`; // same as title... today
+                        const message = `👇👇👇${title} changelog👇👇👇\n\n${body}\n\n👆👆👆${title} changelog👆👆👆`;
+                        const doRelease = await task.prompt(ListrEnquirerPromptAdapter).run({
+                            type: 'confirm',
+                            message: message + '\n\nDraft release?',
+                            initial: false,
+                        });
+                        if (doRelease) {
+                            const releaseParams = { tag, title, body };
+                            await openReleaseDraft(repoUrl, releaseParams);
+                        }
+                    }
+                }
+            },
+        },
+    ], { ctx: {} });
+    await tasks.run();
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "mopub",
+  "version": "0.0.1",
+  "description": "Publish packages in a pnpm monorepo",
+  "type": "module",
+  "bin": {
+    "mopub": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "ISC",
+  "dependencies": {
+    "@listr2/prompt-adapter-enquirer": "^4.2.1",
+    "@trpc/server": "^11.16.0",
+    "clipboardy": "^5.3.1",
+    "execa": "^9.6.1",
+    "find-up": "^8.0.0",
+    "listr2": "^10.2.1",
+    "semver": "^7.7.4",
+    "sort-package-json": "^3.6.1",
+    "trpc-cli": "^0.14.0",
+    "type-fest": "^5.6.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@types/semver": "^7.7.1",
+    "eslint": "^10.2.1",
+    "eslint-plugin-mmkal": "^0.11.3",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "dogfood": "tsx src/cli",
+    "build": "tsc --noEmit false --outDir dist",
+    "lint": "eslint .",
+    "test": "echo maybe later"
+  }
+}