@mui/internal-code-infra 0.0.3-canary.6 → 0.0.3-canary.61

package/src/brokenLinksChecker/index.test.ts

@@ -0,0 +1,178 @@
+import path from 'node:path';
+import getPort from 'get-port';
+import { describe, expect, it } from 'vitest';
+
+// eslint-disable-next-line import/extensions
+import { crawl, Issue, Link } from './index.mjs';
+
+type ExpectedIssue = Omit<Partial<Issue>, 'link'> & { link?: Partial<Link> };
+
+function objectMatchingIssue(expectedIssue: ExpectedIssue) {
+  return expect.objectContaining({
+    ...expectedIssue,
+    ...(expectedIssue.link ? { link: expect.objectContaining(expectedIssue.link) } : {}),
+  });
+}
+
+/**
+ * Helper to assert that an issue with matching properties exists in the issues array
+ */
+function expectIssue(issues: Issue[], expectedIssue: ExpectedIssue) {
+  expect(issues).toEqual(expect.arrayContaining([objectMatchingIssue(expectedIssue)]));
+}
+
+/**
+ * Helper to assert that no issue with matching properties exists in the issues array
+ */
+function expectNotIssue(issues: Issue[], notExpectedIssue: ExpectedIssue) {
+  expect(issues).not.toEqual(expect.arrayContaining([objectMatchingIssue(notExpectedIssue)]));
+}
+
+describe('Broken Links Checker', () => {
+  const fixtureDir = path.join(import.meta.dirname, '__fixtures__', 'static-site');
+  const servePath = path.join(import.meta.dirname, '..', '..', 'node_modules', '.bin', 'serve');
+
+  it('should detect all broken links and targets across the entire site', async () => {
+    const port = await getPort();
+    const host = `http://localhost:${port}`;
+
+    const result = await crawl({
+      startCommand: `${servePath} ${fixtureDir} -p ${port}`,
+      host,
+      ignoredPaths: [/ignored-page\.html$/],
+      ignoredContent: ['.sidebar'],
+      ignoredTargets: new Set(['__should-be-ignored']),
+      knownTargets: new Map([['/external-page.html', new Set(['#valid-target'])]]),
+      knownTargetsDownloadUrl: [`${host}/known-targets.json`],
+      seedUrls: ['/', '/orphaned-page.html'],
+    });
+
+    expect(result.links).toHaveLength(54);
+    expect(result.issues).toHaveLength(8);
+
+    // Check broken-link type issues
+    expectIssue(result.issues, {
+      type: 'broken-link',
+      link: {
+        src: '/broken-links.html',
+        href: '/does-not-exist.html',
+        text: 'This page does not exist',
+      },
+    });
+
+    expectIssue(result.issues, {
+      type: 'broken-link',
+      link: {
+        src: '/broken-links.html',
+        href: '/another-missing-page.html',
+        text: 'Another missing page',
+      },
+    });
+
+    // Check broken-target type issues
+    expectIssue(result.issues, {
+      type: 'broken-target',
+      link: {
+        src: '/broken-targets.html',
+        href: '/with-anchors.html#nonexistent',
+        text: 'Non-existent anchor',
+      },
+    });
+
+    expectIssue(result.issues, {
+      type: 'broken-target',
+      link: {
+        src: '/broken-targets.html',
+        href: '/valid.html#missing-target',
+        text: 'Valid page, missing target',
+      },
+    });
+
+    expectIssue(result.issues, {
+      type: 'broken-target',
+      link: {
+        src: '/broken-targets.html',
+        href: '/with-anchors.html#also-missing',
+        text: 'Also missing',
+      },
+    });
+
+    // Verify that valid links are not reported
+    expectNotIssue(result.issues, { link: { href: '/' } });
+    expectNotIssue(result.issues, { link: { href: '/valid.html' } });
+    expectNotIssue(result.issues, { link: { href: '/with-anchors.html' } });
+    expectNotIssue(result.issues, { link: { href: '/with-anchors.html#section1' } });
+    expectNotIssue(result.issues, { link: { href: '/with-anchors.html#section2' } });
+    expectNotIssue(result.issues, { link: { href: '/with-anchors.html#section3' } });
+    expectNotIssue(result.issues, { link: { href: '/nested/page.html' } });
+
+    // Verify that external links are not reported
+    expectNotIssue(result.issues, { link: { href: 'https://example.com' } });
+    expectNotIssue(result.issues, { link: { href: 'https://github.com/mui' } });
+
+    // Test ignoredPaths: ignored-page.html should not be crawled
+    expectNotIssue(result.issues, { link: { src: '/ignored-page.html' } });
+    expectNotIssue(result.issues, { link: { href: '/this-link-should-not-be-checked.html' } });
+
+    // Test ignoredContent: links in .sidebar should be ignored
+    expectNotIssue(result.issues, { link: { href: '/sidebar-broken-link.html' } });
+
+    // Test ignoredTargets: __should-be-ignored target should not cause issues
+    expectNotIssue(result.issues, {
+      link: { href: '/page-with-custom-targets.html#__should-be-ignored' },
+    });
+
+    // Test that non-ignored custom target is valid
+    expectNotIssue(result.issues, { link: { href: '/page-with-custom-targets.html#custom-id' } });
+
+    // Test knownTargets: valid-target is known and should not cause issues
+    expectNotIssue(result.issues, { link: { href: '/external-page.html#valid-target' } });
+
+    // Test knownTargets: invalid-target is not in knownTargets and should cause an issue
+    expectIssue(result.issues, {
+      type: 'broken-target',
+      link: {
+        src: '/page-with-known-target-links.html',
+        href: '/external-page.html#invalid-target',
+        text: 'Invalid external target',
+      },
+    });
+
+    // Test knownTargetsDownloadUrl: method1 and method2 are in downloaded known targets
+    expectNotIssue(result.issues, { link: { href: '/api-page.html#method1' } });
+    expectNotIssue(result.issues, { link: { href: '/api-page.html#method2' } });
+
+    // Test knownTargetsDownloadUrl: unknown-method is not in downloaded known targets and should cause an issue
+    expectIssue(result.issues, {
+      type: 'broken-target',
+      link: {
+        src: '/page-with-api-links.html',
+        href: '/api-page.html#unknown-method',
+        text: 'Unknown API method',
+      },
+    });
+
+    // Test seedUrls: orphaned-page.html should be crawled even though it's not linked from anywhere
+    expect(result.pages.has('/orphaned-page.html')).toBe(true);
+
+    // Test seedUrls: broken link from orphaned page should be detected
+    expectIssue(result.issues, {
+      type: 'broken-link',
+      link: {
+        src: '/orphaned-page.html',
+        href: '/orphaned-broken-link.html',
+        text: 'Broken link from orphaned page',
+      },
+    });
+
+    // Test trailing slash normalization: /valid.html and /valid.html/ should be treated as the same page
+    // The orphaned page has both links, but they should not cause duplicate page crawls
+    expectNotIssue(result.issues, { link: { href: '/valid.html/' } });
+
+    // Test content-type checking: links inside markdown files should not be crawled
+    // The example.md file contains a link to /this-should-not-be-checked.html in an HTML snippet
+    expectNotIssue(result.issues, { link: { href: '/this-should-not-be-checked.html' } });
+    // The markdown file itself should not cause issues (it's a valid file, just not HTML)
+    expectNotIssue(result.issues, { link: { href: '/example.md' } });
+  }, 30000);
+});

