fix(@angular/cli): handle bun registry error output and 404 detection

Unlike npm, `bun pm view` does not emit `npm ERR! code E404` or nested JSON error objects with a `code` property when a package, version, or dist-tag is missing from the registry. Instead, missing packages produce plain-text HTTP status lines on `stderr` (such as `404 Not Found: ...`), while missing versions or dist-tags produce flat JSON objects on `stdout` with a string `error` field (such as `{ "error": "No matching version found" }`). Because `parseNpmLikeError` did not recognize either format, querying a non-existent package or version under Bun threw an unhandled `PackageManagerError` instead of returning `null`.

This change introduces a dedicated `parseBunError` parser for the `bun` package manager descriptor that extracts structured error codes from both Bun's JSON error payloads and plain-text HTTP status messages, normalizing not-found responses to `E404`.

Author: clydin

packages/angular/cli/src/package-managers/package-manager-descriptor.ts

@@ -18,6 +18,7 @@ import { PackageManifest, PackageMetadata } from './package-metadata';
 import { InstalledPackage } from './package-tree';
 import {
   parseBunDependencies,
+  parseBunError,
   parseNpmBeforeDate,
   parseNpmLikeDependencies,
   parseNpmLikeError,
@@ -349,7 +350,7 @@ export const SUPPORTED_PACKAGE_MANAGERS = {
       listDependencies: parseBunDependencies,
       getRegistryManifest: parseNpmLikeManifest,
       getRegistryMetadata: parseNpmLikeMetadata,
-      getError: parseNpmLikeError,
+      getError: parseBunError,
     },
     isNotFound: isKnownNotFound,
   },

packages/angular/cli/src/package-managers/package-manager_spec.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
+import { PackageManagerError } from './error';
 import { MANIFEST_FIELDS, PackageManager } from './package-manager';
 import { SUPPORTED_PACKAGE_MANAGERS } from './package-manager-descriptor';
 import { MockHost } from './testing/mock-host';
@@ -54,6 +55,37 @@ describe('PackageManager', () => {
         jasmine.anything(),
       );
     });
