fix(packaging): bundle audio capture for mirror installs

.github/workflows/release.yml

@@ -391,11 +391,6 @@ jobs:
             echo "Dry run enabled. Skipping push."
           fi
 
-      - name: 'Build Bundle and Prepare Package'
-        run: |-
-          npm run bundle
-          npm run prepare:package
-
       - name: 'Download audio capture prebuilds'
         if: |-
           ${{ github.repository == 'QwenLM/qwen-code' }}
@@ -404,6 +399,13 @@ jobs:
           name: 'audio-capture-prebuilds'
           path: 'packages/audio-capture/prebuilds'
 
+      - name: 'Build Bundle and Prepare Package'
+        env:
+          QWEN_REQUIRE_AUDIO_CAPTURE_PREBUILD: "${{ github.repository == 'QwenLM/qwen-code' && '1' || '' }}"
+        run: |-
+          npm run bundle
+          npm run prepare:package
+
       - name: 'Build Standalone Archives'
         env:
           RELEASE_VERSION: '${{ needs.prepare.outputs.release_version }}'

packages/cli/src/ui/voice/native-audio-recorder.test.ts

@@ -158,6 +158,64 @@ describe('createNativeAudioRecorder', () => {
     expect(backend.startRecording).toHaveBeenCalledTimes(1);
   });
 
