feat(recording): implement simplified recording system with API endpoints and UI integration

bin/services/simple_recorder.dart

@@ -0,0 +1,221 @@
+import 'dart:async';
+import 'dart:io';
+import 'package:uuid/uuid.dart';
+import '../database/database.dart';
+import '../models/recording.dart';
+
+/// 🎯 SIMPLIFIED Recording System - One job: Record streams
+class SimpleRecorder {
+  final AppDatabase db;
+  final String recordingsDir;
+  
+  // Active recordings (streamId -> process)
+  final Map<String, _ActiveRecording> _active = {};
+  
+  SimpleRecorder(this.db, {this.recordingsDir = '/app/recordings'});
+
+  /// Initialize recordings directory
+  Future<void> init() async {
+    final dir = Directory(recordingsDir);
+    if (!await dir.exists()) {
+      await dir.create(recursive: true);
+    }
+    print('🎬 Recorder ready -> $recordingsDir');
+  }
+
+  /// Start recording immediately
+  Future<String> startRecording({
+    required String channelId,
+    required String streamUrl,
+    required String title,
+    required Duration duration,
+  }) async {
+    if (_active.containsKey(channelId)) {
+      throw Exception('Already recording: $title');
+    }
+
+    final recordingId = const Uuid().v4();
+    final now = DateTime.now();
+    final endTime = now.add(duration);
+
+    // Create recording in DB
+    db.createRecording(
+      userId: 'system',
+      channelId: channelId,
+      streamUrl: streamUrl,
+      title: title,
+      startTime: now,
+      endTime: endTime,
+    );
+
+    // Generate safe filename
+    final filename = _safeName(title, recordingId);
+    final filepath = '$recordingsDir/$filename';
+
+    // Start FFmpeg process
+    try {
+      final ffmpeg = await Process.start('ffmpeg', [
+        '-y',
+        '-i', streamUrl,
+        '-c', 'copy',
+        '-t', '${duration.inSeconds}',
+        filepath,
+      ]);
+
+      _active[channelId] = _ActiveRecording(
+        id: recordingId,
+        process: ffmpeg,
+        filepath: filepath,
+        endTime: endTime,
+      );
+
+      // Update DB
+      db.updateRecordingStatus(recordingId, 'recording', filePath: filepath);
+
+      // Auto-stop when time is up or process ends
+      ffmpeg.exitCode.then((_) {
+        db.updateRecordingStatus(recordingId, 'completed');
+        _active.remove(channelId);
+        print('✅ Recording done: $title');
+      }).catchError((e) {
+        db.updateRecordingStatus(recordingId, 'failed', errorReason: 'FFmpeg error');
+        _active.remove(channelId);
+      });
+
+      print('🔴 Recording: $title ($duration)');
+      return recordingId;
+    } catch (e) {
+      db.updateRecordingStatus(recordingId, 'failed', errorReason: '$e');
+      rethrow;
+    }
+  }
+
+  /// Schedule recording for later
+  Future<String> scheduleRecording({
+    required String channelId,
+    required String streamUrl,
+    required String title,
+    required DateTime startTime,
+    required DateTime endTime,
+  }) async {
+    final recordingId = const Uuid().v4();
+    
+    // Create in DB with 'scheduled' status
+    db.createRecording(
+      userId: 'system',
+      channelId: channelId,
+      streamUrl: streamUrl,
+      title: title,
+      startTime: startTime,
+      endTime: endTime,
+    );
+
+    // Schedule auto-start
+    final delay = startTime.difference(DateTime.now());
+    if (delay.isNegative) {
+      throw Exception('Start time is in the past');
+    }
+
+    Timer(delay, () async {
+      try {
+        await startRecording(
+          channelId: channelId,
+          streamUrl: streamUrl,
+          title: title,
+          duration: endTime.difference(startTime),
+        );
+      } catch (e) {
+        print('❌ Auto-start failed: $e');
+      }
+    });
+
+    print('⏰ Scheduled: $title at ${startTime.toLocal()}');
+    return recordingId;
+  }
+
+  /// Stop recording immediately
+  Future<void> stopRecording(String channelId) async {
+    final active = _active[channelId];
+    if (active == null) return;
+
+    active.process.kill();
+    db.updateRecordingStatus(active.id, 'completed');
+    _active.remove(channelId);
+    print('⏹️  Stopped: $channelId');
+  }
+
+  /// Check scheduled recordings (call every minute)
+  Future<void> checkScheduled() async {
+    final now = DateTime.now();
+    for (final rec in db.getAllRecordings()) {
+      if (rec.status != 'scheduled') continue;
+      if (now.isBefore(rec.startTime)) continue;
+
+      try {
+        await startRecording(
+          channelId: rec.channelId,
+          streamUrl: rec.streamUrl,
+          title: rec.title,
+          duration: rec.endTime.difference(rec.startTime),
+        );
+      } catch (e) {
+        print('❌ Auto-start error: $e');
+        db.updateRecordingStatus(rec.id, 'failed', errorReason: '$e');
+      }
+    }
+  }
+
+  /// Get active recordings
+  List<Map<String, dynamic>> getActive() {
+    return _active.entries.map((e) => {
+      'id': e.value.id,
+      'channel': e.key,
+      'filepath': e.value.filepath,
+      'endsAt': e.value.endTime.toIso8601String(),
+    }).toList();
+  }
+
+  /// Cleanup old recordings (keep last 20)
+  Future<void> cleanupOld({int keepCount = 20}) async {
+    final dir = Directory(recordingsDir);
+    final files = dir
+        .listSync()
+        .whereType<File>()
+        .toList()
+        ..sort((a, b) => b.statSync().modified.compareTo(a.statSync().modified));
+
+    if (files.length > keepCount) {
+      for (final file in files.skip(keepCount)) {
+        await file.delete();
+        print('🗑️  Deleted: ${file.path}');
+      }
+    }
+  }
+
+  String _safeName(String title, String id) {
+    final safe = title.replaceAll(RegExp(r'[^a-zA-Z0-9_-]'), '_');
+    final timestamp = DateTime.now().toIso8601String().replaceAll(':', '').split('.')[0];
+    return '${safe}_$timestamp.mkv';
+  }
+
+  void dispose() {
+    for (final rec in _active.values) {
+      rec.process.kill();
+    }
+  }
+}
+
+/// Internal: Active recording tracking
+class _ActiveRecording {
+  final String id;
+  final Process process;
+  final String filepath;
+  final DateTime endTime;
+
+  _ActiveRecording({
+    required this.id,
+    required this.process,
+    required this.filepath,
+    required this.endTime,
+  });
+}