servcraft 0.1.0 → 0.1.3

package/src/modules/media-processing/media-processing.routes.ts

@@ -0,0 +1,111 @@
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import type { MediaProcessingService } from './media-processing.service.js';
+import type { ImageOperation, VideoOperation, MediaType, ThumbnailOptions } from './types.js';
+
+/**
+ * Create media processing routes
+ */
+export function createMediaProcessingRoutes(mediaService: MediaProcessingService): Router {
+  const router = Router();
+
+  /**
+   * Process image
+   * POST /image
+   */
+  router.post('/image', async (req: Request, res: Response) => {
+    const { source, output, operations } = req.body as {
+      source: string;
+      output: string;
+      operations: ImageOperation[];
+    };
+
+    const result = await mediaService.processImage(source, output, operations);
+    res.json(result);
+  });
+
+  /**
+   * Process video
+   * POST /video
+   */
+  router.post('/video', async (req: Request, res: Response) => {
+    const { source, output, operations } = req.body as {
+      source: string;
+      output: string;
+      operations: VideoOperation[];
+    };
+
+    const result = await mediaService.processVideo(source, output, operations);
+    res.json(result);
+  });
+
+  /**
+   * Create processing job
+   * POST /jobs
+   */
+  router.post('/jobs', async (req: Request, res: Response) => {
+    const { mediaType, source, output, operations } = req.body as {
+      mediaType: MediaType;
+      source: string;
+      output: string;
+      operations: (ImageOperation | VideoOperation)[];
+    };
+
+    const job = await mediaService.createJob(mediaType, source, output, operations);
+    res.status(201).json(job);
+  });
+
+  /**
+   * Get job status
+   * GET /jobs/:id
+   */
+  router.get('/jobs/:id', async (req: Request, res: Response) => {
+    const jobId = req.params.id;
+    if (!jobId) {
+      res.status(400).json({ error: 'Job ID is required' });
+      return;
+    }
+
+    const job = await mediaService.getJob(jobId);
+
+    if (!job) {
+      res.status(404).json({ error: 'Job not found' });
+      return;
+    }
+
+    res.json(job);
+  });
+
+  /**
+   * Get media info
+   * POST /info
+   */
+  router.post('/info', async (req: Request, res: Response) => {
+    const { filePath } = req.body as { filePath: string };
+
+    if (!filePath) {
+      res.status(400).json({ error: 'filePath is required' });
+      return;
+    }
+
+    const info = await mediaService.getMediaInfo(filePath);
+    res.json(info);
+  });
+
+  /**
+   * Generate thumbnail
+   * POST /thumbnail
+   */
+  router.post('/thumbnail', async (req: Request, res: Response) => {
+    const { source, output, options } = req.body as {
+      source: string;
+      output: string;
+      options?: ThumbnailOptions;
+    };
+
+    const result = await mediaService.generateThumbnail(source, output, options);
+    res.json(result);
+  });
+
+  return router;
+}

package/src/modules/media-processing/media-processing.service.ts

