@mui/internal-code-infra 0.0.4-canary.10 → 0.0.4-canary.100

package/src/cli/cmdPublishCanary.mjs

@@ -93,7 +93,11 @@ async function fetchCommitsForPackage({ packagePath }) {
   return results;
 }
 
-const AUTHOR_EXCLUDE_LIST = ['renovate[bot]', 'dependabot[bot]'];
+const AUTHOR_EXCLUDE_LIST = new Set([
+  'renovate[bot]',
+  'dependabot[bot]',
+  'code-infra-renovate[bot]',
+]);
 
 /**
  * @param {string} message
@@ -144,7 +148,7 @@ async function prepareChangelogsFromGitCli(packagesToPublish, allPackages, canar
         // Exclude commits authored by bots
         .filter(
           // We want to allow commits from copilot or other AI tools, so only filter known bots
-          (commit) => !AUTHOR_EXCLUDE_LIST.includes(commit.author),
+          (commit) => !AUTHOR_EXCLUDE_LIST.has(commit.author),
         )
         .map((commit) => `- ${cleanupCommitMessage(commit.message)} by ${commit.author}`);
 
@@ -159,7 +163,10 @@ async function prepareChangelogsFromGitCli(packagesToPublish, allPackages, canar
 
   const transitiveDepSets = await Promise.all(
     allPackages.map((pkg) =>
-      getTransitiveDependencies([pkg.name], { includeDev: false, workspacePathByName }),
+      getTransitiveDependencies([pkg.name], {
+        includeDev: false,
+        workspacePathByName,
+      }),
     ),
   );
 
@@ -225,6 +232,41 @@ async function prepareChangelogsForPackages(packagesToPublish, allPackages, cana
   return changelogs;
 }
 
+/**
+ * Create or replace a GitHub release. Attempts to create the release first,
+ * and if it already exists (422), deletes the existing one and retries.
+ *
+ * @param {InstanceType<typeof Octokit>} octokit
+ * @param {NonNullable<Parameters<Octokit['repos']['createRelease']>[0]>} params
+ */
+async function upsertGitHubRelease(octokit, params) {
+  try {
+    return await octokit.repos.createRelease(params);
+  } catch (/** @type {any} */ error) {
+    const isAlreadyExists =
+      error.status === 422 &&
+      error.response?.data?.errors?.some(
+        (/** @type {any} */ err) => err.code === 'already_exists' && err.field === 'tag_name',
+      );
+    if (!isAlreadyExists) {
+      throw error;
+    }
+  }
+
+  // Release already exists — delete and recreate
+  const existing = await octokit.repos.getReleaseByTag({
+    owner: params.owner,
+    repo: params.repo,
+    tag: params.tag_name,
+  });
+  await octokit.repos.deleteRelease({
+    owner: params.owner,
+    repo: params.repo,
+    release_id: existing.data.id,
+  });
+  return octokit.repos.createRelease(params);
+}
+
 /**
  * Create GitHub releases and tags for published packages
  * @param {PublicPackage[]} publishedPackages - Packages that were published
@@ -277,15 +319,20 @@ async function createGitHubReleasesForPackages(
           GIT_COMMITTER_NAME: 'Code infra',
           GIT_COMMITTER_EMAIL: 'code-infra@mui.com',
         },
-      })`git tag -a ${tagName} -m ${`Canary release ${pkg.name}@${version}`}`;
+      })`git tag -fa ${tagName} -m ${`Canary release ${pkg.name}@${version}`}`;
 
+      // Force-push to handle retries where the tag already exists from a previous
+      // failed publish. The npm registry is the source of truth for published
+      // versions, so it's safe to rewrite a tag even if it points to a different
+      // commit — it just means the prior publish for this version failed partway
+      // through and the GitHub release needs to be recreated.
       // eslint-disable-next-line no-await-in-loop
-      await $`git push origin ${tagName}`;
+      await $`git push --force origin ${tagName}`;
       console.log(`✅ Created and pushed git tag: ${tagName}`);
 
       // Create GitHub release
       // eslint-disable-next-line no-await-in-loop
-      const res = await octokit.repos.createRelease({
+      const res = await upsertGitHubRelease(octokit, {
         owner: repoInfo.owner,
         repo: repoInfo.repo,
         tag_name: tagName,
@@ -315,7 +362,14 @@ async function getLastCanaryTag() {
     // Tag might not exist locally, which is fine
   }
 
-  await $`git fetch origin tag ${CANARY_TAG}`;
+  try {
+    await $`git fetch origin tag ${CANARY_TAG}`;
+  } catch (err) {
+    // Tag might not exist on the remote yet (first canary run), which is fine
+    if (!(/** @type {Error} */ (err).message?.includes("couldn't find remote ref"))) {
+      throw err;
+    }
+  }
   const { stdout: remoteCanaryTag } = await $`git ls-remote --tags origin ${CANARY_TAG}`;
   return remoteCanaryTag.trim() ? CANARY_TAG : null;
 }
