Avoid problems with them extensions self built by external vite

alfonso-noriega · alfonso-noriega · commit 3d4bf3a9c27d · 2025-10-31T13:21:23.000+01:00
diff --git a/packages/app/src/cli/services/dev/app-events/app-event-watcher.ts b/packages/app/src/cli/services/dev/app-events/app-event-watcher.ts
@@ -234,48 +234,74 @@ export class AppEventWatcher extends EventEmitter {
    * buildForBundle method.
    */
   private async buildExtensions(extensionEvents: ExtensionEvent[]) {
-    const promises = extensionEvents.map(async (extEvent) => {
-      const ext = extEvent.extension
-      return useConcurrentOutputContext({outputPrefix: ext.handle, stripAnsi: false}, async () => {
-        try {
-          if (this.esbuildManager.contexts?.[ext.uid]?.length) {
-            await this.esbuildManager.rebuildContext(ext)
-            this.options.stdout.write(`Build successful`)
-          } else {
-            await this.buildExtension(ext)
-          }
-          extEvent.buildResult = {status: 'ok', uid: ext.uid}
-          // eslint-disable-next-line no-catch-all/no-catch-all, @typescript-eslint/no-explicit-any
-        } catch (error: any) {
-          // If there is an `errors` array, it's an esbuild error, format it and log it
-          // If not, just print the error message to stderr.
-          const errors: Message[] = error.errors ?? []
-          let errorMessage = error.message
-          let errorFile: string | undefined
-
-          if (errors.length) {
-            // Use the first error for the main message and file
-            const firstError = errors[0]
-            errorMessage = firstError?.text
-            errorFile = firstError?.location?.file
-
-            const formattedErrors = formatMessagesSync(errors, {kind: 'error', color: !isUnitTest()})
-            formattedErrors.forEach((error) => {
-              this.options.stderr.write(error)
+    // Group events by extension to handle multiple events for the same extension
+    const groupedExtensionEvents = extensionEvents.reduce<{extension: ExtensionInstance; events: ExtensionEvent[]}[]>(
+      (grouped: {extension: ExtensionInstance; events: ExtensionEvent[]}[], event: ExtensionEvent) => {
+        const existingGroup = grouped.find((group) => group.extension.uid === event.extension.uid)
+        if (existingGroup) {
+          existingGroup.events.push(event)
+        } else {
+          grouped.push({
+            extension: event.extension,
+            events: [event],
+          })
+        }
+        return grouped
+      },
+      [],
+    )
+
+    const promises = groupedExtensionEvents
+      .filter(({events}) => events.length > 0)
+      .map(async ({extension: ext, events}) => {
+        return useConcurrentOutputContext({outputPrefix: ext.handle, stripAnsi: false}, async () => {
+          try {
+            if (this.esbuildManager.contexts?.[ext.uid]?.length) {
+              await this.esbuildManager.rebuildContext(ext)
+              this.options.stdout.write(`Build successful`)
+            } else {
+              await this.buildExtension(ext)
+            }
+            // Update all events for this extension with success result
+            const buildResult = {status: 'ok' as const, uid: ext.uid}
+            events.forEach((event) => {
+              event.buildResult = buildResult
+            })
+            // eslint-disable-next-line no-catch-all/no-catch-all, @typescript-eslint/no-explicit-any
+          } catch (error: any) {
+            // If there is an `errors` array, it's an esbuild error, format it and log it
+            // If not, just print the error message to stderr.
+            const errors: Message[] = error.errors ?? []
+            let errorMessage = error.message
+            let errorFile: string | undefined
+
+            if (errors.length) {
+              // Use the first error for the main message and file
+              const firstError = errors[0]
+              errorMessage = firstError?.text
+              errorFile = firstError?.location?.file
+
+              const formattedErrors = formatMessagesSync(errors, {kind: 'error', color: !isUnitTest()})
+              formattedErrors.forEach((error) => {
+                this.options.stderr.write(error)
+              })
+            } else {
+              this.options.stderr.write(error.message)
+            }
+
+            // Update all events for this extension with error result
+            const buildResult = {
+              status: 'error' as const,
+              error: errorMessage,
+              file: errorFile,
+              uid: ext.uid,
+            }
+            events.forEach((event) => {
+              event.buildResult = buildResult
             })
-          } else {
-            this.options.stderr.write(error.message)
-          }
-
-          extEvent.buildResult = {
-            status: 'error',
-            error: errorMessage,
-            file: errorFile,
-            uid: ext.uid,
           }
-        }
+        })
       })
-    })
     return Promise.all(promises)
   }
 
diff --git a/packages/app/src/cli/services/extensions/bundle.ts b/packages/app/src/cli/services/extensions/bundle.ts
@@ -68,14 +68,38 @@ export async function bundleThemeExtension(
   options.stdout.write(`Bundling theme extension ${extension.localIdentifier}...`)
   const files = await themeExtensionFiles(extension)
 
-  await Promise.all(
-    files.map(function (filepath) {
+  const results = await Promise.allSettled(
+    files.map(async function (filepath) {
       const relativePathName = relativePath(extension.directory, filepath)
       const outputFile = joinPath(extension.outputPath, relativePathName)
-      if (filepath === outputFile) return
-      return copyFile(filepath, outputFile)
+      if (filepath === outputFile) return {status: 'skipped', filepath}
+
+      try {
+        await copyFile(filepath, outputFile)
+        return {status: 'success', filepath}
+        // eslint-disable-next-line no-catch-all/no-catch-all
+      } catch (error) {
+        // Log warning but don't fail the entire process
+        // We intentionally catch all errors here to continue copying other files
+        outputDebug(`Failed to copy file ${filepath}: ${error}`)
+        return {status: 'failed', filepath, error}
+      }
     }),
   )
+
+  // Report any failures as warnings
+  const failures = results.filter((result) => {
+    return result.status === 'rejected' || (result.status === 'fulfilled' && result.value?.status === 'failed')
+  })
+
+  if (failures.length > 0) {
+    const failedFiles = failures.map((failure) => {
+      if (failure.status === 'rejected') return 'unknown file'
+      const value = (failure as PromiseFulfilledResult<{status: string; filepath: string}>).value
+      return value.filepath
+    })
+    outputDebug(`Warning: ${failures.length} file(s) could not be copied: ${failedFiles.join(', ')}`)
+  }
 }
 
 export async function copyFilesForExtension(
@@ -93,14 +117,39 @@ export async function copyFilesForExtension(
     ignore: ignored,
   })
 
-  await Promise.all(
-    files.map(function (filepath) {
+  const results = await Promise.allSettled(
+    files.map(async function (filepath) {
       const relativePathName = relativePath(extension.directory, filepath)
       const outputFile = joinPath(extension.outputPath, relativePathName)
-      if (filepath === outputFile) return
-      return copyFile(filepath, outputFile)
+      if (filepath === outputFile) return {status: 'skipped', filepath}
+
+      try {
+        await copyFile(filepath, outputFile)
+        return {status: 'success', filepath}
+        // eslint-disable-next-line no-catch-all/no-catch-all
+      } catch (error) {
+        // Log warning but don't fail the entire process
+        // We intentionally catch all errors here to continue copying other files
+        outputDebug(`Failed to copy file ${filepath}: ${error}`)
+        return {status: 'failed', filepath, error}
+      }
     }),
   )
+
+  // Report any failures as warnings
+  const failures = results.filter((result) => {
+    return result.status === 'rejected' || (result.status === 'fulfilled' && result.value?.status === 'failed')
+  })
+
+  if (failures.length > 0) {
+    const failedFiles = failures.map((failure) => {
+      if (failure.status === 'rejected') return 'unknown file'
+      const value = (failure as PromiseFulfilledResult<{status: string; filepath: string}>).value
+      return value.filepath
+    })
+    outputDebug(`Warning: ${failures.length} file(s) could not be copied: ${failedFiles.join(', ')}`)
+  }
+
   options.stdout.write(`${extension.localIdentifier} successfully built`)
 }
 
diff --git a/packages/cli-kit/src/public/node/archiver.integration.test.ts b/packages/cli-kit/src/public/node/archiver.integration.test.ts
@@ -1,11 +1,12 @@
 import {zip, brotliCompress} from './archiver.js'
-import {fileExists, inTemporaryDirectory, mkdir, touchFile} from './fs.js'
+import {fileExists, inTemporaryDirectory, mkdir, touchFile, removeFile, readFile} from './fs.js'
 import {joinPath, dirname} from './path.js'
 import {exec} from './system.js'
-import {describe, expect, test} from 'vitest'
+import {describe, expect, test, vi} from 'vitest'
 import StreamZip from 'node-stream-zip'
 import brotli from 'brotli'
 import fs from 'fs'
+import {glob} from './fs.js'
 
 describe('zip', () => {
   test('zips a directory', async () => {
@@ -57,6 +58,51 @@ describe('zip', () => {
       expect(expectedEntries.sort()).toEqual(archiveEntries.sort())
     })
   })
+
+  test('gracefully handles files deleted during archiving', async () => {
+    await inTemporaryDirectory(async (tmpDir) => {
+      // Given
+      const zipPath = joinPath(tmpDir, 'output.zip')
+      const outputDirectoryName = 'output'
+      const outputDirectoryPath = joinPath(tmpDir, outputDirectoryName)
+      const structure = ['file1.js', 'file2.js', 'file3.js']
+
+      await createFiles(structure, outputDirectoryPath)
+
+      const file2Path = joinPath(outputDirectoryPath, 'file2.js')
+
+      // Spy on readFile to simulate a file being deleted during archiving
+      // We'll make readFile throw ENOENT for file2.js specifically
+      const fsModule = await import('./fs.js')
+      const originalReadFile = fsModule.readFile
+      const readFileSpy = vi.spyOn(fsModule, 'readFile')
+      readFileSpy.mockImplementation(async (path: string) => {
+        if (path === file2Path) {
+          const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, open '${path}'`)
+          error.code = 'ENOENT'
+          throw error
+        }
+        return originalReadFile(path)
+      })
+
+      // When - should not throw even though file2.js throws ENOENT
+      await expect(
+        zip({
+          inputDirectory: outputDirectoryPath,
+          outputZipPath: zipPath,
+        }),
+      ).resolves.not.toThrow()
+
+      // Then - archive should contain remaining files only
+      const archiveEntries = await readArchiveFiles(zipPath)
+      expect(archiveEntries).toContain('file1.js')
+      expect(archiveEntries).toContain('file3.js')
+      // file2.js should not be in archive since readFile failed
+      expect(archiveEntries).not.toContain('file2.js')
+
+      readFileSpy.mockRestore()
+    })
+  })
 })
 
 describe('brotliCompress', () => {
@@ -141,6 +187,48 @@ describe('brotliCompress', () => {
       expect(fs.existsSync(joinPath(extractPath, 'test.json'))).toBeFalsy()
     })
   })
+
+  test('gracefully handles files deleted during compression', async () => {
+    await inTemporaryDirectory(async (tmpDir) => {
+      // Given
+      const brotliPath = joinPath(tmpDir, 'output.br')
+      const outputDirectoryName = 'output'
+      const outputDirectoryPath = joinPath(tmpDir, outputDirectoryName)
+      const structure = ['file1.js', 'file2.js', 'file3.js']
+
+      await createFiles(structure, outputDirectoryPath)
+
+      const file2Path = joinPath(outputDirectoryPath, 'file2.js')
+
+      // Spy on readFile to simulate a file being deleted during compression
+      // We'll make readFile throw ENOENT for file2.js specifically
+      const fsModule = await import('./fs.js')
+      const originalReadFile = fsModule.readFile
+      const readFileSpy = vi.spyOn(fsModule, 'readFile')
+      readFileSpy.mockImplementation(async (path: string) => {
+        if (path === file2Path) {
+          const error: NodeJS.ErrnoException = new Error(`ENOENT: no such file or directory, open '${path}'`)
+          error.code = 'ENOENT'
+          throw error
+        }
+        return originalReadFile(path)
+      })
+
+      // When - should not throw even though file2.js throws ENOENT
+      await expect(
+        brotliCompress({
+          inputDirectory: outputDirectoryPath,
+          outputPath: brotliPath,
+        }),
+      ).resolves.not.toThrow()
+
+      // Then - compressed file should exist and be valid
+      const exists = await fileExists(brotliPath)
+      expect(exists).toBeTruthy()
+
+      readFileSpy.mockRestore()
+    })
+  })
 })
 
 async function createFiles(structure: string[], directory: string) {
diff --git a/packages/cli-kit/src/public/node/archiver.ts b/packages/cli-kit/src/public/node/archiver.ts
