tuna-agent 0.1.137 → 0.1.138

package/dist/daemon/analyze-video-handler.js

@@ -14,6 +14,49 @@ const OPENAI_KEY = process.env.OPENAI_API_KEY || '';
 const YT_DLP = process.env.YT_DLP_BIN || '/home/gatoasang94/.local/bin/yt-dlp';
 const FFMPEG = process.env.FFMPEG_BIN || '/usr/bin/ffmpeg';
 const FFPROBE = process.env.FFPROBE_BIN || '/usr/bin/ffprobe';
+// Downloaded source videos are cached by URL hash so re-analyze doesn't
+// re-download (saves bandwidth + time on long clips). relabs01 shares disk
+// with Demucs + the local media server, so the cache is bounded: drop files
+// older than 7 days, then if the total still exceeds 15 GB evict oldest-first.
+const CACHE_DIR = path.join(os.homedir(), '.tuna-analyze-cache');
+const CACHE_MAX_AGE_MS = 7 * 24 * 3600 * 1000;
+const CACHE_MAX_BYTES = 15 * 1024 * 1024 * 1024;
+async function pruneVideoCache() {
+    try {
+        await fs.mkdir(CACHE_DIR, { recursive: true });
+        const names = await fs.readdir(CACHE_DIR);
+        const now = Date.now();
+        const live = [];
+        for (const name of names) {
+            const p = path.join(CACHE_DIR, name);
+            try {
+                const st = await fs.stat(p);
+                if (!st.isFile())
+                    continue;
+                if (now - st.mtimeMs > CACHE_MAX_AGE_MS) {
+                    await fs.rm(p, { force: true });
+                    continue;
+                }
+                live.push({ p, size: st.size, mtime: st.mtimeMs });
+            }
+            catch { /* race with another run deleting it — ignore */ }
+        }
+        let total = live.reduce((s, f) => s + f.size, 0);
+        if (total > CACHE_MAX_BYTES) {
+            live.sort((a, b) => a.mtime - b.mtime); // oldest first
+            for (const f of live) {
+                if (total <= CACHE_MAX_BYTES)
+                    break;
+                try {
+                    await fs.rm(f.p, { force: true });
+                    total -= f.size;
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch { /* cache pruning is best-effort; never block analysis */ }
+}
 function run(cmd, args, opts = {}) {
     return new Promise((resolve, reject) => {
         const p = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], ...opts });
@@ -224,14 +267,41 @@ export async function analyzeVideo(url, onProgress) {
     const progress = onProgress || (() => { });
     const tmpDir = path.join(os.tmpdir(), 'tuna-analyze-' + crypto.randomBytes(6).toString('hex'));
     await fs.mkdir(tmpDir, { recursive: true });
-    const videoPath = path.join(tmpDir, 'video.mp4');
+    // Video lives in the persistent URL-keyed cache (NOT tmpDir) so re-analyze
+    // reuses it. Only audio/frames are per-run + cleaned up in `finally`.
+    const urlHash = crypto.createHash('sha1').update(url).digest('hex');
+    const videoPath = path.join(CACHE_DIR, `${urlHash}.mp4`);
     const audioPath = path.join(tmpDir, 'audio.mp3');
     const framesDir = path.join(tmpDir, 'frames');
     await fs.mkdir(framesDir, { recursive: true });
     try {
-        progress('Đang tải video...');
-        console.log('[analyze_video] Downloading:', url);
-        await run(YT_DLP, ['-f', 'best[height<=720]/best', '-o', videoPath, '--no-playlist', '--quiet', url]);
+        await pruneVideoCache();
+        const cached = await fs.stat(videoPath).then(st => st.isFile() && st.size > 0).catch(() => false);
+        if (cached) {
+            progress('Dùng video đã tải (cache)...');
+            console.log('[analyze_video] Cache HIT:', videoPath);
+            // Bump mtime so an actively re-analyzed video isn't evicted by age.
+            try {
+                const now = new Date();
+                await fs.utimes(videoPath, now, now);
+            }
+            catch { /* ignore */ }
+        }
+        else {
+            progress('Đang tải video...');
+            console.log('[analyze_video] Cache MISS, downloading:', url);
+            // Download to a temp name then atomically rename in, so a concurrent
+            // analyze of the same URL never reads a half-written file.
+            const dlTmp = path.join(CACHE_DIR, `${urlHash}.dl-${crypto.randomBytes(4).toString('hex')}.mp4`);
+            try {
+                await run(YT_DLP, ['-f', 'best[height<=720]/best', '-o', dlTmp, '--no-playlist', '--quiet', url]);
+                await fs.rename(dlTmp, videoPath);
+            }
+            catch (e) {
+                await fs.rm(dlTmp, { force: true }).catch(() => { });
+                throw e;
+            }
+        }
         // Grab the original video title (metadata only, no extra download) so the
         // clone idea gets a real name instead of "Clone: www.youtube.com".
         let source_title = '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.137",
+  "version": "0.1.138",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"