@@ -427,20 +481,23 @@ async function publishCanaryVersions(
   }
 
   // Third pass: publish only the changed packages using recursive publish
-  let publishSuccess = false;
+  /** @type {Set<string>} */
+  const publishedNames = new Set();
   try {
     console.log(`📤 Publishing ${packagesToPublish.length} canary versions...`);
-    await publishPackages(packagesToPublish, {
+    const publishedPackages = await publishPackages(packagesToPublish, {
       dryRun: options.dryRun,
       noGitChecks: true,
       tag: CANARY_TAG,
     });
 
-    packagesToPublish.forEach((pkg) => {
-      const canaryVersion = canaryVersions.get(pkg.name);
-      console.log(`✅ Published ${pkg.name}@${canaryVersion}`);
-    });
-    publishSuccess = true;
+    // Only use package names from the report summary, not versions.
+    // pnpm-publish-summary.json reports the version from the workspace
+    // package.json, which is wrong for packages with publishConfig.directory.
+    for (const { name } of publishedPackages) {
+      publishedNames.add(name);
+      console.log(`✅ Published ${name}@${canaryVersions.get(name)}`);
+    }
   } finally {
     // Always restore original package.json files in parallel
     console.log('\n🔄 Restoring original package.json files...');
@@ -454,16 +511,26 @@ async function publishCanaryVersions(
     await Promise.all(restorePromises);
   }
 
-  if (publishSuccess) {
-    // Create/update the canary tag after successful publish
-    await createCanaryTag(options.dryRun);
-
-    // Create GitHub releases if requested
+  if (publishedNames.size > 0) {
+    // Create GitHub releases only for actually published packages
     if (options.githubRelease) {
-      await createGitHubReleasesForPackages(packagesToPublish, canaryVersions, changelogs, options);
+      const actuallyPublished = packagesToPublish.filter((pkg) => publishedNames.has(pkg.name));
+      await createGitHubReleasesForPackages(actuallyPublished, canaryVersions, changelogs, options);
     }
 
-    console.log('\n🎉 All canary versions published successfully!');
+    // Only advance the canary tag if all expected packages were published.
+    // Otherwise the tag would skip over unpublished packages and they'd
+    // never be retried on the next run.
+    const missing = packagesToPublish.filter((pkg) => !publishedNames.has(pkg.name));
+    if (missing.length === 0) {
+      await createCanaryTag(options.dryRun);
+      console.log('\n🎉 All canary versions published successfully!');
+    } else {
+      const missingNames = missing.map((pkg) => pkg.name).join(', ');
+      console.warn(
+        `\n⚠️  Canary tag not advanced, some packages failed to publish: ${missingNames}`,
+      );
+    }
   }
 }
 
@@ -520,9 +587,14 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       const { issues } = await validatePublishDependencies(filteredPackages);
 
       if (issues.length > 0) {
-        throw new Error('Invalid dependencies structure of packages to be published.', {
-          cause: issues,
-        });
+        throw new Error(
+          `Invalid dependencies structure of packages to be published -
+  ${issues.join('\n  ')}
+`,
+          {
+            cause: issues,
+          },
+        );
       }
 
       console.log('✅ All workspace dependency requirements satisfied');

package/src/cli/cmdPublishNewPackage.mjs

@@ -11,25 +11,44 @@ import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 
 import { getRepositoryInfo } from '../utils/git.mjs';
 import { toPosixPath } from '../utils/path.mjs';
-import { getWorkspacePackages } from '../utils/pnpm.mjs';
+import { getPackagesNeedingManualPublish, getWorkspacePackages } from '../utils/pnpm.mjs';
 
 /**
  * @typedef {Object} Args
  * @property {boolean} [dryRun] If true, will only log the commands without executing them
+ * @property {string} [otp] 6 digit auth code to forward to npm for two-factor authentication
  */
 
 export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
   command: 'publish-new-package [pkg...]',
   describe: 'Publish new empty package(s) to the npm registry.',
   builder: (yargs) =>
-    yargs.option('dryRun', {
-      type: 'boolean',
-      default: false,
-      description: 'If true, will only log the commands without executing them.',
-    }),
+    yargs
+      .option('dryRun', {
+        type: 'boolean',
+        default: false,
+        description: 'If true, will only log the commands without executing them.',
+      })
+      .option('otp', {
+        type: 'string',
+        description: '6 digit auth code to forward to npm for two-factor authentication.',
+        coerce: (value) => {
+          if (value === undefined) {
+            return value;
+          }
+
+          if (!/^\d{6}$/.test(value)) {
+            throw new Error('The --otp option must be a 6 digit number.');
+          }
+
+          return value;
+        },
+      }),
   async handler(args) {
     console.log(`🔍 Detecting new packages to publish in workspace...`);
-    const newPackages = await getWorkspacePackages({ nonPublishedOnly: true });
+    const newPackages = await getPackagesNeedingManualPublish(
+      await getWorkspacePackages({ publicOnly: true }),
+    );
 
     if (!newPackages.length) {
       console.log('No new packages to publish.');
@@ -62,7 +81,7 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
             version: '0.0.1',
             repository: {
               type: 'git',
-              url: `git+https://github.com/${repo.owner}/${repo.remoteName}.git`,
+              url: `git+https://github.com/${repo.owner}/${repo.repo}.git`,
               directory: toPosixPath(path.relative(workspaceDir, pkg.path)),
             },
           };
@@ -78,8 +97,12 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
           if (args.dryRun) {
             publishArgs.push('--dry-run');
           }
+          if (args.otp) {
+            publishArgs.push('--otp', args.otp);
+          }
           await $({
             cwd: newPkgDir,
+            stdio: 'inherit',
           })`npm publish --access public --tag=canary ${publishArgs}`;
           console.log(
             `✅ ${args.dryRun ? '[Dry run] ' : ''}Published ${chalk.bold(`${pkg.name}@${packageJson.version}`)} to npm registry.`,

package/src/cli/cmdRenameScope.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+/* eslint-disable no-console */
+
+import chalk from 'chalk';
+
+import { getWorkspacePackages, renameWorkspaceScope } from '../utils/pnpm.mjs';
+
+/**
+ * A scope is a single `@`-prefixed segment. Letting a `/` through would build
+ * names like `@acme/private/pkg`, which only npm rejects, long after every
+ * matching manifest has been rewritten.
+ */
+const SCOPE_PATTERN = /^@[a-z0-9-~][a-z0-9-._~]*$/;
+
+/**
+ * @typedef {Object} Args
+ * @property {[string, string]} alias Source and target scope
+ */
+
+/**
+ * @param {string} alias
+ * @returns {[string, string]}
+ */
+export function parseAlias(alias) {
+  const parts = alias.split(':');
+  const [from, to] = parts;
+  if (parts.length !== 2 || !SCOPE_PATTERN.test(from) || !SCOPE_PATTERN.test(to)) {
+    throw new Error(
+      `Invalid scope mapping "${alias}". Expected exactly two npm scopes separated by a colon, e.g. "@acme:@acme-private".`,
+    );
+  }
+  if (from === to) {
+    throw new Error(`Invalid scope mapping "${alias}". The source and target scope are the same.`);
+  }
+  return [from, to];
+}
+
+export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
+  command: 'rename-scope <alias>',
+  describe: 'Move publishable workspace packages to a different npm scope',
+  builder: (yargs) =>
+    yargs
+      .positional('alias', {
+        type: 'string',
+        describe: 'Scope mapping written as "@from:@to"',
+        coerce: parseAlias,
+      })
+      .example(
+        '$0 rename-scope @acme:@acme-private',
+        'Publish the workspace @acme packages under @acme-private',
+      ),
+  handler: async (argv) => {
+    const [from, to] = argv.alias;
+    const packages = await getWorkspacePackages();
+    const renamed = await renameWorkspaceScope(packages, from, to);
+
+    // Matching nothing means the mapping is wrong or stale. Carrying on would
+    // publish under the original scope, so fail instead of reporting success.
+    if (renamed.size === 0) {
+      throw new Error(
+        `No publishable workspace packages found in ${from}. Check the scope mapping "${from}:${to}", or the workspace may already have been renamed.`,
+      );
+    }
+
+    for (const [oldName, newName] of renamed) {
+      console.log(`📦 ${oldName} → ${chalk.bold(newName)}`);
+    }
+
+    console.log(
+      chalk.yellow(
+        '\n⚠️  Workspace manifests were rewritten in place and are not restored. Discard them before committing.',
+      ),
+    );
+  },
+});

package/src/cli/cmdSetVersionOverrides.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
 import * as semver from 'semver';
 import { $ } from 'execa';
-import { resolveVersion, findDependencyVersionFromSpec } from '../utils/pnpm.mjs';
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
+import {
+  resolveVersion,
+  findDependencyVersionFromSpec,
+  writeOverridesToWorkspace,
+} from '../utils/pnpm.mjs';
 
 /**
  * @typedef {Object} Args
@@ -103,11 +105,8 @@ async function handler(args) {
   // eslint-disable-next-line no-console
   console.log(`Using overrides: ${JSON.stringify(overrides, null, 2)}`);
 
-  const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: 'utf8' }));
-  packageJson.resolutions ??= {};
-  Object.assign(packageJson.resolutions, overrides);
-  await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}${os.EOL}`);
+  const workspaceDir = (await findWorkspaceDir(process.cwd())) ?? process.cwd();
+  await writeOverridesToWorkspace(workspaceDir, overrides);
 
   await $({ stdio: 'inherit' })`pnpm dedupe`;
 }