aiden-runtime 3.16.0

package/dist/core/webSearch.js

@@ -0,0 +1,326 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reliableWebSearch = reliableWebSearch;
+exports.deepResearch = deepResearch;
+exports.checkSearxNG = checkSearxNG;
+// ── Constants ─────────────────────────────────────────────────
+const SEARXNG_URL = process.env.SEARXNG_URL || 'http://localhost:8888';
+const BRAVE_API_KEY = process.env.BRAVE_SEARCH_API_KEY || '';
+const SEARCH_TIMEOUT = 10000;
+const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36';
+// ── METHOD 1: SearxNG ──────────────────────────────────────────
+async function searchViaSearxNG(query) {
+    try {
+        const url = `${SEARXNG_URL}/search?q=${encodeURIComponent(query)}&format=json&language=en&categories=general`;
+        const res = await fetch(url, {
+            headers: { 'User-Agent': USER_AGENT, 'Accept': 'application/json' },
+            signal: AbortSignal.timeout(SEARCH_TIMEOUT),
+        });
+        if (!res.ok) {
+            console.warn(`[webSearch] SearxNG returned ${res.status}`);
+            return null;
+        }
+        const data = await res.json();
+        const results = (data.results || []).slice(0, 10).map((r) => ({
+            title: r.title || '',
+            url: r.url || '',
+            snippet: r.content || '',
+            source: 'searxng',
+        }));
+        if (results.length === 0)
+            return null;
+        const lines = results.map(r => `**${r.title}**\n${r.snippet}\n${r.url}`);
+        const output = `[SearxNG Results for "${query}"]\n\n${lines.join('\n\n')}`;
+        console.log(`[webSearch] SearxNG: ${results.length} results`);
+        return { success: true, output, method: 'searxng', results };
+    }
+    catch (e) {
+        console.warn(`[webSearch] SearxNG failed: ${e.message}`);
+        return null;
+    }
+}
+// ── METHOD 2: Brave Search API ────────────────────────────────
+async function searchViaBrave(query) {
+    if (!BRAVE_API_KEY)
+        return null;
+    try {
+        const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=10`;
+        const res = await fetch(url, {
+            headers: {
+                'Accept': 'application/json',
+                'Accept-Encoding': 'gzip',
+                'X-Subscription-Token': BRAVE_API_KEY,
+            },
+            signal: AbortSignal.timeout(SEARCH_TIMEOUT),
+        });
+        if (!res.ok) {
+            console.warn(`[webSearch] Brave API returned ${res.status}`);
+            return null;
+        }
+        const data = await res.json();
+        const webHits = data?.web?.results || [];
+        if (webHits.length === 0)
+            return null;
+        const results = webHits.map(r => ({
+            title: r.title || '',
+            url: r.url || '',
+            snippet: r.description || '',
+            source: 'brave',
+        }));
+        const lines = results.map(r => `**${r.title}**\n${r.snippet}\n${r.url}`);
+        const output = `[Brave Search Results for "${query}"]\n\n${lines.join('\n\n')}`;
+        console.log(`[webSearch] Brave: ${results.length} results`);
+        return { success: true, output, method: 'brave', results };
+    }
+    catch (e) {
+        console.warn(`[webSearch] Brave failed: ${e.message}`);
+        return null;
+    }
+}
+// ── METHOD 3: DuckDuckGo (Instant API + HTML scrape) ──────────
+async function searchViaDDG(query) {
+    const parts = [];
+    // DDG Instant Answer API
+    try {
+        const ddgUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
+        const ddgRes = await fetch(ddgUrl, {
+            headers: { 'User-Agent': USER_AGENT },
+            signal: AbortSignal.timeout(8000),
+        });
+        const ddgData = await ddgRes.json();
+        if (ddgData.Answer)
+            parts.push(`Answer: ${ddgData.Answer}`);
+        if (ddgData.Abstract)
+            parts.push(`Summary: ${ddgData.Abstract}`);
+        if (ddgData.AbstractText && !ddgData.Abstract)
+            parts.push(ddgData.AbstractText);
+        if (ddgData.RelatedTopics?.length) {
+            const topics = ddgData.RelatedTopics
+                .slice(0, 6)
+                .map(t => t.Text || t.Result || '')
+                .filter(Boolean);
+            if (topics.length)
+                parts.push(`Related: ${topics.join('. ')}`);
+        }
+    }
+    catch (e) {
+        console.warn(`[webSearch] DDG Instant failed: ${e.message}`);
+    }
+    // DDG HTML scrape — get snippet text + page content
+    try {
+        const htmlRes = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
+            headers: { 'User-Agent': USER_AGENT },
+            signal: AbortSignal.timeout(10000),
+        });
+        const html = await htmlRes.text();
+        // Extract snippets
+        const snippetMatches = [...html.matchAll(/class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g)];
+        const snippets = snippetMatches
+            .map(m => m[1].replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim())
+            .filter(s => s.length > 30)
+            .slice(0, 5);
+        if (snippets.length > 0) {
+            parts.push(`Search Snippets:\n${snippets.join('\n')}`);
+        }
+        // Fetch top 2 result pages
+        const urlMatches = [...html.matchAll(/uddg=(https?[^&"]+)/g)];
+        const urls = urlMatches
+            .map(m => decodeURIComponent(m[1]))
+            .filter(u => !u.includes('duckduckgo.com') && !u.includes('youtube.com') && u.startsWith('https'))
+            .filter((u, i, arr) => arr.indexOf(u) === i)
+            .slice(0, 2);
+        const pageTexts = await Promise.all(urls.map(async (url) => {
+            try {
+                const r = await fetch(url, {
+                    headers: { 'User-Agent': USER_AGENT },
+                    signal: AbortSignal.timeout(7000),
+                });
+                if (!r.ok)
+                    return null;
+                const text = await r.text();
+                const clean = text
+                    .replace(/<script[\s\S]*?<\/script>/gi, '')
+                    .replace(/<style[\s\S]*?<\/style>/gi, '')
+                    .replace(/<nav[\s\S]*?<\/nav>/gi, '')
+                    .replace(/<header[\s\S]*?<\/header>/gi, '')
+                    .replace(/<footer[\s\S]*?<\/footer>/gi, '')
+                    .replace(/<[^>]+>/g, ' ')
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                if (clean.length < 200)
+                    return null;
+                return `[${url}]\n${clean.slice(0, 1500)}`;
+            }
+            catch {
+                return null;
+            }
+        }));
+        const validPages = pageTexts.filter(Boolean);
+        if (validPages.length > 0)
+            parts.push(...validPages);
+    }
+    catch (e) {
+        console.warn(`[webSearch] DDG HTML scrape failed: ${e.message}`);
+    }
+    if (parts.length === 0)
+        return null;
+    const output = `[DuckDuckGo Results for "${query}"]\n\n${parts.join('\n\n')}`;
+    console.log(`[webSearch] DDG: ${parts.length} sections`);
+    return { success: true, output, method: 'ddg' };
+}
+// ── METHOD 4: Wikipedia ───────────────────────────────────────
+async function searchViaWikipedia(query) {
+    try {
+        const searchRes = await fetch(`https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&srlimit=5&format=json&origin=*`, { signal: AbortSignal.timeout(6000) });
+        const searchData = await searchRes.json();
+        const hits = searchData?.query?.search || [];
+        if (hits.length === 0)
+            return null;
+        const topTitle = hits[0].title;
+        const summaryRes = await fetch(`https://en.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(topTitle)}`, { signal: AbortSignal.timeout(6000) });
+        if (!summaryRes.ok)
+            return null;
+        const wiki = await summaryRes.json();
+        if (!wiki.extract || wiki.extract.length < 50)
+            return null;
+        const snippets = hits
+            .slice(1, 4)
+            .map(h => h.snippet?.replace(/<[^>]+>/g, '') || '')
+            .filter(s => s.length > 20);
+        const extra = snippets.length > 0 ? `\n\nRelated: ${snippets.join(' | ')}` : '';
+        const output = `[Wikipedia: ${wiki.title}]\n${wiki.extract.slice(0, 1500)}${extra}`;
+        console.log(`[webSearch] Wikipedia: ${wiki.extract.length} chars for "${wiki.title}"`);
+        return { success: true, output, method: 'wikipedia' };
+    }
+    catch (e) {
+        console.warn(`[webSearch] Wikipedia failed: ${e.message}`);
+        return null;
+    }
+}
+// ── Weather shortcut ──────────────────────────────────────────
+async function fetchWeather(query) {
+    const city = query
+        .replace(/what(?:'s| is) the weather/gi, '')
+        .replace(/\b(weather|forecast|today|current|temperature|rain|snow|sunny|cloudy|humidity|wind|in|for)\b/gi, '')
+        .replace(/\s+/g, ' ')
+        .trim() || 'auto';
+    try {
+        const wr = await fetch(`https://wttr.in/${encodeURIComponent(city)}?format=j1`, { signal: AbortSignal.timeout(8000) });
+        const data = await wr.json();
+        const cc = data.current_condition?.[0];
+        const area = data.nearest_area?.[0];
+        if (!cc || !area)
+            return null;
+        const location = [area.areaName?.[0]?.value, area.country?.[0]?.value].filter(Boolean).join(', ');
+        const desc = cc.weatherDesc?.[0]?.value || '';
+        let out = `Weather for ${location || city}:\n`;
+        out += `Condition: ${desc}\n`;
+        out += `Temperature: ${cc.temp_C}°C / ${cc.temp_F}°F (feels like ${cc.FeelsLikeC}°C)\n`;
+        out += `Humidity: ${cc.humidity}% | Wind: ${cc.windspeedKmph} km/h ${cc.winddir16Point} | Visibility: ${cc.visibility} km | UV: ${cc.uvIndex}\n`;
+        const forecasts = (data.weather || []).slice(0, 3);
+        if (forecasts.length) {
+            out += '\n3-Day Forecast:\n';
+            for (const day of forecasts) {
+                const mid = day.hourly?.[4]?.weatherDesc?.[0]?.value || '';
+                out += `  ${day.date}: High ${day.maxtempC}°C / Low ${day.mintempC}°C${mid ? ' — ' + mid : ''}\n`;
+            }
+        }
+        console.log(`[webSearch] Weather: retrieved for "${city}"`);
+        return { success: true, output: out.trim(), method: 'wttr.in' };
+    }
+    catch (e) {
+        console.warn(`[webSearch] Weather failed: ${e.message}`);
+        return null;
+    }
+}
+// ── Main exported function ────────────────────────────────────
+async function reliableWebSearch(query) {
+    if (!query?.trim())
+        return { success: false, output: '', error: 'No query provided' };
+    console.log(`[webSearch] Query: "${query}"`);
+    // Weather shortcut
+    if (/weather|temperature|forecast|rain|snow|sunny|cloudy|humidity|wind/i.test(query)) {
+        const weather = await fetchWeather(query);
+        if (weather)
+            return { success: true, output: weather.output };
+    }
+    // Method 1 — SearxNG
+    const searxResult = await searchViaSearxNG(query);
+    if (searxResult) {
+        console.log(`[webSearch] ✓ SearxNG succeeded`);
+        return { success: true, output: searxResult.output.slice(0, 10000) };
+    }
+    // Method 2 — Brave
+    const braveResult = await searchViaBrave(query);
+    if (braveResult) {
+        console.log(`[webSearch] ✓ Brave succeeded`);
+        return { success: true, output: braveResult.output.slice(0, 10000) };
+    }
+    // Method 3 — DDG
+    const ddgResult = await searchViaDDG(query);
+    if (ddgResult) {
+        console.log(`[webSearch] ✓ DDG succeeded`);
+        return { success: true, output: ddgResult.output.slice(0, 10000) };
+    }
+    // Method 4 — Wikipedia
+    const wikiResult = await searchViaWikipedia(query);
+    if (wikiResult) {
+        console.log(`[webSearch] ✓ Wikipedia fallback`);
+        return { success: true, output: wikiResult.output };
+    }
+    console.warn(`[webSearch] All methods failed for: "${query}"`);
+    return {
+        success: false,
+        output: '',
+        error: `Web search failed for "${query}" — all 4 methods exhausted (SearxNG, Brave, DuckDuckGo, Wikipedia). Try starting SearxNG: .\\scripts\\start-searxng.ps1`,
+    };
+}
+// ── Deep research — 3-pass synthesis ─────────────────────────
+async function deepResearch(topic) {
+    if (!topic?.trim())
+        return { success: false, output: '', error: 'No topic provided' };
+    console.log(`[deepResearch] Topic: "${topic}"`);
+    const parts = [];
+    // Pass 1: Broad
+    console.log(`[deepResearch] Pass 1: broad`);
+    const broad = await reliableWebSearch(topic);
+    if (broad.success && broad.output.length > 100) {
+        parts.push(`=== PASS 1: BROAD RESEARCH ===\n${broad.output}`);
+    }
+    // Pass 2: Latest 2026
+    const latestQ = `${topic} 2026 latest`;
+    console.log(`[deepResearch] Pass 2: latest — "${latestQ}"`);
+    const latest = await reliableWebSearch(latestQ);
+    if (latest.success && latest.output.length > 100) {
+        parts.push(`=== PASS 2: LATEST (2026) ===\n${latest.output}`);
+    }
+    // Pass 3: Comparison / review
+    const compareQ = `best top ${topic} comparison review`;
+    console.log(`[deepResearch] Pass 3: comparison — "${compareQ}"`);
+    const compare = await reliableWebSearch(compareQ);
+    if (compare.success && compare.output.length > 100) {
+        parts.push(`=== PASS 3: COMPARISON & REVIEWS ===\n${compare.output}`);
+    }
+    if (parts.length === 0) {
+        return { success: false, output: '', error: `No research results found for: ${topic}` };
+    }
+    const combined = parts.join('\n\n');
+    console.log(`[deepResearch] Complete: ${combined.length} chars across ${parts.length} passes`);
+    return { success: true, output: combined.slice(0, 15000) };
+}
+// ── SearxNG health check ──────────────────────────────────────
+async function checkSearxNG() {
+    try {
+        const res = await fetch(`${SEARXNG_URL}/search?q=test&format=json`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/workflowTracker.js

@@ -0,0 +1,72 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWorkflow = startWorkflow;
+exports.addNode = addNode;
+exports.updateNode = updateNode;
+exports.addEdge = addEdge;
+exports.completeWorkflow = completeWorkflow;
+exports.getWorkflow = getWorkflow;
+// core/workflowTracker.ts — Real-time agent orchestration tracker.
+// Emits workflow events onto eventBus so api/server.ts can forward
+// them to the dashboard via the existing /api/stream SSE channel.
+const eventBus_1 = require("./eventBus");
+// ── State ──────────────────────────────────────────────────────
+let currentWorkflow = null;
+// ── Internal emit ──────────────────────────────────────────────
+function emit(type, payload) {
+    eventBus_1.eventBus.emit('workflow_event', { type, ...payload });
+}
+// ── Public API ─────────────────────────────────────────────────
+function startWorkflow(goal) {
+    const id = `wf_${Date.now()}`;
+    currentWorkflow = {
+        id, goal, nodes: [], edges: [],
+        status: 'active',
+        totalCost: 0,
+        totalDuration: 0,
+        startedAt: Date.now(),
+    };
+    emit('workflow:start', { workflow: currentWorkflow });
+    return id;
+}
+function addNode(node) {
+    if (!currentWorkflow)
+        return;
+    if (currentWorkflow.nodes.some(n => n.id === node.id))
+        return;
+    currentWorkflow.nodes.push(node);
+    emit('workflow:node:add', { node });
+}
+function updateNode(nodeId, update) {
+    if (!currentWorkflow)
+        return;
+    const node = currentWorkflow.nodes.find(n => n.id === nodeId);
+    if (!node)
+        return;
+    Object.assign(node, update);
+    if (update.cost)
+        currentWorkflow.totalCost += update.cost;
+    emit('workflow:node:update', { nodeId, update });
+}
+function addEdge(edge) {
+    if (!currentWorkflow)
+        return;
+    if (currentWorkflow.edges.some(e => e.id === edge.id))
+        return;
+    currentWorkflow.edges.push(edge);
+    emit('workflow:edge', { edge });
+}
+function completeWorkflow(status) {
+    if (!currentWorkflow)
+        return;
+    currentWorkflow.status = status;
+    currentWorkflow.totalDuration = Date.now() - (currentWorkflow.startedAt ?? 0);
+    emit('workflow:complete', { workflow: currentWorkflow });
+}
+function getWorkflow() {
+    return currentWorkflow;
+}

package/dist/core/workspaceMemory.js

@@ -0,0 +1,54 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceMemory = void 0;
+// core/workspaceMemory.ts — Per-task file workspace.
+// Each task gets an isolated directory for intermediate artifacts.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class WorkspaceMemory {
+    constructor(taskId) {
+        this.taskDir = path_1.default.join(process.cwd(), 'workspace', 'tasks', taskId);
+        fs_1.default.mkdirSync(this.taskDir, { recursive: true });
+    }
+    write(filename, content) {
+        const filePath = path_1.default.join(this.taskDir, filename);
+        fs_1.default.writeFileSync(filePath, content, 'utf-8');
+        return filePath;
+    }
+    read(filename) {
+        const filePath = path_1.default.join(this.taskDir, filename);
+        if (!fs_1.default.existsSync(filePath))
+            return null;
+        return fs_1.default.readFileSync(filePath, 'utf-8');
+    }
+    append(filename, content) {
+        const filePath = path_1.default.join(this.taskDir, filename);
+        fs_1.default.appendFileSync(filePath, content + '\n', 'utf-8');
+        return filePath;
+    }
+    exists(filename) {
+        return fs_1.default.existsSync(path_1.default.join(this.taskDir, filename));
+    }
+    getPath(filename) {
+        return path_1.default.join(this.taskDir, filename);
+    }
+    getDir() {
+        return this.taskDir;
+    }
+    list() {
+        try {
+            return fs_1.default.readdirSync(this.taskDir);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.WorkspaceMemory = WorkspaceMemory;

package/dist/core/youtubeTranscript.js

@@ -0,0 +1,224 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVideoId = extractVideoId;
+exports.extractYouTubeTranscript = extractYouTubeTranscript;
+// core/youtubeTranscript.ts — Extract transcripts from YouTube
+// videos using the timedtext API (no API key required).
+// Falls back to yt-dlp if the page fetch is blocked, then to a
+// helpful error message asking the user to paste the transcript.
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// ── Video ID extraction ────────────────────────────────────────
+function extractVideoId(url) {
+    const patterns = [
+        /(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([a-zA-Z0-9_-]{11})/,
+        /^([a-zA-Z0-9_-]{11})$/,
+    ];
+    for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+// ── HTML entity decoder ────────────────────────────────────────
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&#39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#x2F;/g, '/')
+        .replace(/<[^>]*>/g, ''); // strip any inline tags
+}
+// ── Method 1: YouTube timedtext API (no key needed) ───────────
+async function fetchViaTimedtextApi(videoId) {
+    const pageUrl = `https://www.youtube.com/watch?v=${videoId}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15000);
+    let pageHtml;
+    try {
+        const resp = await fetch(pageUrl, {
+            signal: controller.signal,
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'Accept-Language': 'en-US,en;q=0.9',
+            },
+        });
+        pageHtml = await resp.text();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    // Extract caption tracks JSON from page source
+    const captionMatch = pageHtml.match(/"captionTracks":\[(\{.*?\})\]/);
+    if (!captionMatch) {
+        console.log('[YouTube] No captions found in page source');
+        return null;
+    }
+    let captionData;
+    try {
+        captionData = JSON.parse(`[${captionMatch[1]}]`);
+    }
+    catch {
+        console.log('[YouTube] Failed to parse captionTracks JSON');
+        return null;
+    }
+    // Prefer English, fall back to first available track
+    const track = captionData.find((t) => t.languageCode === 'en') ||
+        captionData.find((t) => t.languageCode?.startsWith('en')) ||
+        captionData[0];
+    if (!track?.baseUrl)
+        return null;
+    // Fetch the XML transcript
+    const xmlResp = await fetch(track.baseUrl);
+    const xml = await xmlResp.text();
+    // Parse <text start="…" dur="…">…</text> entries
+    const entries = [];
+    const regex = /<text start="([\d.]+)" dur="([\d.]+)"[^>]*>([\s\S]*?)<\/text>/g;
+    let m;
+    while ((m = regex.exec(xml)) !== null) {
+        const text = decodeHtmlEntities(m[3]).trim();
+        if (text) {
+            entries.push({
+                start: parseFloat(m[1]),
+                duration: parseFloat(m[2]),
+                text,
+            });
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    // Extract page title
+    const titleMatch = pageHtml.match(/<title>(.*?)<\/title>/);
+    const title = titleMatch?.[1]?.replace(/ - YouTube$/, '').trim() || 'YouTube Video';
+    const fullText = entries.map(e => e.text).join(' ');
+    return { title, transcript: entries, fullText };
+}
+// ── Method 2: yt-dlp fallback ──────────────────────────────────
+async function fetchViaYtDlp(videoId) {
+    const url = `https://www.youtube.com/watch?v=${videoId}`;
+    // Check if yt-dlp is available
+    try {
+        await execAsync('yt-dlp --version', { timeout: 5000 });
+    }
+    catch {
+        console.log('[YouTube] yt-dlp not installed — skipping fallback');
+        return null;
+    }
+    console.log('[YouTube] Trying yt-dlp fallback...');
+    // --write-auto-sub + --skip-download + --sub-format vtt
+    const cmd = `yt-dlp --write-auto-sub --skip-download --sub-lang en --sub-format vtt -o "/tmp/yt_%(id)s" "${url}"`;
+    try {
+        await execAsync(cmd, { timeout: 60000 });
+    }
+    catch (e) {
+        console.log('[YouTube] yt-dlp failed:', e.message?.slice(0, 80));
+        return null;
+    }
+    // Read the generated VTT file
+    const { readFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+    const vttPath = `/tmp/yt_${videoId}.en.vtt`;
+    if (!existsSync(vttPath)) {
+        console.log('[YouTube] yt-dlp did not produce a VTT file');
+        return null;
+    }
+    const vtt = readFileSync(vttPath, 'utf8');
+    // Parse VTT — strip cue headers and HTML tags, collect text lines
+    const lines = vtt.split('\n');
+    const texts = [];
+    const timeRe = /^\d{2}:\d{2}:\d{2}\.\d{3} --> /;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === 'WEBVTT' || timeRe.test(trimmed))
+            continue;
+        if (/^NOTE|^STYLE|^REGION/.test(trimmed))
+            continue;
+        const clean = trimmed.replace(/<[^>]+>/g, '').replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+        if (clean)
+            texts.push(clean);
+    }
+    if (texts.length === 0)
+        return null;
+    // Deduplicate consecutive identical lines (VTT often repeats)
+    const deduped = texts.filter((t, i) => i === 0 || t !== texts[i - 1]);
+    const fullText = deduped.join(' ');
+    return {
+        title: `YouTube Video (${videoId})`,
+        transcript: deduped.map((text, i) => ({ text, start: i, duration: 1 })),
+        fullText,
+    };
+}
+// ── Public entry point ─────────────────────────────────────────
+async function extractYouTubeTranscript(url) {
+    const videoId = extractVideoId(url);
+    if (!videoId) {
+        console.log('[YouTube] Could not extract video ID from URL:', url);
+        return null;
+    }
+    console.log(`[YouTube] Extracting transcript for video: ${videoId}`);
+    // Try primary method (timedtext API via page fetch)
+    try {
+        const result = await fetchViaTimedtextApi(videoId);
+        if (result) {
+            console.log(`[YouTube] Got transcript via timedtext API: ${result.transcript.length} segments`);
+            return result;
+        }
+    }
+    catch (err) {
+        console.log('[YouTube] timedtext API failed:', err.message?.slice(0, 120));
+    }
+    // Try yt-dlp fallback
+    try {
+        const result = await fetchViaYtDlp(videoId);
+        if (result) {
+            console.log(`[YouTube] Got transcript via yt-dlp: ${result.transcript.length} segments`);
+            return result;
+        }
+    }
+    catch (err) {
+        console.log('[YouTube] yt-dlp fallback failed:', err.message?.slice(0, 80));
+    }
+    console.log('[YouTube] All extraction methods failed for:', videoId);
+    return null;
+}