@@ -0,0 +1,245 @@
+import { logger } from '../../core/logger.js';
+import { randomUUID } from 'crypto';
+import type {
+  MediaProcessingConfig,
+  ProcessingJob,
+  ImageOperation,
+  VideoOperation,
+  MediaInfo,
+  ThumbnailOptions,
+  ProcessingResult,
+  MediaType,
+} from './types.js';
+
+/**
+ * Media Processing Service
+ * Image and video processing with FFmpeg
+ */
+export class MediaProcessingService {
+  private config: MediaProcessingConfig;
+  private jobs = new Map<string, ProcessingJob>();
+  private queue: ProcessingJob[] = [];
+  private processing = 0;
+
+  constructor(config: MediaProcessingConfig = {}) {
+    this.config = {
+      ffmpegPath: 'ffmpeg',
+      ffprobePath: 'ffprobe',
+      tempDir: './temp',
+      maxConcurrent: 3,
+      gpuAcceleration: false,
+      ...config,
+    };
+
+    logger.info('Media processing service initialized');
+  }
+
+  /**
+   * Process image
+   */
+  async processImage(
+    source: string,
+    output: string,
+    operations: ImageOperation[]
+  ): Promise<ProcessingResult> {
+    const startTime = Date.now();
+
+    try {
+      // Note: In production, use Sharp library for image processing
+      // This is a placeholder implementation
+      logger.info({ source, output, operations }, 'Processing image');
+
+      // Simulate processing
+      await this.simulateProcessing();
+
+      return {
+        success: true,
+        outputPath: output,
+        processingTime: Date.now() - startTime,
+      };
+    } catch (error) {
+      logger.error({ source, error }, 'Image processing failed');
+      return {
+        success: false,
+        processingTime: Date.now() - startTime,
+        error: error instanceof Error ? error.message : 'Processing failed',
+      };
+    }
+  }
+
+  /**
+   * Process video
+   */
+  async processVideo(
+    source: string,
+    output: string,
+    operations: VideoOperation[]
+  ): Promise<ProcessingResult> {
+    const startTime = Date.now();
+
+    try {
+      // Note: In production, use fluent-ffmpeg or node-ffmpeg
+      logger.info({ source, output, operations }, 'Processing video');
+
+      // Simulate processing
+      await this.simulateProcessing();
+
+      return {
+        success: true,
+        outputPath: output,
+        processingTime: Date.now() - startTime,
+      };
+    } catch (error) {
+      logger.error({ source, error }, 'Video processing failed');
+      return {
+        success: false,
+        processingTime: Date.now() - startTime,
+        error: error instanceof Error ? error.message : 'Processing failed',
+      };
+    }
+  }
+
+  /**
+   * Create job
+   */
+  async createJob(
+    mediaType: MediaType,
+    source: string,
+    output: string,
+    operations: (ImageOperation | VideoOperation)[]
+  ): Promise<ProcessingJob> {
+    const job: ProcessingJob = {
+      id: randomUUID(),
+      mediaType,
+      source,
+      output,
+      operations,
+      status: 'pending',
+      progress: 0,
+      createdAt: new Date(),
+    };
+
+    this.jobs.set(job.id, job);
+    this.queue.push(job);
+
+    this.processQueue();
+
+    logger.info({ jobId: job.id }, 'Processing job created');
+
+    return job;
+  }
+
+  /**
+   * Get job status
+   */
+  async getJob(jobId: string): Promise<ProcessingJob | null> {
+    return this.jobs.get(jobId) || null;
+  }
+
+  /**
+   * Get media info
+   */
+  async getMediaInfo(filePath: string): Promise<MediaInfo> {
+    // Note: In production, use ffprobe
+    logger.info({ filePath }, 'Getting media info');
+
+    return {
+      path: filePath,
+      type: 'image',
+      format: 'jpeg',
+      size: 0,
+      width: 1920,
+      height: 1080,
+    };
+  }
+
+  /**
+   * Generate thumbnail
+   */
+  async generateThumbnail(
+    source: string,
+    output: string,
+    options: ThumbnailOptions = {}
+  ): Promise<ProcessingResult> {
+    const startTime = Date.now();
+
+    try {
+      logger.info({ source, output, options }, 'Generating thumbnail');
+
+      // Simulate processing
+      await this.simulateProcessing();
+
+      return {
+        success: true,
+        outputPath: output,
+        processingTime: Date.now() - startTime,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        processingTime: Date.now() - startTime,
+        error: error instanceof Error ? error.message : 'Thumbnail generation failed',
+      };
+    }
+  }
+
+  /**
+   * Process queue
+   */
+  private async processQueue(): Promise<void> {
+    if (this.processing >= (this.config.maxConcurrent || 3)) {
+      return;
+    }
+
+    const job = this.queue.shift();
+    if (!job) {
+      return;
+    }
+
+    this.processing++;
+    job.status = 'processing';
+
+    try {
+      let result: ProcessingResult;
+
+      if (job.mediaType === 'image') {
+        result = await this.processImage(
+          job.source,
+          job.output,
+          job.operations as ImageOperation[]
+        );
+      } else if (job.mediaType === 'video') {
+        result = await this.processVideo(
+          job.source,
+          job.output,
+          job.operations as VideoOperation[]
+        );
+      } else {
+        throw new Error('Unsupported media type');
+      }
+
+      job.status = result.success ? 'completed' : 'failed';
+      job.progress = 100;
+      job.completedAt = new Date();
+      job.processingTime = result.processingTime;
+
+      if (!result.success) {
+        job.error = result.error;
+      }
+    } catch (error) {
+      job.status = 'failed';
+      job.error = error instanceof Error ? error.message : 'Processing failed';
+      job.completedAt = new Date();
+    }
+
+    this.processing--;
+    this.processQueue();
+  }
+
+  /**
+   * Simulate processing (placeholder)
+   */
+  private async simulateProcessing(): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}

package/src/modules/media-processing/types.ts

