Add first-class ebook request support and UI

Implements first-class ebook requests with their own type, parent-child relationship to audiobook requests, and separate status flow. Updates database schema and migrations to support 'type' and 'parentRequestId' fields on requests. Adds processors and job types for ebook search and direct HTTP download from Anna's Archive, with FlareSolverr integration for Cloudflare bypass. Enhances admin UI tables and request actions to display and manage ebook requests, including orange badge and source links. Updates documentation to reflect new ebook support, configuration, and behavior.

src/lib/services/ebook-scraper.ts

@@ -304,8 +304,9 @@ export async function downloadEbook(
 
 /**
  * Step 1: Search Anna's Archive by ASIN and extract MD5 hash
+ * Exported for use by search-ebook processor
  */
-async function searchByAsin(
+export async function searchByAsin(
   asin: string,
   format: string,
   baseUrl: string,
@@ -394,8 +395,9 @@ async function searchByAsin(
 
 /**
  * Search Anna's Archive by title and author (fallback method)
+ * Exported for use by search-ebook processor
  */
-async function searchByTitle(
+export async function searchByTitle(
   title: string,
   author: string,
   format: string,
@@ -486,8 +488,9 @@ async function searchByTitle(
 
 /**
  * Step 3: Get slow download links from MD5 page (no waitlist only)
+ * Exported for use by search-ebook processor
  */
-async function getSlowDownloadLinks(
+export async function getSlowDownloadLinks(
   md5: string,
   baseUrl: string,
   logger?: RMABLogger,
@@ -561,7 +564,7 @@ async function getSlowDownloadLinks(
   }
 }
 
-interface ExtractedDownload {
+export interface ExtractedDownload {
   url: string;
   format: string;
 }
@@ -570,8 +573,9 @@ interface ExtractedDownload {
  * Step 4: Extract actual download URL from slow download page
  * IMPORTANT: Supports dynamic file formats (not hardcoded to .epub)
  * Returns both URL and detected format
+ * Exported for use by direct-download processor
  */
-async function extractDownloadUrl(
+export async function extractDownloadUrl(
   slowDownloadUrl: string,
   baseUrl: string,
   format: string,

src/lib/services/job-queue.service.ts

@@ -24,7 +24,11 @@ export type JobType =
   | 'retry_failed_imports'
   | 'cleanup_seeded_torrents'
   | 'monitor_rss_feeds'
-  | 'send_notification';
+  | 'send_notification'
+  // Ebook-specific job types
+  | 'search_ebook'
+  | 'start_direct_download'
+  | 'monitor_direct_download';
 
 export interface JobPayload {
   jobId?: string; // Database job ID (added automatically by addJob)
@@ -95,6 +99,45 @@ export interface CleanupSeededTorrentsPayload extends JobPayload {
   scheduledJobId?: string;
 }
 
+// Ebook-specific payload interfaces
+export interface SearchEbookPayload extends JobPayload {
+  requestId: string;
+  audiobook: {
+    id: string;
+    title: string;
+    author: string;
+    asin?: string; // ASIN for Anna's Archive search (best match)
+  };
+  preferredFormat?: string; // epub, pdf, mobi, azw3 (default: from config)
+}
+
+export interface EbookSearchResult {
+  md5: string;
+  title: string;
+  author: string;
+  format: string;
+  fileSize?: number;
+  downloadUrls: string[]; // Slow download URLs from Anna's Archive
+  source: 'annas_archive'; // For future indexer support
+  score: number; // Ranking score (for future multi-source ranking)
+}
+
+export interface StartDirectDownloadPayload extends JobPayload {
+  requestId: string;
+  downloadHistoryId: string;
+  downloadUrl: string;
+  targetFilename: string;
+  expectedSize?: number;
+}
+
+export interface MonitorDirectDownloadPayload extends JobPayload {
+  requestId: string;
+  downloadHistoryId: string;
+  downloadId: string; // Internal tracking ID
+  targetPath: string; // Full path to the downloading file
+  expectedSize?: number;
+}
+
 export interface SendNotificationPayload extends JobPayload {
   event: 'request_pending_approval' | 'request_approved' | 'request_available' | 'request_error';
   requestId: string;
@@ -301,6 +344,22 @@ export class JobQueueService {
       const { processSendNotification } = await import('../processors/send-notification.processor');
       return await processSendNotification(job.data);
     });
+
+    // Ebook-specific processors
+    this.queue.process('search_ebook', 3, async (job: BullJob<SearchEbookPayload>) => {
+      const { processSearchEbook } = await import('../processors/search-ebook.processor');
+      return await processSearchEbook(job.data);
+    });
+
+    this.queue.process('start_direct_download', 3, async (job: BullJob<StartDirectDownloadPayload>) => {
+      const { processStartDirectDownload } = await import('../processors/direct-download.processor');
+      return await processStartDirectDownload(job.data);
+    });
+
+    this.queue.process('monitor_direct_download', 5, async (job: BullJob<MonitorDirectDownloadPayload>) => {
+      const { processMonitorDirectDownload } = await import('../processors/direct-download.processor');
+      return await processMonitorDirectDownload(job.data);
+    });
   }
 
   /**
@@ -635,6 +694,83 @@ export class JobQueueService {
     );
   }
 
+  // =========================================================================
+  // EBOOK-SPECIFIC JOB METHODS
+  // =========================================================================
+
+  /**
+   * Add search ebook job (Anna's Archive search)
+   */
+  async addSearchEbookJob(
+    requestId: string,
+    audiobook: { id: string; title: string; author: string; asin?: string },
+    preferredFormat?: string
+  ): Promise<string> {
+    return await this.addJob(
+      'search_ebook',
+      {
+        requestId,
+        audiobook,
+        preferredFormat,
+      } as SearchEbookPayload,
+      {
+        priority: 10, // High priority for user-initiated requests
+      }
+    );
+  }
+
+  /**
+   * Add start direct download job (HTTP download for ebooks)
+   */
+  async addStartDirectDownloadJob(
+    requestId: string,
+    downloadHistoryId: string,
+    downloadUrl: string,
+    targetFilename: string,
+    expectedSize?: number
+  ): Promise<string> {
+    return await this.addJob(
+      'start_direct_download',
+      {
+        requestId,
+        downloadHistoryId,
+        downloadUrl,
+        targetFilename,
+        expectedSize,
+      } as StartDirectDownloadPayload,
+      {
+        priority: 9, // High priority - download selected ebook
+      }
+    );
+  }
+
+  /**
+   * Add monitor direct download job (tracks HTTP download progress)
+   */
+  async addMonitorDirectDownloadJob(
+    requestId: string,
+    downloadHistoryId: string,
+    downloadId: string,
+    targetPath: string,
+    expectedSize?: number,
+    delaySeconds: number = 0
+  ): Promise<string> {
+    return await this.addJob(
+      'monitor_direct_download',
+      {
+        requestId,
+        downloadHistoryId,
+        downloadId,
+        targetPath,
+        expectedSize,
+      } as MonitorDirectDownloadPayload,
+      {
+        priority: 5, // Medium priority
+        delay: delaySeconds * 1000,
+      }
+    );
+  }
+
   /**
    * Get job by ID
    */

src/lib/services/request-delete.service.ts

@@ -26,7 +26,7 @@ export interface DeleteRequestResult {
 /**
  * Soft delete a request with intelligent cleanup of media files and torrents
  *
- * Logic:
+ * Logic (audiobook requests):
  * 1. Check if request exists and is not already deleted
  * 2. For each download:
  *    - If unlimited seeding (0): Log and keep seeding, no monitoring
@@ -34,7 +34,15 @@ export interface DeleteRequestResult {
  *    - If seeding requirement met: Delete torrent + files
  *    - If still seeding: Keep in qBittorrent for cleanup job
  * 3. Delete media files (title folder only)
- * 4. Soft delete request (set deletedAt, deletedBy)
+ * 4. Delete from backend library (Plex/ABS)
+ * 5. Clear audiobook availability linkage
+ * 6. Soft delete request (set deletedAt, deletedBy)
+ *
+ * Logic (ebook requests):
+ * 1. Check if request exists and is not already deleted
+ * 2. Delete ebook files only (leave audiobook files intact)
+ * 3. Soft delete request (set deletedAt, deletedBy)
+ * Note: No backend library deletion or audiobook linkage clearing for ebooks
  */
 export async function deleteRequest(
   requestId: string,
@@ -57,6 +65,7 @@ export async function deleteRequest(
             audibleAsin: true,
             plexGuid: true,
             absItemId: true,
+            fileFormat: true,
           },
         },
         downloadHistory: {
@@ -71,6 +80,10 @@ export async function deleteRequest(
       },
     });
 
+    // Determine request type (default to audiobook for backward compatibility)
+    const requestType = (request as any)?.type || 'audiobook';
+    const isEbook = requestType === 'ebook';
+
     if (!request) {
       return {
         success: false,
@@ -87,10 +100,11 @@ export async function deleteRequest(
     let torrentsKeptSeeding = 0;
     let torrentsKeptUnlimited = 0;
 
-    // 2. Handle downloads & seeding
+    // 2. Handle downloads & seeding (skip for ebooks - they use direct HTTP downloads)
     const downloadHistory = request.downloadHistory[0];
+    const skipTorrentHandling = isEbook; // Ebooks use direct downloads, not torrents/NZBs
 
-    if (downloadHistory && downloadHistory.indexerName) {
+    if (!skipTorrentHandling && downloadHistory && downloadHistory.indexerName) {
       try {
         // Get indexer seeding configuration
         const { getConfigService } = await import('./config.service');
@@ -186,7 +200,9 @@ export async function deleteRequest(
       }
     }
 
-    // 3. Delete media files (title folder only)
+    // 3. Delete media files
+    // For audiobooks: delete entire title folder
+    // For ebooks: delete only ebook files (leave audiobook files intact)
     let filesDeleted = false;
     try {
       const { getConfigService } = await import('./config.service');
@@ -219,15 +235,34 @@ export async function deleteRequest(
         }
       );
 
-      // Check if folder exists and delete it
+      // Check if folder exists
       try {
         await fs.access(titleFolderPath);
 
-        // Delete the title folder (not the author folder)
-        await fs.rm(titleFolderPath, { recursive: true, force: true });
+        if (isEbook) {
+          // For ebooks: only delete ebook files, leave audiobook files intact
+          const ebookExtensions = ['.epub', '.pdf', '.mobi', '.azw', '.azw3', '.fb2', '.cbz', '.cbr'];
+          const files = await fs.readdir(titleFolderPath);
 
-        logger.info(`Deleted media directory: ${titleFolderPath}`);
-        filesDeleted = true;
+          let deletedCount = 0;
+          for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            if (ebookExtensions.includes(ext)) {
+              const filePath = path.join(titleFolderPath, file);
+              await fs.unlink(filePath);
+              logger.info(`Deleted ebook file: ${file}`);
+              deletedCount++;
+            }
+          }
+
+          filesDeleted = deletedCount > 0;
+          logger.info(`Deleted ${deletedCount} ebook file(s) from: ${titleFolderPath}`);
+        } else {
+          // For audiobooks: delete the entire title folder
+          await fs.rm(titleFolderPath, { recursive: true, force: true });
+          logger.info(`Deleted media directory: ${titleFolderPath}`);
+          filesDeleted = true;
+        }
       } catch (accessError) {
         // Folder doesn't exist - that's okay
         logger.info(`Media directory not found: ${titleFolderPath}`);
@@ -242,143 +277,188 @@ export async function deleteRequest(
     }
 
     // 4. Delete from plex_library table and clear audiobook availability
+    // Skip for ebooks - audiobook files and library entry should remain intact
     // This ensures the book immediately shows as NOT available when searching
-    try {
-      const { getConfigService } = await import('./config.service');
-      const configService = getConfigService();
-      const backendMode = await configService.getBackendMode();
+    if (!isEbook) {
+      try {
+        const { getConfigService } = await import('./config.service');
+        const configService = getConfigService();
+        const backendMode = await configService.getBackendMode();
 
-      // Delete from library backend (ABS or Plex)
-      if (backendMode === 'audiobookshelf' && request.audiobook.absItemId) {
-        // Audiobookshelf: delete the library item from ABS
-        try {
-          const { deleteABSItem } = await import('../services/audiobookshelf/api');
-          await deleteABSItem(request.audiobook.absItemId);
-          logger.info(
-            `Deleted Audiobookshelf library item ${request.audiobook.absItemId} for "${request.audiobook.title}"`
-          );
-        } catch (absError) {
-          logger.error(
-            `Error deleting Audiobookshelf library item ${request.audiobook.absItemId}`,
-            { error: absError instanceof Error ? absError.message : String(absError) }
-          );
-          // Continue with deletion even if ABS deletion fails
+        // Delete from library backend (ABS or Plex)
+        if (backendMode === 'audiobookshelf' && request.audiobook.absItemId) {
+          // Audiobookshelf: delete the library item from ABS
+          try {
+            const { deleteABSItem } = await import('../services/audiobookshelf/api');
+            await deleteABSItem(request.audiobook.absItemId);
+            logger.info(
+              `Deleted Audiobookshelf library item ${request.audiobook.absItemId} for "${request.audiobook.title}"`
+            );
+          } catch (absError) {
+            logger.error(
+              `Error deleting Audiobookshelf library item ${request.audiobook.absItemId}`,
+              { error: absError instanceof Error ? absError.message : String(absError) }
+            );
+            // Continue with deletion even if ABS deletion fails
+          }
+        } else if (backendMode === 'plex' && request.audiobook.plexGuid) {
+          // Plex: delete the library item from Plex by ratingKey
+          try {
+            // Query plex_library table to get the ratingKey
+            const plexLibraryRecord = await prisma.plexLibrary.findUnique({
+              where: { plexGuid: request.audiobook.plexGuid },
+              select: { plexRatingKey: true },
+            });
+
+            if (plexLibraryRecord && plexLibraryRecord.plexRatingKey) {
+              const ratingKey = plexLibraryRecord.plexRatingKey;
+
+              // Get Plex config
+              const plexServerUrl = (await configService.get('plex_url')) || '';
+              const plexToken = (await configService.get('plex_token')) || '';
+
+              if (plexServerUrl && plexToken) {
+                const { getPlexService } = await import('../integrations/plex.service');
+                const plexService = getPlexService();
+                await plexService.deleteItem(plexServerUrl, plexToken, ratingKey);
+                logger.info(
+                  `Deleted Plex library item ${ratingKey} (plexGuid: ${request.audiobook.plexGuid}) for "${request.audiobook.title}"`
+                );
+              } else {
+                logger.warn('Plex server URL or token not configured, skipping Plex library deletion');
+              }
+            } else {
+              logger.warn(
+                `No plexRatingKey found in plex_library for plexGuid: ${request.audiobook.plexGuid}`
+              );
+            }
+          } catch (plexError) {
+            logger.error(
+              `Error deleting Plex library item (plexGuid: ${request.audiobook.plexGuid})`,
+              { error: plexError instanceof Error ? plexError.message : String(plexError) }
+            );
+            // Continue with deletion even if Plex deletion fails
+          }
         }
-      } else if (backendMode === 'plex' && request.audiobook.plexGuid) {
-        // Plex: delete the library item from Plex by ratingKey
+
+        // Delete ALL plex_library records matching this audiobook's title and author
+        // This handles cases where there might be duplicate library records
+        // and ensures the book doesn't show as "In Your Library" during searches
         try {
-          // Query plex_library table to get the ratingKey
-          const plexLibraryRecord = await prisma.plexLibrary.findUnique({
-            where: { plexGuid: request.audiobook.plexGuid },
-            select: { plexRatingKey: true },
+          // Find all matching library records (by title/author fuzzy match)
+          const matchingLibraryRecords = await prisma.plexLibrary.findMany({
+            where: {
+              title: {
+                contains: request.audiobook.title.substring(0, 20),
+                mode: 'insensitive',
+              },
+            },
           });
 
-          if (plexLibraryRecord && plexLibraryRecord.plexRatingKey) {
-            const ratingKey = plexLibraryRecord.plexRatingKey;
+          // Filter to exact matches (case-insensitive title and author)
+          const exactMatches = matchingLibraryRecords.filter((record) => {
+            const titleMatch = record.title.toLowerCase() === request.audiobook.title.toLowerCase();
+            const authorMatch = record.author.toLowerCase() === request.audiobook.author.toLowerCase();
+            return titleMatch && authorMatch;
+          });
 
-            // Get Plex config
-            const plexServerUrl = (await configService.get('plex_url')) || '';
-            const plexToken = (await configService.get('plex_token')) || '';
+          if (exactMatches.length > 0) {
+            // Delete all exact matches
+            const deletePromises = exactMatches.map((record) =>
+              prisma.plexLibrary.delete({ where: { id: record.id } })
+            );
 
-            if (plexServerUrl && plexToken) {
-              const { getPlexService } = await import('../integrations/plex.service');
-              const plexService = getPlexService();
-              await plexService.deleteItem(plexServerUrl, plexToken, ratingKey);
-              logger.info(
-                `Deleted Plex library item ${ratingKey} (plexGuid: ${request.audiobook.plexGuid}) for "${request.audiobook.title}"`
-              );
-            } else {
-              logger.warn('Plex server URL or token not configured, skipping Plex library deletion');
-            }
+            await Promise.all(deletePromises);
+
+            logger.info(
+              `Deleted ${exactMatches.length} plex_library record(s) for "${request.audiobook.title}"`
+            );
           } else {
-            logger.warn(
-              `No plexRatingKey found in plex_library for plexGuid: ${request.audiobook.plexGuid}`
+            logger.info(
+              `No plex_library records found for "${request.audiobook.title}"`
             );
           }
-        } catch (plexError) {
+        } catch (libError) {
           logger.error(
-            `Error deleting Plex library item (plexGuid: ${request.audiobook.plexGuid})`,
-            { error: plexError instanceof Error ? plexError.message : String(plexError) }
+            `Error deleting plex_library records`,
+            { error: libError instanceof Error ? libError.message : String(libError) }
           );
-          // Continue with deletion even if Plex deletion fails
+          // Continue with deletion even if library cleanup fails
         }
-      }
 
-      // Delete ALL plex_library records matching this audiobook's title and author
-      // This handles cases where there might be duplicate library records
-      // and ensures the book doesn't show as "In Your Library" during searches
+        // Clear audiobook record linkage
+        const updateData: any = {
+          status: 'requested', // Reset to requested state
+          updatedAt: new Date(),
+        };
+
+        // Clear library linkage based on backend mode
+        if (backendMode === 'audiobookshelf') {
+          updateData.absItemId = null;
+        } else {
+          updateData.plexGuid = null;
+        }
+
+        await prisma.audiobook.update({
+          where: { id: request.audiobook.id },
+          data: updateData,
+        });
+
+        logger.info(
+          `Cleared availability status for audiobook ${request.audiobook.id}`
+        );
+      } catch (error) {
+        logger.error(
+          `Error clearing audiobook status`,
+          { error: error instanceof Error ? error.message : String(error) }
+        );
+        // Continue with deletion even if this fails
+      }
+    } else {
+      logger.info(`Skipping backend library deletion for ebook request ${requestId}`);
+    }
+
+    // 5. Delete child requests (ebook requests linked to this audiobook request)
+    if (!isEbook) {
       try {
-        // Find all matching library records (by title/author fuzzy match)
-        const matchingLibraryRecords = await prisma.plexLibrary.findMany({
+        const childRequests = await prisma.request.findMany({
           where: {
-            title: {
-              contains: request.audiobook.title.substring(0, 20),
-              mode: 'insensitive',
-            },
+            parentRequestId: requestId,
+            deletedAt: null,
+          },
+          select: {
+            id: true,
+            type: true,
           },
         });
 
-        // Filter to exact matches (case-insensitive title and author)
-        const exactMatches = matchingLibraryRecords.filter((record) => {
-          const titleMatch = record.title.toLowerCase() === request.audiobook.title.toLowerCase();
-          const authorMatch = record.author.toLowerCase() === request.audiobook.author.toLowerCase();
-          return titleMatch && authorMatch;
-        });
+        if (childRequests.length > 0) {
+          logger.info(`Found ${childRequests.length} child request(s) to delete`);
 
-        if (exactMatches.length > 0) {
-          // Delete all exact matches
-          const deletePromises = exactMatches.map((record) =>
-            prisma.plexLibrary.delete({ where: { id: record.id } })
-          );
+          // Soft delete all child requests
+          await prisma.request.updateMany({
+            where: {
+              parentRequestId: requestId,
+              deletedAt: null,
+            },
+            data: {
+              deletedAt: new Date(),
+              deletedBy: adminUserId,
+            },
+          });
 
-          await Promise.all(deletePromises);
-
-          logger.info(
-            `Deleted ${exactMatches.length} plex_library record(s) for "${request.audiobook.title}"`
-          );
-        } else {
-          logger.info(
-            `No plex_library records found for "${request.audiobook.title}"`
-          );
+          logger.info(`Soft-deleted ${childRequests.length} child request(s)`);
         }
-      } catch (libError) {
+      } catch (error) {
         logger.error(
-          `Error deleting plex_library records`,
-          { error: libError instanceof Error ? libError.message : String(libError) }
+          `Error deleting child requests for ${requestId}`,
+          { error: error instanceof Error ? error.message : String(error) }
         );
-        // Continue with deletion even if library cleanup fails
+        // Continue with parent deletion even if child deletion fails
       }
-
-      // Clear audiobook record linkage
-      const updateData: any = {
-        status: 'requested', // Reset to requested state
-        updatedAt: new Date(),
-      };
-
-      // Clear library linkage based on backend mode
-      if (backendMode === 'audiobookshelf') {
-        updateData.absItemId = null;
-      } else {
-        updateData.plexGuid = null;
-      }
-
-      await prisma.audiobook.update({
-        where: { id: request.audiobook.id },
-        data: updateData,
-      });
-
-      logger.info(
-        `Cleared availability status for audiobook ${request.audiobook.id}`
-      );
-    } catch (error) {
-      logger.error(
-        `Error clearing audiobook status`,
-        { error: error instanceof Error ? error.message : String(error) }
-      );
-      // Continue with deletion even if this fails
     }
 
-    // 5. Soft delete request
+    // 6. Soft delete request
     await prisma.request.update({
       where: { id: requestId },
       data: {