+  it('explains mirror registry installs when the native package is missing', async () => {
+    const recorder = createNativeAudioRecorder({
+      loadBackend: () => {
+        throw new Error(
+          "Cannot find package '@qwen-code/audio-capture' imported from /qwen/dist/cli.js",
+        );
+      },
+    });
+
+    await expect(recorder.start()).rejects.toThrow(
+      /mirror or private registry/,
+    );
+    await expect(recorder.start()).rejects.toThrow(/@qwen-code\/audio-capture/);
+  });
+
+  it.each(['ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND'])(
+    'explains mirror registry installs for %s native package errors',
+    async (code) => {
+      const error = Object.assign(
+        new Error('missing @qwen-code/audio-capture dependency'),
+        { code },
+      );
+      const recorder = createNativeAudioRecorder({
+        loadBackend: () => {
+          throw error;
+        },
+      });
+
+      await expect(recorder.start()).rejects.toThrow(
+        /mirror or private registry/,
+      );
+      await expect(recorder.start()).rejects.toThrow(
+        /@qwen-code\/audio-capture/,
+      );
+    },
+  );
+
+  it('does not explain native start failures as missing packages', async () => {
+    const startError = new Error(
+      "Cannot find package '@qwen-code/audio-capture' while starting",
+    );
+    const backend = {
+      startRecording: vi.fn(() => {
+        throw startError;
+      }),
+      stopRecording: vi.fn(() => new Uint8Array([1])),
+      isRecording: vi.fn(() => false),
+      microphoneAuthorizationStatus: vi.fn(() => 'unknown' as const),
+    };
+    const recorder = createNativeAudioRecorder({
+      loadBackend: () => backend,
+    });
+
+    await expect(recorder.start()).rejects.toBe(startError);
+
+    expect(backend.startRecording).toHaveBeenCalledTimes(1);
+  });
+
   it('allows retry after native stop throws', async () => {
     const backend = {
       startRecording: vi.fn(),

packages/cli/src/ui/voice/native-audio-recorder.ts

@@ -15,6 +15,7 @@ import type {
 // Native silence detection sets a flag we poll for; older addons lack it.
 const SILENCE_POLL_INTERVAL_MS = 200;
 const debugLogger = createDebugLogger('VOICE_NATIVE_RECORDER');
+const AUDIO_CAPTURE_PACKAGE = '@qwen-code/audio-capture';
 
 interface NativeAudioRecorderOptions {
   loadBackend?: () =>
@@ -71,7 +72,11 @@ class NativeAudioRecorder implements VoiceRecorder {
     this.starting = true;
     let backend: NativeAudioCaptureBackend;
     try {
-      backend = await this.loadBackend();
+      try {
+        backend = await this.loadBackend();
+      } catch (loadError) {
+        throw explainMissingNativePackage(loadError);
+      }
       const silenceDetection = options.silenceDetection === true;
       backend.startRecording({
         sampleRate: 16000,
@@ -130,6 +135,36 @@ async function loadDefaultBackend(): Promise<NativeAudioCaptureBackend> {
   return createNativeAudioCaptureBackend();
 }
 
+function explainMissingNativePackage(error: unknown): unknown {
+  if (!(error instanceof Error) || !isMissingNativePackageError(error)) {
+    return error;
+  }
+
+  debugLogger.warn(
+    '[voice] native package missing:',
+    error.message,
+    (error as NodeJS.ErrnoException).code,
+  );
+  return new Error(
+    `Native voice capture package '${AUDIO_CAPTURE_PACKAGE}' is missing. ` +
+      'If Qwen Code was installed from a mirror or private registry, the ' +
+      'registry may not have synced this optional package. Reinstall from ' +
+      'https://registry.npmjs.org or make sure the configured registry ' +
+      `provides ${AUDIO_CAPTURE_PACKAGE}. (${error.message})`,
+    { cause: error },
+  );
+}
+
+function isMissingNativePackageError(error: Error): boolean {
+  return (
+    error.message.includes(AUDIO_CAPTURE_PACKAGE) &&
+    (error.message.includes('Cannot find package') ||
+      error.message.includes('Cannot find module') ||
+      (error as NodeJS.ErrnoException).code === 'ERR_MODULE_NOT_FOUND' ||
+      (error as NodeJS.ErrnoException).code === 'MODULE_NOT_FOUND')
+  );
+}
+
 export function createNativeAudioRecorder(
   options: NativeAudioRecorderOptions = {},
 ): VoiceRecorder {

scripts/prepare-package.js

@@ -11,21 +11,32 @@
  */
 
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultRootDir = path.resolve(__dirname, '..');
+const nodeRequire = createRequire(import.meta.url);
 
-export function preparePackage({ rootDir = defaultRootDir } = {}) {
+export function preparePackage({
+  rootDir = defaultRootDir,
+  requireNativeAudioCapture = process.env
+    .QWEN_REQUIRE_AUDIO_CAPTURE_PREBUILD === '1',
+} = {}) {
   const distDir = path.join(rootDir, 'dist');
 
   verifyBundleArtifacts(rootDir, distDir);
   copyDocumentationFiles(rootDir, distDir);
   copyLocales(rootDir, distDir);
   copyExtensionExamples(rootDir, distDir);
-  writeDistPackageJson(rootDir, distDir);
+  const bundleNativeAudioCapture = copyNativeAudioCapturePackage(
+    rootDir,
+    distDir,
+    { required: requireNativeAudioCapture },
+  );
+  writeDistPackageJson(rootDir, distDir, { bundleNativeAudioCapture });
   printPackageStructure(distDir);
 }
 
@@ -129,7 +140,97 @@ function copyExtensionExamples(rootDir, distDir) {
   }
 }
 
-function writeDistPackageJson(rootDir, distDir) {
+function copyNativeAudioCapturePackage(rootDir, distDir, { required } = {}) {
+  console.log('Copying native audio capture package...');
+
+  const addonSrc = path.join(rootDir, 'packages', 'audio-capture');
+  const addonDest = path.join(
+    distDir,
+    'node_modules',
+    '@qwen-code',
+    'audio-capture',
+  );
+  const requiredPaths = [
+    path.join(addonSrc, 'dist'),
+    path.join(addonSrc, 'prebuilds'),
+    path.join(addonSrc, 'package.json'),
+  ];
+
+  for (const requiredPath of requiredPaths) {
+    if (!fs.existsSync(requiredPath)) {
+      const message = `audio capture package artifact not found at ${requiredPath}`;
+      if (required) {
+        throw new Error(
+          `Required ${message}. ` +
+            'Cannot publish package without native voice capture.',
+        );
+      }
+      console.warn(`Warning: ${message}`);
+      return false;
+    }
+  }
+
+  const addonPkg = JSON.parse(
+    fs.readFileSync(path.join(addonSrc, 'package.json'), 'utf8'),
+  );
+  const dependencySources = [];
+  for (const dependencyName of Object.keys(addonPkg.dependencies ?? {})) {
+    try {
+      dependencySources.push([
+        dependencyName,
+        path.dirname(nodeRequire.resolve(`${dependencyName}/package.json`)),
+      ]);
+    } catch {
+      throw new Error(
+        `Required audio capture dependency not resolvable: ${dependencyName}. ` +
+          'Cannot publish package without native voice capture.',
+      );
+    }
+  }
+
+  delete addonPkg.scripts;
+  delete addonPkg.devDependencies;
+
+  const copyOpts = {
+    recursive: true,
+    dereference: true,
+    verbatimSymlinks: false,
+  };
+
+  fs.rmSync(addonDest, { recursive: true, force: true });
+  fs.mkdirSync(addonDest, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(addonDest, 'package.json'),
+    JSON.stringify(addonPkg, null, 2) + '\n',
+  );
+  fs.cpSync(path.join(addonSrc, 'dist'), path.join(addonDest, 'dist'), {
+    ...copyOpts,
+    filter: (src) => !/\.test\.(d\.)?[mc]?[jt]s(\.map)?$/.test(src),
+  });
+  fs.cpSync(
+    path.join(addonSrc, 'prebuilds'),
+    path.join(addonDest, 'prebuilds'),
+    copyOpts,
+  );
+
+  for (const [dependencyName, dependencySrc] of dependencySources) {
+    fs.cpSync(
+      dependencySrc,
+      path.join(addonDest, 'node_modules', dependencyName),
+      copyOpts,
+    );
+  }
+
+  console.log('Copied native audio capture package');
+  return true;
+}
+
+function writeDistPackageJson(
+  rootDir,
+  distDir,
+  { bundleNativeAudioCapture = false } = {},
+) {
   console.log('Creating package.json for distribution...');
 
   const cliEntryContent = `#!/usr/bin/env node
@@ -190,6 +291,9 @@ if (result.signal) {
       'bundled',
       'web-shell',
     ],
+    ...(bundleNativeAudioCapture
+      ? { bundledDependencies: ['@qwen-code/audio-capture'] }
+      : {}),
     config: rootPackageJson.config,
     dependencies: {},
     optionalDependencies: {