chore: add screenshot

Author: chrisbbreuer

.github/art/screenshot.png

@@ -10,6 +10,8 @@
 
 A TypeScript library and CLI tool for converting Audible AAX audiobooks to standard MP3, M4A, or M4B formats.
 
+![Screenshot](.github/art/screenshot.png)
+
 ## Features
 
 - Convert AAX files to MP3, M4A, or M4B formats

README.md

@@ -2,6 +2,7 @@ import type { ConversionOptions, ConversionResult } from './types'
 import { existsSync, mkdirSync } from 'node:fs'
 import path from 'node:path'
 import { config } from './config'
+import { getActivationBytesFromAudibleCli } from './utils/activation'
 import { checkFFmpeg, runFFmpeg } from './utils/ffmpeg'
 import { logger } from './utils/logger'
 import { getBookMetadata } from './utils/metadata'
@@ -51,6 +52,14 @@ function generateOutputPath(metadata: any, options: ConversionOptions): string {
  */
 export async function convertAAX(options: ConversionOptions): Promise<ConversionResult> {
   // Validate input file
+  if (!options.inputFile) {
+    logger.error('No input file provided. Please specify an AAX file to convert.')
+    return {
+      success: false,
+      error: 'No input file provided',
+    }
+  }
+
   if (!existsSync(options.inputFile)) {
     logger.error(`Input file does not exist: ${options.inputFile}`)
     return {
@@ -59,24 +68,24 @@ export async function convertAAX(options: ConversionOptions): Promise<Conversion
     }
   }
 
-  // Start the conversion process with a nice header
-  await logger.box(`Converting ${path.basename(options.inputFile)}`)
-
-  // Check FFmpeg
-  logger.info('Checking FFmpeg installation...')
+  // Check for ffmpeg
   const ffmpegAvailable = await checkFFmpeg()
   if (!ffmpegAvailable) {
-    logger.error('FFmpeg is not available. Please install FFmpeg or set ffmpegPath in config.')
+    logger.error('FFmpeg is not available. Please install FFmpeg and try again.')
     return {
       success: false,
-      error: 'FFmpeg is not available. Please install FFmpeg or set ffmpegPath in config.',
+      error: 'FFmpeg not found. Required for conversion.',
     }
   }
+  logger.info('Checking FFmpeg installation...')
+
+  // Get activation code
+  const activationCode = options.activationCode || config.activationCode || await getActivationBytesFromAudibleCli()
 
-  // Validate activation code
-  const activationCode = options.activationCode || config.activationCode
   if (!activationCode) {
-    logger.error('No activation code provided. This is required to convert AAX files.')
+    logger.error('No activation code provided for decryption.')
+    logger.info('You can specify an activation code with the -c option or set it in your config.')
+    logger.info('To auto-detect activation code, run "aax setup-audible" first.')
     return {
       success: false,
       error: 'No activation code provided. This is required to convert AAX files.',
@@ -113,8 +122,13 @@ export async function convertAAX(options: ConversionOptions): Promise<Conversion
       logger.info(`Chapters: ${metadata.chapters.length}`)
     }
 
+    // Avoid duplicate logs by using logger.debug for detailed path info
     logger.info(`Output format: ${options.outputFormat || config.outputFormat || 'mp3'}`)
-    logger.info(`Output path: ${outputPath}`)
+
+    // Only log the base output path once, more detailed path info in debug
+    const shortPath = path.basename(outputPath)
+    logger.info(`Output path: ${shortPath}`)
+    logger.debug(`Full output path: ${outputPath}`)
 
     // Build FFmpeg command
     logger.info('Preparing FFmpeg command...')

src/converter.ts

@@ -81,22 +81,23 @@ export async function runFFmpeg(args: string[]): Promise<{ success: boolean, out
     let currentSize = '0KB'
     let currentSpeed = '0x'
 
-    // Progress bar
-    const progressBar = isMetadataExtraction
-      ? null
-      : logger.progress(100, 'Preparing conversion...')
+    // Progress bar reference - only created once explicitly needed
+    let progressBar: ReturnType<typeof logger.progress> | null = null
+
+    // Flag to prevent duplicate completion messages
+    let progressCompleted = false
 
     // Regular update interval
     const updateInterval = setInterval(() => {
-      if (!progressBar || !bookDuration)
+      if (!progressBar || !bookDuration || progressCompleted)
         return
 
       // Only apply time-based updates if we're actually making progress
       const now = Date.now()
       if (now - lastOutputTime > 3000 && currentTimeMs > 0) {
         // It's been a while since the last FFmpeg update, show progress is still happening
         // Assume some minimal progress
-        const progressPercent = Math.max(0.1, Math.min(99.9, (currentTimeMs / bookDuration) * 100))
+        const progressPercent = Math.min(99, (currentTimeMs / bookDuration) * 100)
         progressBar.update(progressPercent, `Converting ${formatTime(currentTimeMs)} / ${formatTime(bookDuration)} (${currentSpeed}) - Size: ${currentSize}`)
 
         // Small time progress so user knows it's not frozen
@@ -105,24 +106,31 @@ export async function runFFmpeg(args: string[]): Promise<{ success: boolean, out
     }, 1000)
 
     function updateProgressFromOutput(text: string) {
-      if (!progressBar)
-        return
-
       const progress = parseFFmpegProgress(text)
 
       // Get total duration once we know it
       if (progress.totalMs && progress.totalMs > 0 && !bookDuration) {
         bookDuration = progress.totalMs
+
+        // Create progress bar when we first know the duration
+        // This prevents creating it prematurely
+        if (!isMetadataExtraction && !progressBar && !progressCompleted) {
+          progressBar = logger.progress(100, 'Starting conversion...')
+        }
       }
 
+      // Skip further processing if no progress bar
+      if (!progressBar || progressCompleted)
+        return
+
       // Update time position if provided
       if (progress.timeMs !== undefined) {
         currentTimeMs = progress.timeMs
         lastOutputTime = Date.now()
 
         // Calculate progress percentage based on time
         if (bookDuration) {
-          const progressPercent = Math.max(0.1, Math.min(99.9, (currentTimeMs / bookDuration) * 100))
+          const progressPercent = Math.min(99, (currentTimeMs / bookDuration) * 100)
 
           // Update size and speed if available
           if (progress.size)
@@ -191,19 +199,31 @@ export async function runFFmpeg(args: string[]): Promise<{ success: boolean, out
     ffmpeg.on('close', (code) => {
       clearInterval(updateInterval)
 
-      if (progressBar) {
+      if (progressBar && !progressCompleted) {
+        progressCompleted = true
+
         if (code === 0) {
-          progressBar.finish('Conversion completed successfully!')
+          // This is where the duplicate message happens
+          // Set to 100% first and only then finish with message
+          progressBar.update(100)
+          const barRef = progressBar // Store reference to avoid null issues
+          setTimeout(() => {
+            if (barRef)
+              barRef.finish('Conversion completed successfully!')
+          }, 50)
         }
         else {
           progressBar.interrupt('Conversion failed', 'error')
         }
       }
 
-      resolve({
-        success: code === 0,
-        output,
-      })
+      // Give a small delay to allow the progress bar to finish properly
+      setTimeout(() => {
+        resolve({
+          success: code === 0,
+          output,
+        })
+      }, 100)
     })
   })
 }
@@ -212,7 +232,12 @@ export async function runFFmpeg(args: string[]): Promise<{ success: boolean, out
  * Extracts metadata from an AAX file using FFmpeg
  */
 export async function extractAAXMetadata(filePath: string): Promise<string> {
-  logger.info(`Extracting metadata from ${filePath}...`)
+  // Shorten the filepath display if it's too long
+  const displayPath = filePath.length > 70
+    ? `...${filePath.substring(filePath.length - 67)}`
+    : filePath
+
+  logger.debug(`Extracting metadata from ${displayPath}...`)
 
   // For metadata extraction we use a simple info message rather than a progress bar
   // since it's usually quick and doesn't provide meaningful progress information