latinfo 0.16.0 → 0.18.0

package/dist/index.js

@@ -47,7 +47,7 @@ const local_search_1 = require("./local-search");
 const client_search_1 = require("./client-search");
 const odis_search_1 = require("./odis-search");
 const mphf_search_1 = require("./mphf-search");
-const VERSION = '0.16.0';
+const VERSION = '0.18.0';
 const API_URL = process.env.LATINFO_API_URL || 'https://api.latinfo.dev';
 const GITHUB_CLIENT_ID = process.env.GITHUB_CLIENT_ID || 'Ov23li5fcQaiCsVtaMKK';
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.latinfo');
@@ -748,39 +748,171 @@ function costsSimulate(usersStr, rpmStr, proPctStr) {
     printCosts({ users, pro_users: proUsers, requests, cf_tier: cfTier, cf_cost: cfCost, revenue, margin, safe: margin >= 0 });
 }
 // --- Bench ---
-const BENCH_SAMPLES = {
-    'pe/ruc': [
-        '20100047218', '20100070970', '20131312955', '20103343984', '20100059502',
-        '20512002090', '20100030595', '20504437303', '20601188848', '20100017491',
-        '20602105251', '20600006805', '20348550455', '20547141826', '20601427564',
-        '20429423558', '20100192660', '20330791884', '20519398169', '20501503536',
-    ],
-    'pe/search': [
-        'banco', 'minera', 'construccion', 'servicios', 'comercial',
-        'inversiones', 'grupo empresarial', 'empresa', 'sociedad', 'industria',
-        'peru', 'lima', 'consultora', 'transporte', 'holding',
-        'desarrollos', 'ingenieria', 'tecnologia', 'salud', 'educacion',
-    ],
-    'pe/oece/tenders': [
-        'servicio', 'construccion', 'suministro', 'consultoria', 'mantenimiento',
-        'obra', 'adquisicion', 'sistema', 'equipos', 'vehiculos',
-        'alimentos', 'seguridad', 'limpieza', 'transporte', 'software',
-    ],
-    'co/nit': [
-        '0901620698', '0800099778', '0860002264', '0890903938', '0890399995',
-        '0830114921', '0900544580', '0860030380', '0811046900', '0900073223',
-        '0800037800', '0800149923', '0800235461', '0800193650', '0812003744',
-    ],
-    'co/search': [
-        'banco', 'minera', 'construccion', 'servicios', 'comercializadora',
-        'inversiones', 'grupo', 'empresa', 'sociedad', 'fundacion',
-        'transporte', 'ingenieria', 'consultoria', 'salud', 'tecnologia',
-    ],
-};
+// --- Search server status ---
+async function searchServerStatus() {
+    const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+    const RUNNER = 'f3mt0@100.109.82.87';
+    // Test SSH
+    try {
+        execSync(`ssh -o ConnectTimeout=5 ${RUNNER} "echo OK"`, { stdio: 'pipe' });
+    }
+    catch {
+        console.error('  Linux Mint not reachable. Is it on?');
+        process.exit(1);
+    }
+    // Check health
+    try {
+        const health = execSync(`ssh ${RUNNER} "curl -s http://localhost:3001/health"`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const data = JSON.parse(health);
+        if (data.status === 'ok') {
+            console.log(`\n  Search server: READY`);
+            console.log(`  Mode: ${data.mode || 'ram'}`);
+            console.log(`  Sources: ${data.sources.join(', ')}`);
+            console.log(`  Disk shards: ${data.diskShards || 0}`);
+            console.log(`  RAM shards: ${data.ramShards || 0}`);
+            console.log(`  RAM: ${data.ramMB || '?'} MB`);
+            // Quick search test
+            const t0 = Date.now();
+            const testResult = execSync(`ssh ${RUNNER} "curl -s 'http://localhost:3001/search?source=${data.sources[0]}&q=banco'"`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+            const testData = JSON.parse(testResult);
+            console.log(`\n  Search test (${data.sources[0]}): ${testData.results?.length || 0} results in ${testData.ms}ms`);
+            return;
+        }
+    }
+    catch { }
+    // Not ready — show download progress
+    console.log(`\n  Search server: LOADING\n`);
+    const diskUsage = execSync(`ssh ${RUNNER} "du -sm /tmp/latinfo-search-data/ 2>/dev/null | awk '{print \\$1}'"`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    const currentMB = parseInt(diskUsage) || 0;
+    const totalExpected = 6400;
+    const pct = Math.min(Math.floor(currentMB / totalExpected * 100), 99);
+    const filled = Math.floor(pct * 30 / 100);
+    const bar = '█'.repeat(filled) + '░'.repeat(30 - filled);
+    console.log(`  [${bar}] ${currentMB}/${totalExpected} MB (${pct}%)`);
+    // Show last shard activity
+    const lastLog = execSync(`ssh ${RUNNER} "sudo journalctl -u latinfo-search --no-pager -n 5 2>/dev/null | grep -oE '(Shard [0-9]+|Loading [^ ]+)' | tail -1"`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    if (lastLog)
+        console.log(`  Last: ${lastLog}`);
+    // Show RAM
+    const ram = execSync(`ssh ${RUNNER} "free -h | awk '/Mem:/{print \\$3\"/\"\\$2}'"`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+    console.log(`  RAM: ${ram}`);
+}
+// Seed queries used to discover real data from the API
+const SEED_QUERIES = ['banco', 'empresa', 'servicios', 'comercial', 'grupo'];
+function discoverBenchSources(filterSource) {
+    const repo = getRepoPath();
+    const sourcesDir = path_1.default.join(repo, 'sources');
+    if (!fs_1.default.existsSync(sourcesDir))
+        return [];
+    const yamls = fs_1.default.readdirSync(sourcesDir).filter(f => f.endsWith('.yaml'));
+    const sources = [];
+    for (const file of yamls) {
+        const content = fs_1.default.readFileSync(path_1.default.join(sourcesDir, file), 'utf-8');
+        const nameMatch = content.match(/^name:\s*(.+)/m);
+        const countryMatch = content.match(/^country:\s*(.+)/m);
+        const institutionMatch = content.match(/^institution:\s*(.+)/m);
+        const datasetMatch = content.match(/^dataset:\s*(.+)/m);
+        const idNameMatch = content.match(/primary_id:\s*\n\s*name:\s*(.+)/);
+        const idLenMatch = content.match(/primary_id:[\s\S]*?length:\s*(\d+)/);
+        const smokeIdMatch = content.match(/smoke_test:\s*\n\s*id:\s*"?([^"\n]+)"?/);
+        if (!nameMatch || !countryMatch || !institutionMatch || !datasetMatch)
+            continue;
+        const name = nameMatch[1].trim();
+        if (filterSource && name !== filterSource)
+            continue;
+        const routePath = `/${countryMatch[1].trim()}/${institutionMatch[1].trim()}/${datasetMatch[1].trim()}`;
+        const primaryId = {
+            name: idNameMatch ? idNameMatch[1].trim() : 'id',
+            length: idLenMatch ? parseInt(idLenMatch[1]) : 10,
+        };
+        const smokeId = smokeIdMatch ? smokeIdMatch[1].trim() : undefined;
+        const lookupIds = [];
+        if (smokeId)
+            lookupIds.push(smokeId);
+        sources.push({ name, routePath, primaryId, smokeId, lookupIds, searchQueries: [] });
+    }
+    return sources;
+}
+/** Generate a non-existent ID based on the primary ID pattern */
+function generateFakeId(length) {
+    // All 9s — unlikely to be a real ID
+    return '9'.repeat(length);
+}
+/** Seed lookup IDs + search queries from real API data */
+async function seedBenchQueries(source, apiKey) {
+    const headers = { Authorization: `Bearer ${apiKey}` };
+    const names = [];
+    // Fetch real records via search
+    for (const seed of SEED_QUERIES) {
+        try {
+            const res = await fetch(`${API_URL}${source.routePath}/search?q=${encodeURIComponent(seed)}&limit=20`, {
+                headers, signal: AbortSignal.timeout(10_000),
+            });
+            if (!res.ok)
+                continue;
+            const data = await res.json();
+            for (const r of data) {
+                const id = r.id || r[source.primaryId.name];
+                if (id && !source.lookupIds.includes(String(id)))
+                    source.lookupIds.push(String(id));
+                // Extract the search field (first string field that isn't the ID)
+                const name = Object.values(r).find((v, i) => typeof v === 'string' && i > 0);
+                if (name && name.length > 3)
+                    names.push(name);
+            }
+        }
+        catch { }
+        if (source.lookupIds.length >= 20 && names.length >= 20)
+            break;
+    }
+    // Add non-existent IDs for edge case testing
+    for (let i = 0; i < 5; i++) {
+        source.lookupIds.push(generateFakeId(source.primaryId.length));
+    }
+    // Generate diverse search queries from real names
+    const uniqueNames = [...new Set(names)];
+    for (const name of uniqueNames.slice(0, 10)) {
+        // Full name (easy)
+        source.searchQueries.push(name);
+    }
+    for (const name of uniqueNames.slice(0, 10)) {
+        // Single token (medium)
+        const tokens = name.split(/\s+/).filter(t => t.length >= 3);
+        if (tokens.length > 0)
+            source.searchQueries.push(tokens[0]);
+    }
+    for (const name of uniqueNames.slice(0, 10)) {
+        // 3-letter prefix (hard)
+        const token = name.split(/\s+/).find(t => t.length >= 4);
+        if (token)
+            source.searchQueries.push(token.slice(0, 3));
+    }
+    for (const name of uniqueNames.slice(0, 5)) {
+        // Multi-token substring (hard)
+        const tokens = name.split(/\s+/).filter(t => t.length >= 3);
+        if (tokens.length >= 2)
+            source.searchQueries.push(tokens.slice(0, 2).join(' '));
+    }
+    // Non-existent search queries (edge case)
+    source.searchQueries.push('xyznonexistent', 'qqq999', 'zzznodata');
+    // Fallback: if API returned nothing, use seed queries
+    if (source.searchQueries.length < 5) {
+        source.searchQueries.push(...SEED_QUERIES);
+    }
+}
 async function benchStress(args) {
     const config = requireAuth();
     const durationSec = parseInt(parseFlag(args, '--duration') || '120');
     const maxVUs = parseInt(parseFlag(args, '--max-vus') || '500');
+    const filterSource = parseFlag(args, '--source');
+    const benchSources = discoverBenchSources(filterSource || undefined);
+    if (benchSources.length === 0) {
+        console.error('No sources found. Check sources/ directory.');
+        process.exit(1);
+    }
+    // Seed lookup IDs from API
+    console.log(`  Seeding queries from ${benchSources.length} sources...`);
+    await Promise.all(benchSources.map(s => seedBenchQueries(s, config.api_key)));
     const stages = [
         { name: 'warmup', vus: 10, duration: Math.floor(durationSec * 0.08) },
         { name: 'ramp', vus: Math.floor(maxVUs * 0.5), duration: Math.floor(durationSec * 0.17) },
@@ -789,16 +921,21 @@ async function benchStress(args) {
         { name: 'hold', vus: maxVUs, duration: Math.floor(durationSec * 0.25) },
         { name: 'cool', vus: 10, duration: Math.floor(durationSec * 0.08) },
     ];
-    const endpoints = [
-        ...BENCH_SAMPLES['pe/ruc'].map(s => ({ url: `${API_URL}/pe/sunat/padron/ruc/${s}`, type: 'ruc' })),
-        ...BENCH_SAMPLES['pe/search'].map(s => ({ url: `${API_URL}/pe/sunat/padron/search?q=${encodeURIComponent(s)}`, type: 'search' })),
-        ...BENCH_SAMPLES['pe/oece/tenders'].slice(0, 10).map(s => ({ url: `${API_URL}/pe/oece/tenders?q=${encodeURIComponent(s)}&limit=5`, type: 'tenders' })),
-        ...BENCH_SAMPLES['co/nit'].slice(0, 10).map(s => ({ url: `${API_URL}/co/rues/registry/nit/${s}`, type: 'co/nit' })),
-        ...BENCH_SAMPLES['co/search'].slice(0, 10).map(s => ({ url: `${API_URL}/co/rues/registry/search?q=${encodeURIComponent(s)}`, type: 'co/search' })),
-    ];
+    // Build endpoints dynamically from discovered sources
+    const endpoints = [];
+    for (const s of benchSources) {
+        if (s.lookupIds.length > 0) {
+            for (const id of s.lookupIds.slice(0, 10)) {
+                endpoints.push({ url: `${API_URL}${s.routePath}/${s.primaryId.name}/${id}`, type: `${s.name}/lookup` });
+            }
+        }
+        for (const q of s.searchQueries.slice(0, 10)) {
+            endpoints.push({ url: `${API_URL}${s.routePath}/search?q=${encodeURIComponent(q)}&limit=5`, type: `${s.name}/search` });
+        }
+    }
     const headers = { Authorization: `Bearer ${config.api_key}` };
     const results = [];
-    console.log(`\n  STRESS TEST — ${durationSec}s, max ${maxVUs} VUs, mixed endpoints\n`);
+    console.log(`\n  STRESS TEST — ${durationSec}s, max ${maxVUs} VUs, ${benchSources.map(s => s.name).join(' + ')}\n`);
     console.log(`  Stage       VUs    Duration`);
     for (const s of stages)
         console.log(`  ${s.name.padEnd(10)}  ${String(s.vus).padEnd(5)}  ${s.duration}s`);
@@ -886,6 +1023,7 @@ async function benchStress(args) {
     console.log(`\n${'═'.repeat(60)}`);
     console.log(`  STRESS TEST RESULTS`);
     console.log(`${'═'.repeat(60)}\n`);
+    console.log(`  Sources:      ${benchSources.map(s => s.name).join(', ')}`);
     console.log(`  Duration:     ${dur}s`);
     console.log(`  Max VUs:      ${maxVUs}`);
     console.log(`  Total reqs:   ${total.toLocaleString()}`);
@@ -918,10 +1056,10 @@ async function benchStress(args) {
         }
     console.log();
     console.log(`  Per Endpoint`);
-    console.log(`  ${'Type'.padEnd(15)} ${'Reqs'.padEnd(8)} ${'p50'.padEnd(8)} ${'p95'.padEnd(8)} p99`);
+    console.log(`  ${'Type'.padEnd(25)} ${'Reqs'.padEnd(8)} ${'p50'.padEnd(8)} ${'p95'.padEnd(8)} p99`);
     for (const [t, d] of Object.entries(allByType)) {
         const sl = d.latencies.sort((a, b) => a - b);
-        console.log(`  ${t.padEnd(15)} ${String(d.count).padEnd(8)} ${(pct(sl, 0.5) + 'ms').padEnd(8)} ${(pct(sl, 0.95) + 'ms').padEnd(8)} ${pct(sl, 0.99)}ms`);
+        console.log(`  ${t.padEnd(25)} ${String(d.count).padEnd(8)} ${(pct(sl, 0.5) + 'ms').padEnd(8)} ${(pct(sl, 0.95) + 'ms').padEnd(8)} ${pct(sl, 0.99)}ms`);
     }
     console.log();
     console.log(`  HTTP Status:  ${Object.entries(allStat).map(([s, c]) => `${s}: ${c}`).join('  ')}`);
@@ -996,44 +1134,48 @@ async function bench(args) {
     const count = countIdx !== -1 ? parseInt(args[countIdx + 1]) || 100 : 100;
     const concurrencyIdx = args.indexOf('--concurrency');
     const concurrency = concurrencyIdx !== -1 ? parseInt(args[concurrencyIdx + 1]) || 10 : 10;
-    const countryIdx = args.indexOf('--country');
-    const country = countryIdx !== -1 ? args[countryIdx + 1] : 'pe';
-    const typeIdx = args.indexOf('--type');
-    const type = typeIdx !== -1 ? args[typeIdx + 1] : (country === 'pe' ? 'ruc' : 'nit');
+    const filterSource = parseFlag(args, '--source');
+    const searchOnly = args.includes('--search-only');
+    const lookupOnly = args.includes('--lookup-only');
     const config = requireAuth();
-    const key = `${country}/${type}`;
-    const samples = BENCH_SAMPLES[key];
-    if (!samples) {
-        console.error(`Unknown combination: --country ${country} --type ${type}`);
-        console.error(`Supported: ${Object.keys(BENCH_SAMPLES).map(k => '--country ' + k.replace('/', ' --type ')).join(', ')}`);
+    const benchSources = discoverBenchSources(filterSource || undefined);
+    if (benchSources.length === 0) {
+        console.error('No sources found. Check sources/ directory or use --source <name>.');
         process.exit(1);
     }
-    const ROUTE_MAP = {
-        'pe/ruc': '/pe/sunat/padron/ruc',
-        'pe/search': '/pe/sunat/padron/search',
-        'pe/oece/tenders': '/pe/oece/tenders',
-        'co/nit': '/co/rues/registry/nit',
-        'co/search': '/co/rues/registry/search',
-    };
-    const getUrl = (sample) => {
-        const route = ROUTE_MAP[key];
-        if (type === 'search' || type === 'oece/tenders')
-            return `${API_URL}${route}?q=${encodeURIComponent(sample)}&limit=5`;
-        return `${API_URL}${route}/${sample}`;
-    };
-    const tasks = Array.from({ length: count }, (_, i) => samples[i % samples.length]);
+    // Seed queries + IDs from real API data
     if (!jsonFlag)
-        console.log(`\nBenchmarking /${key} — ${count} requests, ${concurrency} concurrent\n`);
+        console.log(`  Seeding queries from ${benchSources.length} sources...`);
+    await Promise.all(benchSources.map(s => seedBenchQueries(s, config.api_key)));
+    // Build URL list
+    const urls = [];
+    for (const s of benchSources) {
+        if (!searchOnly && s.lookupIds.length > 0) {
+            for (const id of s.lookupIds) {
+                urls.push({ url: `${API_URL}${s.routePath}/${s.primaryId.name}/${id}`, type: `${s.name}/lookup` });
+            }
+        }
+        if (!lookupOnly) {
+            for (const q of s.searchQueries) {
+                urls.push({ url: `${API_URL}${s.routePath}/search?q=${encodeURIComponent(q)}&limit=5`, type: `${s.name}/search` });
+            }
+        }
+    }
+    const sourceNames = benchSources.map(s => s.name).join(', ');
+    if (!jsonFlag)
+        console.log(`\n  Bench: ${sourceNames} — ${count} requests, ${concurrency} concurrent\n`);
     const latencies = [];
     const statusCounts = {};
+    const byType = {};
     let completed = 0;
     const startAll = Date.now();
+    const tasks = Array.from({ length: count }, (_, i) => urls[i % urls.length]);
     for (let i = 0; i < tasks.length; i += concurrency) {
         const batch = tasks.slice(i, i + concurrency);
-        await Promise.all(batch.map(async (sample) => {
+        await Promise.all(batch.map(async (task) => {
             const t0 = Date.now();
             try {
-                const res = await fetch(getUrl(sample), {
+                const res = await fetch(task.url, {
                     headers: { Authorization: `Bearer ${config.api_key}` },
                     signal: AbortSignal.timeout(15_000),
                 });
@@ -1044,6 +1186,10 @@ async function bench(args) {
                 latencies.push(Date.now() - t0);
                 statusCounts[0] = (statusCounts[0] || 0) + 1;
             }
+            if (!byType[task.type])
+                byType[task.type] = { count: 0, latencies: [] };
+            byType[task.type].count++;
+            byType[task.type].latencies.push(latencies[latencies.length - 1]);
             completed++;
             if (process.stdout.isTTY && !jsonFlag) {
                 const pct = Math.floor(completed / count * 30);
@@ -1060,11 +1206,14 @@ async function bench(args) {
     const rps = (count / (totalMs / 1000)).toFixed(1);
     if (jsonFlag) {
         console.log(JSON.stringify({
-            endpoint: key, count, concurrency,
-            total_ms: totalMs,
-            rps: parseFloat(rps),
-            status: statusCounts,
+            sources: benchSources.map(s => s.name), count, concurrency,
+            total_ms: totalMs, rps: parseFloat(rps), status: statusCounts,
             latency: { p50: p(0.5), p95: p(0.95), p99: p(0.99), max: latencies[latencies.length - 1] },
+            byType: Object.fromEntries(Object.entries(byType).map(([t, d]) => {
+                const sl = d.latencies.sort((a, b) => a - b);
+                const pp = (pct) => sl[Math.floor(sl.length * pct)] ?? 0;
+                return [t, { count: d.count, p50: pp(0.5), p95: pp(0.95), p99: pp(0.99) }];
+            })),
         }));
         return;
     }
@@ -1080,6 +1229,7 @@ async function bench(args) {
         rateLimit ? `429: ${rateLimit}` : '',
         errors ? `Errors: ${errors}` : '',
     ].filter(Boolean).join('   ');
+    console.log(`  Sources:  ${sourceNames}`);
     console.log(`  Total:    ${(totalMs / 1000).toFixed(1)}s   Req/sec: ${rps}`);
     console.log(`  Status:   ${statusLine}`);
     console.log();
@@ -1087,6 +1237,65 @@ async function bench(args) {
     console.log(`  p95:  ${p(0.95)}ms`);
     console.log(`  p99:  ${p(0.99)}ms`);
     console.log(`  max:  ${latencies[latencies.length - 1]}ms`);
+    if (Object.keys(byType).length > 1) {
+        console.log();
+        console.log(`  Per Endpoint`);
+        console.log(`  ${'Type'.padEnd(25)} ${'Reqs'.padEnd(8)} ${'p50'.padEnd(8)} ${'p95'.padEnd(8)} p99`);
+        for (const [t, d] of Object.entries(byType)) {
+            const sl = d.latencies.sort((a, b) => a - b);
+            const pp = (pct) => sl[Math.floor(sl.length * pct)] ?? 0;
+            console.log(`  ${t.padEnd(25)} ${String(d.count).padEnd(8)} ${(pp(0.5) + 'ms').padEnd(8)} ${(pp(0.95) + 'ms').padEnd(8)} ${pp(0.99)}ms`);
+        }
+    }
+}
+/** Run production bench: 500 concurrent against api.latinfo.dev, returns success rate */
+async function benchProduction(sourceName, apiKey, concurrency = 500) {
+    const benchSources = discoverBenchSources(sourceName);
+    if (benchSources.length === 0)
+        throw new Error(`Source ${sourceName} not found`);
+    const source = benchSources[0];
+    // Seed IDs
+    await seedBenchQueries(source, apiKey);
+    // Build mixed URL list (search + lookup)
+    const urls = [];
+    for (const q of source.searchQueries) {
+        urls.push(`${API_URL}${source.routePath}/search?q=${encodeURIComponent(q)}&limit=5`);
+    }
+    for (const id of source.lookupIds) {
+        urls.push(`${API_URL}${source.routePath}/${source.primaryId.name}/${id}`);
+    }
+    const total = concurrency;
+    const headers = { Authorization: `Bearer ${apiKey}` };
+    let idx = 0, success = 0, fails = 0;
+    const lats = [];
+    const t0 = Date.now();
+    async function worker() {
+        while (idx < total) {
+            const i = idx++;
+            const url = urls[i % urls.length];
+            const start = Date.now();
+            try {
+                const res = await fetch(url, { headers, signal: AbortSignal.timeout(15_000) });
+                lats.push(Date.now() - start);
+                if (res.status === 200 || res.status === 404)
+                    success++;
+                else
+                    fails++;
+            }
+            catch {
+                lats.push(Date.now() - start);
+                fails++;
+            }
+        }
+    }
+    await Promise.all(Array.from({ length: concurrency }, () => worker()));
+    lats.sort((a, b) => a - b);
+    const p = (pct) => lats[Math.floor(lats.length * pct)] ?? 0;
+    return {
+        success_rate: (success / total) * 100,
+        p50: p(0.5), p95: p(0.95), p99: p(0.99),
+        qps: Math.round(total / ((Date.now() - t0) / 1000)),
+    };
 }
 // --- Licitaciones ---
 function parseFlag(args, flag) {
@@ -2356,18 +2565,61 @@ async function pipePublish(args) {
     catch {
         console.log(`[pipe] Could not trigger workflow automatically.`);
     }
-    // 4. Restart search server
-    console.log(`[pipe] Restarting search server on Linux Mint...`);
+    // 4. Update search server SOURCES env + restart
+    console.log(`[pipe] Updating search server SOURCES on Linux Mint...`);
+    try {
+        // Read current SOURCES from systemd service
+        const currentSources = run(`ssh -o ConnectTimeout=10 ${RUNNER} "grep -oP 'SOURCES=\\K.*' /etc/systemd/system/latinfo-search.service 2>/dev/null || echo ''"`, {
+            encoding: 'utf-8', stdio: 'pipe',
+        }).trim().replace(/^"|"$/g, '');
+        const sourceList = currentSources ? currentSources.split(',').map(s => s.trim()) : [];
+        if (!sourceList.includes(sourceName)) {
+            sourceList.push(sourceName);
+            const newSources = sourceList.join(',');
+            console.log(`[pipe] Adding ${sourceName} to SOURCES: ${newSources}`);
+            run(`ssh ${RUNNER} "sudo sed -i 's|^Environment=.*SOURCES=.*|Environment=SOURCES=${newSources}|' /etc/systemd/system/latinfo-search.service && sudo systemctl daemon-reload"`, { stdio: 'pipe' });
+        }
+        else {
+            console.log(`[pipe] ${sourceName} already in SOURCES.`);
+        }
+        run(`ssh ${RUNNER} "sudo systemctl restart latinfo-search"`, { stdio: 'inherit' });
+        console.log(`[pipe] Search server restarted.`);
+    }
+    catch {
+        console.log(`[pipe] Could not update search server (not critical).`);
+    }
+    // 5. Production bench: 500 concurrent against api.latinfo.dev
+    console.log(`\n[pipe] Running production bench (500 concurrent)...`);
     try {
-        run(`ssh ${RUNNER} "sudo systemctl restart latinfo-search 2>/dev/null || echo 'No service yet'"`, { stdio: 'inherit' });
+        const config = loadConfig();
+        if (!config?.api_key)
+            throw new Error('No API key');
+        const bench = await benchProduction(sourceName, config.api_key, 500);
+        console.log(`\n  Production bench: ${bench.qps} q/s, ${bench.success_rate.toFixed(1)}% success`);
+        console.log(`  p50: ${bench.p50}ms  p95: ${bench.p95}ms  p99: ${bench.p99}ms`);
+        if (bench.success_rate < 99.9) {
+            console.error(`\n[pipe] PRODUCTION BENCH FAILED — ${bench.success_rate.toFixed(1)}% < 99.9%`);
+            console.error(`[pipe] Rolling back...`);
+            try {
+                run(`git revert HEAD --no-edit && git push`, { cwd: repo, stdio: 'pipe' });
+                run(`npx wrangler deploy`, { cwd: repo, stdio: 'pipe' });
+            }
+            catch { }
+            status.publish = { passed: false, timestamp: new Date().toISOString() };
+            savePipeStatus(status);
+            process.exit(1);
+        }
+        status.publish = { passed: true, timestamp: new Date().toISOString(), bench: { concurrent: 500, success_rate: bench.success_rate, p50: bench.p50, p95: bench.p95, p99: bench.p99 } };
     }
-    catch { }
+    catch (e) {
+        console.log(`[pipe] Skipping production bench (no API key or network error).`);
+        status.publish = { passed: true, timestamp: new Date().toISOString() };
+    }
+    savePipeStatus(status);
     console.log(`\n[pipe] Gate 4 PASSED ✓`);
     console.log(`[pipe] ${sourceName} is LIVE`);
     console.log(`  API: https://api.latinfo.dev/${sourceName.replace(/-/g, '/')}/`);
     console.log(`  CLI: latinfo ${sourceName.replace(/-/g, ' ')}`);
-    status.publish = { passed: true, timestamp: new Date().toISOString() };
-    savePipeStatus(status);
 }
 async function pipeStatus(args) {
     const [sourceName] = args;
@@ -2965,6 +3217,9 @@ else {
         case 'bench':
             bench(args).catch(e => { console.error(e); process.exit(1); });
             break;
+        case 'search-server':
+            searchServerStatus().catch(e => { console.error(e); process.exit(1); });
+            break;
         case 'pipe':
             pipe(args).catch(e => { console.error(e); process.exit(1); });
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "latinfo",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Tax registry & procurement API for Latin America. Query RUC, DNI, NIT, licitaciones from Peru & Colombia. Offline MPHF search, full OCDS data, updated daily.",
   "homepage": "https://latinfo.dev",
   "repository": {