@@ -0,0 +1,156 @@
+export type MediaType = 'image' | 'video' | 'audio';
+export type ImageFormat = 'jpeg' | 'png' | 'webp' | 'gif' | 'avif';
+export type VideoFormat = 'mp4' | 'webm' | 'avi' | 'mov';
+export type AudioFormat = 'mp3' | 'wav' | 'ogg' | 'aac';
+
+export interface MediaProcessingConfig {
+  /** FFmpeg path */
+  ffmpegPath?: string;
+  /** FFprobe path */
+  ffprobePath?: string;
+  /** Temporary directory */
+  tempDir?: string;
+  /** Max concurrent jobs */
+  maxConcurrent?: number;
+  /** Enable GPU acceleration */
+  gpuAcceleration?: boolean;
+}
+
+export interface ImageOperation {
+  type: 'resize' | 'crop' | 'rotate' | 'flip' | 'watermark' | 'compress' | 'filter';
+  options: ImageOperationOptions;
+}
+
+export interface ImageOperationOptions {
+  // Resize
+  width?: number;
+  height?: number;
+  fit?: 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+
+  // Crop
+  x?: number;
+  y?: number;
+
+  // Rotate
+  angle?: number;
+
+  // Flip
+  direction?: 'horizontal' | 'vertical';
+
+  // Watermark
+  text?: string;
+  image?: string;
+  position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
+  opacity?: number;
+
+  // Compress
+  quality?: number;
+
+  // Filter
+  filter?: 'grayscale' | 'blur' | 'sharpen' | 'sepia' | 'brightness' | 'contrast';
+  intensity?: number;
+}
+
+export interface VideoOperation {
+  type: 'trim' | 'resize' | 'compress' | 'extract-audio' | 'add-subtitle' | 'thumbnail';
+  options: VideoOperationOptions;
+}
+
+export interface VideoOperationOptions {
+  // Trim
+  startTime?: string;
+  endTime?: string;
+  duration?: string;
+
+  // Resize
+  width?: number;
+  height?: number;
+  scale?: string;
+
+  // Compress
+  bitrate?: string;
+  crf?: number;
+
+  // Thumbnail
+  timestamp?: string;
+  count?: number;
+
+  // Subtitle
+  subtitleFile?: string;
+}
+
+export interface ProcessingJob {
+  /** Job ID */
+  id: string;
+  /** Media type */
+  mediaType: MediaType;
+  /** Source file path */
+  source: string;
+  /** Output file path */
+  output: string;
+  /** Operations to perform */
+  operations: (ImageOperation | VideoOperation)[];
+  /** Job status */
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  /** Progress (0-100) */
+  progress: number;
+  /** Error message */
+  error?: string;
+  /** Created at */
+  createdAt: Date;
+  /** Completed at */
+  completedAt?: Date;
+  /** Processing time (ms) */
+  processingTime?: number;
+}
+
+export interface MediaInfo {
+  /** File path */
+  path: string;
+  /** Media type */
+  type: MediaType;
+  /** Format */
+  format: string;
+  /** Duration (for video/audio) */
+  duration?: number;
+  /** Width (for image/video) */
+  width?: number;
+  /** Height (for image/video) */
+  height?: number;
+  /** Bitrate */
+  bitrate?: number;
+  /** File size in bytes */
+  size: number;
+  /** Codec */
+  codec?: string;
+  /** Frame rate (for video) */
+  fps?: number;
+  /** Metadata */
+  metadata?: Record<string, unknown>;
+}
+
+export interface ThumbnailOptions {
+  /** Timestamp for video (e.g., '00:00:05') */
+  timestamp?: string;
+  /** Width */
+  width?: number;
+  /** Height */
+  height?: number;
+  /** Format */
+  format?: ImageFormat;
+  /** Quality (1-100) */
+  quality?: number;
+}
+
+export interface ProcessingResult {
+  /** Success status */
+  success: boolean;
+  /** Output file path */
+  outputPath?: string;
+  /** Processing time (ms) */
+  processingTime: number;
+  /** File size */
+  size?: number;
+  /** Error message */
+  error?: string;
+}

package/src/modules/mfa/index.ts

@@ -0,0 +1,20 @@
+export { MFAService, getMFAService, createMFAService } from './mfa.service.js';
+export { registerMFARoutes } from './mfa.routes.js';
+export {
+  generateSecret,
+  generateTOTP,
+  verifyTOTP,
+  generateTOTPUri,
+  generateQRCode,
+  formatSecretForDisplay,
+  getRemainingSeconds,
+} from './totp.js';
+export type {
+  MFAConfig,
+  MFAMethod,
+  UserMFA,
+  TOTPSetup,
+  MFAChallenge,
+  MFAVerifyResult,
+  BackupCodesResult,
+} from './types.js';