+
+    it('should return null when bun pm view fails with No matching version found', async () => {
+      const pm = new PackageManager(host, '/tmp', SUPPORTED_PACKAGE_MANAGERS['bun']);
+      runCommandSpy.and.rejectWith(
+        new PackageManagerError(
+          'Process exited with code 1.',
+          JSON.stringify({ error: 'No matching version found', version: 'foo@99.99.99' }),
+          '',
+          1,
+        ),
+      );
+
+      expect(await pm.getRegistryManifest('foo', '99.99.99')).toBeNull();
+    });
+
+    it('should throw when bun pm view fails with an unrecognized JSON error', async () => {
+      const pm = new PackageManager(host, '/tmp', SUPPORTED_PACKAGE_MANAGERS['bun']);
+      runCommandSpy.and.rejectWith(
+        new PackageManagerError(
+          'Process exited with code 1.',
+          JSON.stringify({ error: 'Authentication token not found' }),
+          '',
+          1,
+        ),
+      );
+
+      await expectAsync(pm.getRegistryManifest('foo', '1.0.0')).toBeRejectedWithError(
+        PackageManagerError,
+        'Authentication token not found',
+      );
+    });
   });
 
   describe('getVersion', () => {
@@ -376,6 +408,20 @@ describe('PackageManager', () => {
         jasmine.anything(),
       );
     });
+
+    it('should return null when bun pm view fails with 404 Not Found', async () => {
+      const pm = new PackageManager(host, '/tmp', SUPPORTED_PACKAGE_MANAGERS['bun']);
+      runCommandSpy.and.rejectWith(
+        new PackageManagerError(
+          'Process exited with code 1.',
+          '',
+          "404 Not Found: https://registry.npmjs.org/non-existent\n\n - 'non-existent@latest' does not exist in this registry",
+          1,
+        ),
+      );
+
+      expect(await pm.getRegistryMetadata('non-existent')).toBeNull();
+    });
   });
 
   describe('getCurrentPackageName', () => {

packages/angular/cli/src/package-managers/parsers.ts

@@ -513,7 +513,7 @@ export function parseNpmLikeError(output: string, logger?: Logger): ErrorInfo |
     return null;
   }
 
-  // Attempt to parse as JSON first (common for pnpm, modern yarn, bun, npm 12)
+  // Attempt to parse as JSON first (common for pnpm, modern yarn, npm 12)
   try {
     let jsonError = JSON.parse(output);
     if (Array.isArray(jsonError)) {
@@ -636,6 +636,92 @@ export function parseYarnClassicError(output: string, logger?: Logger): ErrorInf
   return null;
 }
 
+/**
+ * Known Bun JSON error messages that indicate a requested version or dist-tag does not exist.
+ */
+const BUN_NOT_FOUND_ERROR_PATTERN = /^(?:no matching version found|dist-tag not found)\b/i;
+
+/**
+ * Parses the `stdout` or `stderr` output of `bun` commands to extract structured error information.
+ *
+ * Handles flat JSON error payloads emitted on `stdout` by `bun pm view` (e.g., when a requested
+ * version or dist-tag does not exist) as well as plain-text HTTP status errors emitted on `stderr`
+ * (e.g., 404 Not Found). Other JSON error shapes are delegated to `parseNpmLikeError`.
+ *
+ * Example JSON error output:
+ * ```json
+ * { "error": "No matching version found", "version": "@angular/core@99.99.99" }
+ * ```
+ *
+ * Example plain-text error output:
+ * ```
+ * 404 Not Found: https://registry.npmjs.org/@angular%2fnon-existent
+ * ```
+ *
+ * @param output The standard output or standard error of the command.
+ * @param logger An optional logger instance.
+ * @returns An `ErrorInfo` object if parsing is successful, otherwise `null`.
+ */
+export function parseBunError(output: string, logger?: Logger): ErrorInfo | null {
+  logger?.debug('Parsing Bun error output...');
+  logStdout(output, logger);
+
+  if (!output) {
+    logger?.debug('  output is empty. No error found.');
+
+    return null;
+  }
+
+  // 1. JSON output. Valid JSON is never a plain-text status line, so text matching is skipped.
+  let parsed: unknown;
+  let isJson = false;
+  try {
+    parsed = JSON.parse(output);
+    isJson = true;
+  } catch {
+    // Not JSON. Fall back to plain-text error matching.
+  }
+
+  if (isJson) {
+    // Only accept Bun's exact flat error shape (`error` with an optional `version`) to avoid
+    // misinterpreting successful output, such as a dist-tags object containing an `error` tag.
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      const { error, version, ...rest } = parsed as Record<string, unknown>;
+      if (
+        typeof error === 'string' &&
+        (version === undefined || typeof version === 'string') &&
+        Object.keys(rest).length === 0
+      ) {
+        const code = BUN_NOT_FOUND_ERROR_PATTERN.test(error) ? 'E404' : 'UNKNOWN_ERROR';
+        const summary = version ? `${error}: ${version}` : error;
+        logger?.debug(`  Successfully parsed Bun JSON error with code '${code}'.`);
+
+        return { code, summary };
+      }
+    }
+
+    // Fall back to npm-compatible JSON error objects (e.g., `{ "error": { "code": "E404", ... } }`).
+    return parseNpmLikeError(output, logger);
+  }
+
+  // 2. Plain-text HTTP error status lines from `bun pm view`
+  // (e.g., `404 Not Found: https://registry.npmjs.org/...`).
+  const httpStatusMatch = output.match(/^([45]\d{2})\s+[^\r\n:]+:.+$/m);
+  if (httpStatusMatch) {
+    const code = `E${httpStatusMatch[1]}`;
+    logger?.debug(`  Detected HTTP error status code '${httpStatusMatch[1]}' in Bun output.`);
+
+    return {
+      code,
+      summary: httpStatusMatch[0].trim(),
+    };
+  }
+
+  logger?.debug('  Failed to parse Bun error. No structured error found.');
+
+  return null;
+}
+
 /**
  * Parses the output of `bun pm ls`.
  *

packages/angular/cli/src/package-managers/parsers_spec.ts

@@ -8,6 +8,7 @@
 
 import {
   parseBunDependencies,
+  parseBunError,
   parseNpmBeforeDate,
   parseNpmLikeDependencies,
   parseNpmLikeError,
@@ -554,6 +555,92 @@ project node_modules
     });
   });
 
+  describe('parseBunError', () => {
+    it('should parse JSON missing version error as E404', () => {
+      const stdout = JSON.stringify({
+        error: 'No matching version found',
+        version: '@angular/core@99.99.99',
+      });
+      expect(parseBunError(stdout)).toEqual({
+        code: 'E404',
+        summary: 'No matching version found: @angular/core@99.99.99',
+      });
+    });
+
+    it('should parse JSON missing dist-tag error as E404', () => {
+      const stdout = JSON.stringify({
+        error: 'Dist-tag not found',
+        version: '@angular/core@nonexistent-tag',
+      });
+      expect(parseBunError(stdout)).toEqual({
+        code: 'E404',
+        summary: 'Dist-tag not found: @angular/core@nonexistent-tag',
+      });
+    });
+
+    it('should parse plain-text 404 Not Found output from bun pm view as E404', () => {
+      const stderr = `
+404 Not Found: https://registry.npmjs.org/@angular%2fnon-existent
+
+ - '@angular/non-existent@latest' does not exist in this registry
+`.trim();
+      expect(parseBunError(stderr)).toEqual({
+        code: 'E404',
+        summary: '404 Not Found: https://registry.npmjs.org/@angular%2fnon-existent',
+      });
+    });
+
+    it('should parse plain-text 401 Unauthorized output from bun pm view as E401', () => {
+      const stderr = '401 Unauthorized: https://registry.npmjs.org/@private%2fpkg';
+      expect(parseBunError(stderr)).toEqual({
+        code: 'E401',
+        summary: '401 Unauthorized: https://registry.npmjs.org/@private%2fpkg',
+      });
+    });
+
+    it('should parse unrecognized JSON error messages as UNKNOWN_ERROR', () => {
+      const stdout = JSON.stringify({ error: 'Authentication token not found' });
+      expect(parseBunError(stdout)).toEqual({
+        code: 'UNKNOWN_ERROR',
+        summary: 'Authentication token not found',
+      });
+    });
+
+    it('should fall back to npm-compatible JSON error objects', () => {
+      const stdout = JSON.stringify({ error: { code: 'E403', summary: 'Forbidden' } });
+      expect(parseBunError(stdout)).toEqual({
+        code: 'E403',
+        summary: 'Forbidden',
+        detail: undefined,
+      });
+    });
+
+    it('should not treat successful bun pm view JSON output as an error', () => {
+      // A dist-tags object that happens to contain an `error` tag.
+      expect(parseBunError(JSON.stringify({ latest: '1.0.0', error: '0.0.1' }))).toBeNull();
+      expect(parseBunError(JSON.stringify(['1.0.0', '1.1.0']))).toBeNull();
+      expect(parseBunError(JSON.stringify({ name: 'foo', version: '1.0.0' }))).toBeNull();
+    });
+
+    it('should not treat successful bun pm ls output as an error', () => {
+      const stdout = `
+/workspace node_modules (350)
+├── @angular/core@21.2.4
+└── typescript@5.9.3
+`.trim();
+      expect(parseBunError(stdout)).toBeNull();
+    });
+
+    it('should ignore non-error HTTP status lines', () => {
+      expect(parseBunError('304 Not Modified: https://registry.npmjs.org/foo')).toBeNull();
+    });
+
+    it('should return null for empty or unrecognized output', () => {
+      expect(parseBunError('')).toBeNull();
+      expect(parseBunError('some unrelated output')).toBeNull();
+    });
+  });
+
   describe('parseYarnModernDependencies', () => {
     it('should parse yarn info --name-only --json output', () => {
       const stdout = `