fix: resolve linter issues

- Remove unused imports in test files
- Fix import organization in Zemu.ts
- Fix formatting (newlines at end of files)
- Apply Biome linter rules

All tests passing after linter fixes.

Author: jleni

src/Zemu.ts

@@ -27,7 +27,6 @@ import { PNG, type PNGWithMetadata } from 'pngjs'
 import rndstr from 'randomstring'
 import { ClickNavigation, scheduleToNavElement, TouchNavigation } from './actions'
 import { getTouchElement } from './buttons'
-import { isCriticalTransportError, TransportError, getAPDUStatusMessage } from './errors'
 import {
   BASE_NAME,
   DEFAULT_EMU_IMG,
@@ -50,6 +49,7 @@ import {
 } from './constants'
 import { ContainerPool, type IPoolConfig, type IPooledContainer } from './containerPool'
 import EmuContainer from './emulator'
+import { getAPDUStatusMessage, isCriticalTransportError, TransportError } from './errors'
 import GRPCRouter from './grpc'
 import {
   ActionKind,
@@ -439,39 +439,39 @@ export default class Zemu {
 
   getTransport(): Transport {
     if (this.transport == null) throw new Error('Transport is not loaded.')
-    
+
     // Create a wrapper to intercept transport errors
     const self = this
     const originalTransport = this.transport
-    
+
     // Return a proxy that intercepts send() calls
     return new Proxy(originalTransport, {
       get(target, prop, receiver) {
         if (prop === 'send') {
-          return async function(cla: number, ins: number, p1: number, p2: number, data?: Buffer, statusList?: number[]) {
+          return async function (cla: number, ins: number, p1: number, p2: number, data?: Buffer, statusList?: number[]) {
             try {
               self.lastTransportError = null // Clear previous error
               const result = await target.send(cla, ins, p1, p2, data, statusList)
               return result
             } catch (error) {
               // Store the error for later checks
               self.lastTransportError = error as Error
-              
+
               // Log critical errors
               if (isCriticalTransportError(error)) {
                 const statusCode = (error as any).statusCode
                 self.log(`Critical transport error detected: ${getAPDUStatusMessage(statusCode)}`)
               }
-              
+
               // Re-throw the error
               throw error
             }
           }
         }
-        
+
         // For exchange and other methods, apply similar wrapping
         if (prop === 'exchange') {
-          return async function(apdu: Buffer) {
+          return async function (apdu: Buffer) {
             try {
               self.lastTransportError = null
               const result = await target.exchange(apdu)
@@ -486,10 +486,10 @@ export default class Zemu {
             }
           }
         }
-        
+
         // For all other properties/methods, return as-is
         return Reflect.get(target, prop, receiver)
-      }
+      },
     }) as Transport
   }
 
@@ -567,7 +567,7 @@ export default class Zemu {
           this.lastTransportError
         )
       }
-      
+
       const currentTime = new Date()
       const elapsed = currentTime.getTime() - start.getTime()
       if (elapsed > timeout) {
@@ -599,7 +599,7 @@ export default class Zemu {
           this.lastTransportError
         )
       }
-      
+
       const currentTime = new Date()
       const elapsed = currentTime.getTime() - start.getTime()
       if (elapsed > timeout) {
@@ -956,7 +956,7 @@ export default class Zemu {
     if (this.lastTransportError && isCriticalTransportError(this.lastTransportError)) {
       throw this.lastTransportError
     }
-    
+
     // eslint-disable-next-line @typescript-eslint/unbound-method
     axiosRetry(axios, { retryDelay: axiosRetry.exponentialDelay })
     const eventsUrl = `${this.transportProtocol}://${this.host}:${this.speculosApiPort}/events`
@@ -1003,7 +1003,7 @@ export default class Zemu {
           this.lastTransportError
         )
       }
-      
+
       const currentTime = new Date()
       const elapsed = currentTime.getTime() - start.getTime()
       if (elapsed > timeout) {

src/errors.ts

@@ -59,10 +59,10 @@ export class TransportError extends Error {
  */
 export function isCriticalTransportError(error: unknown): boolean {
   if (!error || typeof error !== 'object') return false
-  
+
   const statusCode = (error as any).statusCode
   if (typeof statusCode !== 'number') return false
-  
+
   return CRITICAL_TRANSPORT_ERRORS.includes(statusCode as any)
 }
 
@@ -96,4 +96,4 @@ export function getAPDUStatusMessage(statusCode: number): string {
     default:
       return `Unknown status code: 0x${statusCode.toString(16)}`
   }
-}
+}

tests/error-handling-fixed.test.ts

@@ -1,7 +1,7 @@
-import { describe, expect, test } from 'vitest'
 import { resolve } from 'node:path'
+import { describe, expect, test } from 'vitest'
 import Zemu, { DEFAULT_START_OPTIONS, IStartOptions } from '../src'
-import { TransportError, APDU_STATUS_CODES } from '../src/errors'
+import { TransportError } from '../src/errors'
 
 const DEMO_APP_PATH_S = resolve('bin/app_s.elf')
 
@@ -20,31 +20,31 @@ describe('Error Handling - Fixed', () => {
   test('Should fail fast on error 0x6984 instead of timing out', async () => {
     // Disable pooling globally for this test
     process.env.ZEMU_CONTAINER_POOLING = 'false'
-    
+
     const sim = new Zemu(DEMO_APP_PATH_S)
-    
+
     try {
       await sim.start(ZEMU_OPTIONS_S)
       const transport = sim.getTransport()
-      
+
       console.log('=== Testing invalid APDU command with new error handling ===')
-      
+
       // Send an invalid APDU command that should trigger error 0x6984
       const startTime = Date.now()
-      
+
       try {
         // Invalid CLA (0xFF) should cause error 0x6984
-        const result = await transport.send(0xFF, 0x00, 0x00, 0x00)
+        const result = await transport.send(0xff, 0x00, 0x00, 0x00)
         console.log('Unexpected success:', result)
         expect.fail('Expected transport.send to throw an error')
       } catch (error: any) {
         const elapsedTime = Date.now() - startTime
         console.log(`Error occurred after ${elapsedTime}ms`)
         console.log('Error statusCode:', error.statusCode)
-        
+
         // The error should happen quickly (< 1 second), not after a timeout
         expect(elapsedTime).toBeLessThan(1000)
-        
+
         // Check if we got the expected error code
         // Note: The actual error code might vary based on the app
         expect(error.statusCode).toBeDefined()
@@ -56,47 +56,47 @@ describe('Error Handling - Fixed', () => {
 
   test('Should propagate transport errors in waitUntilScreenIs', async () => {
     process.env.ZEMU_CONTAINER_POOLING = 'false'
-    
+
     const sim = new Zemu(DEMO_APP_PATH_S)
-    
+
     try {
       await sim.start(ZEMU_OPTIONS_S)
       const mainMenuSnapshot = sim.getMainMenuSnapshot()
-      
+
       console.log('=== Testing waitUntilScreenIs with transport error ===')
-      
+
       // First send an invalid command to trigger error
       const transport = sim.getTransport()
       try {
-        await transport.send(0xFF, 0x00, 0x00, 0x00)
+        await transport.send(0xff, 0x00, 0x00, 0x00)
       } catch (error: any) {
         console.log('Triggered error:', error.statusCode)
       }
-      
+
       // Now try to wait for screen - this should fail fast if error is critical
       const startTime = Date.now()
-      
+
       try {
         // Create a snapshot that won't match to force waiting
         const modifiedData = Buffer.from(mainMenuSnapshot.data)
         modifiedData[0] = (modifiedData[0] + 1) % 256
         const modifiedSnapshot = {
           ...mainMenuSnapshot,
-          data: modifiedData
+          data: modifiedData,
         }
-        
+
         await sim.waitUntilScreenIs(modifiedSnapshot, 5000)
-        
+
         // If we get here, check how long it took
         const elapsedTime = Date.now() - startTime
         console.log(`waitUntilScreenIs completed after ${elapsedTime}ms`)
-        
+
         // If error was critical, it should have failed fast
         // Otherwise it might wait for timeout or succeed
       } catch (error: any) {
         const elapsedTime = Date.now() - startTime
         console.log(`Error after ${elapsedTime}ms:`, error.message)
-        
+
         // Check if it's a transport error (fast fail) or timeout
         if (error instanceof TransportError) {
           expect(elapsedTime).toBeLessThan(1000)
@@ -114,36 +114,36 @@ describe('Error Handling - Fixed', () => {
 
   test('Should handle getEvents with transport error', async () => {
     process.env.ZEMU_CONTAINER_POOLING = 'false'
-    
+
     const sim = new Zemu(DEMO_APP_PATH_S)
-    
+
     try {
       await sim.start(ZEMU_OPTIONS_S)
-      
+
       console.log('=== Testing getEvents with transport error ===')
-      
+
       // First trigger a critical transport error
       const transport = sim.getTransport()
       let errorCode: number | undefined
-      
+
       try {
-        await transport.send(0xFF, 0x00, 0x00, 0x00)
+        await transport.send(0xff, 0x00, 0x00, 0x00)
       } catch (error: any) {
         errorCode = error.statusCode
         console.log('Triggered error code:', errorCode)
       }
-      
+
       // Now try getEvents - should throw if error is critical
       try {
         const events = await sim.getEvents()
         console.log('getEvents succeeded, got', events.length, 'events')
-        
+
         // This is OK - getEvents might succeed if error wasn't critical
         // or if the device recovered
         expect(Array.isArray(events)).toBe(true)
       } catch (error: any) {
         console.log('getEvents threw error:', error.message)
-        
+
         // If it throws, should be a transport error with statusCode
         expect(error.statusCode).toBeDefined()
         expect(error.message).toContain('CLA_NOT_SUPPORTED')
@@ -152,4 +152,4 @@ describe('Error Handling - Fixed', () => {
       await sim.close()
     }
   }, 30000)
-})
+})

tests/error-handling-simple.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, test } from 'vitest'
 import { resolve } from 'node:path'
+import { describe, expect, test } from 'vitest'
 import Zemu, { DEFAULT_START_OPTIONS, IStartOptions } from '../src'
 
 const DEMO_APP_PATH_S = resolve('bin/app_s.elf')
@@ -18,19 +18,19 @@ const ZEMU_OPTIONS_S: IStartOptions = {
 describe('Error Handling - Simple', () => {
   test.skip('First understand current timeout behavior', async () => {
     const sim = new Zemu(DEMO_APP_PATH_S)
-    
+
     try {
       await sim.start(ZEMU_OPTIONS_S)
       const transport = sim.getTransport()
-      
+
       console.log('=== Testing invalid APDU command ===')
-      
+
       // Send an invalid APDU command that should trigger error 0x6984
       const startTime = Date.now()
-      
+
       try {
         // Invalid CLA (0xFF) should cause error
-        const result = await transport.send(0xFF, 0x00, 0x00, 0x00)
+        const result = await transport.send(0xff, 0x00, 0x00, 0x00)
         console.log('Result:', result)
       } catch (error: any) {
         const elapsedTime = Date.now() - startTime
@@ -48,23 +48,23 @@ describe('Error Handling - Simple', () => {
   test('Test waitUntilScreenIs with timeout', async () => {
     // Disable pooling globally for this test
     process.env.ZEMU_CONTAINER_POOLING = 'false'
-    
+
     const sim = new Zemu(DEMO_APP_PATH_S)
-    
+
     try {
       await sim.start(ZEMU_OPTIONS_S)
       console.log('=== Testing waitUntilScreenIs behavior ===')
-      
+
       // Get a snapshot that will never match to force timeout
       const snapshot = await sim.snapshot()
       // Create a new Buffer with modified data so it won't match
       const modifiedData = Buffer.from(snapshot.data)
       modifiedData[0] = (modifiedData[0] + 1) % 256 // Change first byte
       const modifiedSnapshot = {
         ...snapshot,
-        data: modifiedData
+        data: modifiedData,
       }
-      
+
       const startTime = Date.now()
       try {
         // This should timeout after 2 seconds
@@ -73,7 +73,7 @@ describe('Error Handling - Simple', () => {
         const elapsedTime = Date.now() - startTime
         console.log(`Timeout occurred after ${elapsedTime}ms`)
         console.log('Error message:', error.message)
-        
+
         // Verify it actually waited for the timeout
         expect(elapsedTime).toBeGreaterThan(1900)
         expect(elapsedTime).toBeLessThan(2500)
@@ -83,4 +83,4 @@ describe('Error Handling - Simple', () => {
       await sim.close()
     }
   }, 30000)
-})
+})