package/src/cli/cmdArgosPush.mjs

@@ -63,8 +63,11 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       const screenshots = await globby(`${folder}/**/*`, {
         onlyFiles: true,
       });
+      const threshold = process.env.ARGOS_THRESHOLD ? parseFloat(process.env.ARGOS_THRESHOLD) : 0.5;
 
-      console.log(`Found ${screenshots.length} screenshots.`);
+      console.log(
+        `Found ${screenshots.length} screenshots. Uploading with threshold ${threshold}.`,
+      );
       if (verbose) {
         console.log('Screenshots found:');
         screenshots.forEach((screenshot) => {
@@ -99,14 +102,22 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
           commit: circleSha1,
           branch: circleBranch,
           token: argosToken,
+          threshold,
           parallel: {
             total: batches.length,
             nonce: circleBuildNum,
           },
         });
 
+        if (verbose) {
+          console.log('Screenshots uploaded:');
+          for (const screenshot of result.screenshots) {
+            console.log(`- ${screenshot.name}. Threshold: ${screenshot.threshold}.`);
+          }
+        }
+
         console.log(
-          `Batch of ${batches[i].length} screenshots uploaded. Build URL: ${result.build.url}`,
+          `Batch of ${batches[i].length} screenshots uploaded. Threshold: ${threshold}. Build URL: ${result.build.url}`,
         );
       }
     } finally {

package/src/cli/cmdBuild.mjs

@@ -1,9 +1,13 @@
 /* eslint-disable no-console */
+import { findWorkspaceDir } from '@pnpm/find-workspace-dir';
 import { $ } from 'execa';
-import set from 'lodash-es/set.js';
+import { globby } from 'globby';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { getOutExtension, isMjsBuild, validatePkgJson } from '../utils/build.mjs';
+import { sep as posixSep } from 'node:path/posix';
+import * as semver from 'semver';
+
+import { getOutExtension, isMjsBuild, mapConcurrently, validatePkgJson } from '../utils/build.mjs';
 
 /**
  * @typedef {Object} Args
@@ -18,6 +22,8 @@ import { getOutExtension, isMjsBuild, validatePkgJson } from '../utils/build.mjs
  * @property {boolean} skipPackageJson - Whether to skip generating the package.json file in the bundle output.
  * @property {boolean} skipMainCheck - Whether to skip checking for main field in package.json.
  * @property {string[]} ignore - Globs to be ignored by Babel.
+ * @property {string[]} [copy] - Files/Directories to be copied. Can be a glob pattern.
+ * @property {boolean} [enableReactCompiler] - Whether to use the React compiler.
  */
 
 const validBundles = [
@@ -64,16 +70,16 @@ ${content}`,
 
 /**
  * @param {Object} param0
- * @param {string | Record<string, string>} param0.importPath
+ * @param {NonNullable<import('./packageJson').PackageJson.Exports>} param0.importPath
  * @param {string} param0.key
  * @param {string} param0.cwd
  * @param {string} param0.dir
  * @param {string} param0.type
- * @param {Object} param0.newExports
+ * @param {import('./packageJson').PackageJson.ExportConditions} param0.newExports
  * @param {string} param0.typeOutExtension
  * @param {string} param0.outExtension
  * @param {boolean} param0.addTypes
- * @returns {Promise<{path: string[], importPath: string | Record<string, string | undefined>}>}
+ * @returns {Promise<void>}
  */
 async function createExportsFor({
   importPath,
@@ -86,10 +92,22 @@ async function createExportsFor({
   outExtension,
   addTypes,
 }) {
+  if (Array.isArray(importPath)) {
+    throw new Error(
+      `Array form of package.json exports is not supported yet. Found in export "${key}".`,
+    );
+  }
+
   let srcPath = typeof importPath === 'string' ? importPath : importPath['mui-src'];
   const rest = typeof importPath === 'string' ? {} : { ...importPath };
   delete rest['mui-src'];
 
+  if (typeof srcPath !== 'string') {
+    throw new Error(
+      `Unsupported export for "${key}". Only a string or an object with "mui-src" field is supported for now.`,
+    );
+  }
+
   const exportFileExists = srcPath.includes('*')
     ? true
     : await fs.stat(path.join(cwd, srcPath)).then(
@@ -105,25 +123,25 @@ async function createExportsFor({
   const ext = path.extname(srcPath);
 
   if (ext === '.css') {
-    set(newExports, [key], srcPath);
-    return {
-      path: [key],
-      importPath: srcPath,
-    };
+    newExports[key] = srcPath;
+    return;
   }
-  return {
-    path: [key, type === 'cjs' ? 'require' : 'import'],
-    importPath: {
-      ...rest,
-      types: addTypes ? srcPath.replace(ext, typeOutExtension) : undefined,
-      default: srcPath.replace(ext, outExtension),
-    },
+
+  if (typeof newExports[key] === 'string' || Array.isArray(newExports[key])) {
+    throw new Error(`The export "${key}" is already defined as a string or Array.`);
+  }
+
+  newExports[key] ??= {};
+  newExports[key][type === 'cjs' ? 'require' : 'import'] = {
+    ...rest,
+    ...(addTypes ? { types: srcPath.replace(ext, typeOutExtension) } : {}),
+    default: srcPath.replace(ext, outExtension),
   };
 }
 
 /**
  * @param {Object} param0
- * @param {any} param0.packageJson - The package.json content.
+ * @param {import('./packageJson').PackageJson} param0.packageJson - The package.json content.
  * @param {{type: import('../utils/build.mjs').BundleType; dir: string}[]} param0.bundles
  * @param {string} param0.outputDir
  * @param {string} param0.cwd
@@ -138,12 +156,15 @@ async function writePackageJson({ packageJson, bundles, outputDir, cwd, addTypes
   packageJson.type = packageJson.type || 'commonjs';
 
   /**
-   * @type {Record<string, string | Record<string, string> | null>}
+   * @type {import('./packageJson').PackageJson.ExportConditions}
    */
-  const originalExports = packageJson.exports || {};
+  const originalExports =
+    typeof packageJson.exports === 'string' || Array.isArray(packageJson.exports)
+      ? { '.': packageJson.exports }
+      : packageJson.exports || {};
   delete packageJson.exports;
   /**
-   * @type {Record<string, string | Record<string, string> | null>}
+   * @type {import('./packageJson').PackageJson.ExportConditions}
    */
   const newExports = {
     './package.json': './package.json',
@@ -172,10 +193,16 @@ async function writePackageJson({ packageJson, bundles, outputDir, cwd, addTypes
         if (type === 'cjs') {
           packageJson.main = exportDir;
         }
-        set(newExports, ['.', type === 'cjs' ? 'require' : 'import'], {
-          types: typeFileExists ? typeExportDir : undefined,
+
+        if (typeof newExports['.'] === 'string' || Array.isArray(newExports['.'])) {
+          throw new Error(`The export "." is already defined as a string or Array.`);
+        }
+
+        newExports['.'] ??= {};
+        newExports['.'][type === 'cjs' ? 'require' : 'import'] = {
+          ...(typeFileExists ? { types: typeExportDir } : {}),
           default: exportDir,
-        });
+        };
       }
       if (typeFileExists && type === 'cjs') {
         packageJson.types = typeExportDir;
@@ -185,11 +212,11 @@ async function writePackageJson({ packageJson, bundles, outputDir, cwd, addTypes
       for (const key of exportKeys) {
         const importPath = originalExports[key];
         if (!importPath) {
-          set(newExports, [key], null);
-          return;
+          newExports[key] = null;
+          continue;
         }
         // eslint-disable-next-line no-await-in-loop
-        const res = await createExportsFor({
+        await createExportsFor({
           importPath,
           key,
           cwd,
@@ -200,7 +227,6 @@ async function writePackageJson({ packageJson, bundles, outputDir, cwd, addTypes
           outExtension,
           addTypes,
         });
-        set(newExports, res.path, res.importPath);
       }
     }),
   );
@@ -213,6 +239,11 @@ async function writePackageJson({ packageJson, bundles, outputDir, cwd, addTypes
   // default condition should come last
   Object.keys(newExports).forEach((key) => {
     const exportVal = newExports[key];
+    if (Array.isArray(exportVal)) {
+      throw new Error(
+        `Array form of package.json exports is not supported yet. Found in export "${key}".`,
+      );
+    }
     if (exportVal && typeof exportVal === 'object' && (exportVal.import || exportVal.require)) {
       const defaultExport = exportVal.import || exportVal.require;
       if (exportVal.import) {
@@ -298,6 +329,18 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
         type: 'boolean',
         default: false,
         description: 'Skip checking for main field in package.json.',
+      })
+      .option('copy', {
+        type: 'string',
+        array: true,
+        description:
+          'Files/Directories to be copied to the output directory. Can be a glob pattern.',
+        default: [],
+      })
+      .option('enableReactCompiler', {
+        type: 'boolean',
+        default: false,
+        description: 'Whether to use the React compiler.',
       });
   },
   async handler(args) {
@@ -312,12 +355,13 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       skipTsc,
       skipBabelRuntimeCheck = false,
       skipPackageJson = false,
+      enableReactCompiler = false,
     } = args;
 
     const cwd = process.cwd();
     const pkgJsonPath = path.join(cwd, 'package.json');
     const packageJson = JSON.parse(await fs.readFile(pkgJsonPath, { encoding: 'utf8' }));
-    validatePkgJson(packageJson, { skipMainCheck: args.skipMainCheck });
+    validatePkgJson(packageJson, { skipMainCheck: args.skipMainCheck, enableReactCompiler });
 
     const buildDirBase = /** @type {string} */ (packageJson.publishConfig?.directory);
     const buildDir = path.join(cwd, buildDirBase);
@@ -346,12 +390,21 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       return;
     }
 
-    const babelMod = await import('./babel.mjs');
+    const babelMod = await import('../utils/babel.mjs');
     const relativeOutDirs = {
       cjs: cjsOutDir,
       esm: 'esm',
     };
     const sourceDir = path.join(cwd, 'src');
+    const reactVersion =
+      semver.minVersion(packageJson.peerDependencies?.react || '')?.version ?? 'latest';
+
+    if (enableReactCompiler) {
+      const mode = process.env.MUI_REACT_COMPILER_MODE ?? 'opt-in';
+      console.log(
+        `[feature] Building with React compiler enabled. The compiler mode is "${mode}" right now.${mode === 'opt-in' ? ' Use explicit "use memo" directives in your components to enable the React compiler for them.' : ''}`,
+      );
+    }
 
     // js build start
     await Promise.all(
@@ -379,6 +432,11 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
             pkgVersion: packageJson.version,
             ignores: extraIgnores,
             outExtension,
+            reactCompiler: enableReactCompiler
+              ? {
+                  reactVersion: reactVersion || 'latest',
+                }
+              : undefined,
           }),
         );
 
@@ -408,7 +466,7 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
     // js build end
 
     if (buildTypes) {
-      const tsMod = await import('./typescript.mjs');
+      const tsMod = await import('../utils/typescript.mjs');
       /**
        * @type {{type: import('../utils/build.mjs').BundleType, dir: string}[]};
        */
@@ -442,5 +500,144 @@ export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
       outputDir: buildDir,
       addTypes: buildTypes,
     });
+
+    await copyHandler({
+      cwd,
+      globs: args.copy ?? [],
+      buildDir,
+      verbose: args.verbose,
+    });
   },
 });
+
+/**
+ * @param {Object} param0
+ * @param {string} param0.cwd - The current working directory.
+ * @param {string[]} [param0.globs=[]] - Extra files to copy, can be specified as `source:target` pairs or just `source`.
+ * @param {string} param0.buildDir - The build directory to copy to.
+ * @param {boolean} [param0.verbose=false] - Whether to suppress output.
+ * @returns {Promise<void>}
+ */
+async function copyHandler({ cwd, globs = [], buildDir, verbose = false }) {
+  /**
+   * @type {(string|{targetPath: string; sourcePath: string})[]}
+   */
+  const defaultFiles = [];
+  const workspaceDir = await findWorkspaceDir(cwd);
+  if (!workspaceDir) {
+    throw new Error('Workspace directory not found');
+  }
+
+  const localOrRootFiles = [
+    [path.join(cwd, 'README.md'), path.join(workspaceDir, 'README.md')],
+    [path.join(cwd, 'LICENSE'), path.join(workspaceDir, 'LICENSE')],
+    [path.join(cwd, 'CHANGELOG.md'), path.join(workspaceDir, 'CHANGELOG.md')],
+  ];
+  await Promise.all(
+    localOrRootFiles.map(async (filesToCopy) => {
+      for (const file of filesToCopy) {
+        if (
+          // eslint-disable-next-line no-await-in-loop
+          await fs.stat(file).then(
+            () => true,
+            () => false,
+          )
+        ) {
+          defaultFiles.push(file);
+          break;
+        }
+      }
+    }),
+  );
+
+  if (globs.length) {
+    const res = globs.map((globPattern) => {
+      const [pattern, baseDir] = globPattern.split(':');
+      return { pattern, baseDir };
+    });
+    /**
+     * Avoids redundant globby calls for the same pattern.
+     *
+     * @type {Map<string, Promise<string[]>>}
+     */
+    const globToResMap = new Map();
+
+    const result = await Promise.all(
+      res.map(async ({ pattern, baseDir }) => {
+        if (!globToResMap.has(pattern)) {
+          const promise = globby(pattern, { cwd });
+          globToResMap.set(pattern, promise);
+        }
+        const files = await globToResMap.get(pattern);
+        return { files: files ?? [], baseDir };
+      }),
+    );
+    globToResMap.clear();
+
+    result.forEach(({ files, baseDir }) => {
+      files.forEach((file) => {
+        const sourcePath = path.resolve(cwd, file);
+        // Use posix separator for the relative paths. So devs can only specify globs with `/` even on Windows.
+        const pathSegments = file.split(posixSep);
+        const relativePath =
+          // Use index 2 (when required) since users can also specify paths like `./src/index.js`
+          pathSegments.slice(pathSegments[0] === '.' ? 2 : 1).join(posixSep) || file;
+        const targetPath = baseDir
+          ? path.resolve(buildDir, baseDir, relativePath)
+          : path.resolve(buildDir, relativePath);
+        defaultFiles.push({ sourcePath, targetPath });
+      });
+    });
+  }
+
+  if (!defaultFiles.length) {
+    if (verbose) {
+      console.log('⓿ No files to copy.');
+    }
+  }
+  await mapConcurrently(
+    defaultFiles,
+    async (file) => {
+      if (typeof file === 'string') {
+        const sourcePath = file;
+        const fileName = path.basename(file);
+        const targetPath = path.join(buildDir, fileName);
+        await recursiveCopy({ source: sourcePath, target: targetPath, verbose });
+      } else {
+        await fs.mkdir(path.dirname(file.targetPath), { recursive: true });
+        await recursiveCopy({ source: file.sourcePath, target: file.targetPath, verbose });
+      }
+    },
+    20,
+  );
+  console.log(`📋 Copied ${defaultFiles.length} files.`);
+}
+
+/**
+ * Recursively copies files and directories from a source path to a target path.
+ *
+ * @async
+ * @param {Object} options - The options for copying files.
+ * @param {string} options.source - The source path to copy from.
+ * @param {string} options.target - The target path to copy to.
+ * @param {boolean} [options.verbose=true] - If true, suppresses console output.
+ * @returns {Promise<boolean>} Resolves when the copy operation is complete.
+ * @throws {Error} Throws if an error occurs other than the source not existing.
+ */
+async function recursiveCopy({ source, target, verbose = true }) {
+  try {
+    await fs.cp(source, target, { recursive: true });
+    if (verbose) {
+      console.log(`Copied ${source} to ${target}`);
+    }
+    return true;
+  } catch (err) {
+    if (/** @type {{ code: string }} */ (err).code !== 'ENOENT') {
+      throw err;
+    }
+    if (verbose) {
+      console.warn(`Source does not exist: ${source}`);
+    }
+    throw err;
+  }
+}

package/src/cli/cmdGithubAuth.mjs

@@ -0,0 +1,36 @@
+/* eslint-disable no-console */
+
+/**
+ * @typedef {Object} Args
+ * @property {boolean} authorize
+ * @property {boolean} clear
+ */
+
+export default /** @type {import('yargs').CommandModule<{}, Args>} */ ({
+  command: 'github',
+  describe: 'Authenticates the user with GitHub and stores the access token securely.',
+  builder: (yargs) =>
+    yargs
+      .option('authorize', {
+        type: 'boolean',
+        describe: 'Trigger the authentication flow to get a new token if not found.',
+        default: false,
+      })
+      .option('clear', {
+        type: 'boolean',
+        describe: 'Clear stored GitHub authentication tokens.',
+        default: false,
+      }),
+  async handler(args) {
+    const gh = await import('../utils/github.mjs');
+    if (args.clear) {
+      await gh.clearGitHubAuth();
+      console.log('✅ GitHub auth tokens cleared.');
+      return;
+    }
+    if (args.authorize) {
+      await gh.endToEndGhAuthGetToken({ log: true });
+      console.log('✅ GitHub auth tokens successfully retrieved.');
+    }
+  },
+});

package/src/cli/cmdListWorkspaces.mjs

@@ -3,12 +3,12 @@
 /* eslint-disable no-console */
 
 /**
- * @typedef {import('./pnpm.mjs').PublicPackage} PublicPackage
+ * @typedef {import('../utils/pnpm.mjs').PublicPackage} PublicPackage
  */
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { getWorkspacePackages } from './pnpm.mjs';
+import { getWorkspacePackages } from '../utils/pnpm.mjs';
 
 /**
  * @typedef {Object} Args