viberadar 0.3.208 → 0.3.210

package/dist/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAO7B,OAAO,EAAE,UAAU,EAA4H,MAAM,YAAY,CAAC;AAOlK,UAAU,aAAa;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;CACrB;AA0vED,wBAAgB,WAAW,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA+gG1G"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAO7B,OAAO,EAAE,UAAU,EAA4H,MAAM,YAAY,CAAC;AAOlK,UAAU,aAAa;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;CACrB;AA0vED,wBAAgB,WAAW,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAuzG1G"}

package/dist/server/index.js

@@ -2095,7 +2095,7 @@ function startServer({ data: initialData, port, projectRoot }) {
         let loadRunning = false;
         let loadProc = null;
         let loadState = {
-            status: 'idle', startTime: 0, buckets: [], totalRequests: 0,
+            runId: null, status: 'idle', startTime: 0, buckets: [], totalRequests: 0,
             totalErrors: 0, logs: [], script: '', config: null, summary: null,
         };
         let probeRunning = false;
@@ -2184,36 +2184,222 @@ function startServer({ data: initialData, port, projectRoot }) {
                 probeRunning = false;
             }
         }
-        function parseK6Dur(s) {
-            let m;
-            if ((m = s.match(/^([\d.]+)µs$/)))
-                return parseFloat(m[1]) / 1000;
-            if ((m = s.match(/^([\d.]+)ms$/)))
-                return parseFloat(m[1]);
-            if ((m = s.match(/^([\d.]+)s$/)))
-                return parseFloat(m[1]) * 1000;
-            if ((m = s.match(/^(\d+)m([\d.]+)s$/)))
-                return parseInt(m[1]) * 60000 + parseFloat(m[2]) * 1000;
-            return 0;
+        const loadRunsDir = path.join(projectRoot, '.viberadar', 'load-runs');
+        const MAX_LOAD_RUN_HISTORY = 50;
+        function sanitizeLoadScriptName(name) {
+            const raw = typeof name === 'string' && name.trim() ? name.trim() : 'Без названия';
+            return raw.replace(/[^a-zA-Zа-яА-ЯёЁ0-9_\- .]/g, '_').slice(0, 80);
         }
-        function parseK6Summary(text) {
-            const s = {};
-            const dur = text.match(/http_req_duration[^:]*:\s+avg=([\w.µ]+)[^\n]*p\(90\)=([\w.µ]+)[^\n]*p\(95\)=([\w.µ]+)/);
-            if (dur) {
-                s.avgDuration = parseK6Dur(dur[1]);
-                s.p90Duration = parseK6Dur(dur[2]);
-                s.p95Duration = parseK6Dur(dur[3]);
-            }
-            const reqs = text.match(/\bhttp_reqs[^:]*:\s+(\d+)\s+([\d.]+)\/s/);
-            if (reqs) {
-                s.totalRequests = parseInt(reqs[1]);
-                s.rps = parseFloat(reqs[2]);
-            }
-            const fail = text.match(/http_req_failed[^:]*:\s+([\d.]+)%/);
-            if (fail)
-                s.errorPct = parseFloat(fail[1]);
-            return s;
+        function normalizeLoadDuration(value) {
+            const raw = typeof value === 'string' && value.trim() ? value.trim() : '30s';
+            if (!/^(\d+(ms|s|m|h))+$/.test(raw))
+                return '30s';
+            return raw;
         }
+        function normalizeLoadVus(value) {
+            const n = typeof value === 'number' ? value : parseInt(String(value || '10'), 10);
+            if (!Number.isFinite(n) || n < 1)
+                return 10;
+            return Math.min(Math.floor(n), 10000);
+        }
+        function sanitizeLoadEnvVars(value) {
+            if (!value || typeof value !== 'object')
+                return {};
+            const out = {};
+            for (const [key, val] of Object.entries(value)) {
+                const envKey = key.trim();
+                if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(envKey))
+                    continue;
+                if (val == null)
+                    continue;
+                out[envKey] = String(val);
+            }
+            return out;
+        }
+        function redactLoadEnvVars(envVars) {
+            const out = {};
+            for (const key of Object.keys(envVars)) {
+                out[key] = /token|secret|password|key/i.test(key) ? '***' : envVars[key];
+            }
+            return out;
+        }
+        function resolveLoadLocalPath(value) {
+            if (typeof value !== 'string' || !value.trim())
+                return undefined;
+            const raw = value.trim();
+            return path.resolve(path.isAbsolute(raw) ? raw : path.join(projectRoot, raw));
+        }
+        function copyLoadDataFiles(sourcePath, workDir) {
+            if (!sourcePath || !fs.existsSync(sourcePath))
+                return 0;
+            const stat = fs.statSync(sourcePath);
+            let copied = 0;
+            const copyOne = (src, dst) => {
+                const st = fs.statSync(src);
+                if (st.isDirectory()) {
+                    fs.mkdirSync(dst, { recursive: true });
+                    for (const name of fs.readdirSync(src)) {
+                        if (name === '.git' || name === 'node_modules' || name === 'dist')
+                            continue;
+                        copyOne(path.join(src, name), path.join(dst, name));
+                    }
+                    return;
+                }
+                if (!st.isFile())
+                    return;
+                fs.mkdirSync(path.dirname(dst), { recursive: true });
+                fs.copyFileSync(src, dst);
+                copied++;
+            };
+            if (stat.isDirectory()) {
+                for (const name of fs.readdirSync(sourcePath)) {
+                    if (name === '.git' || name === 'node_modules' || name === 'dist')
+                        continue;
+                    copyOne(path.join(sourcePath, name), path.join(workDir, name));
+                }
+            }
+            else if (stat.isFile()) {
+                copyOne(sourcePath, path.join(workDir, path.basename(sourcePath)));
+            }
+            return copied;
+        }
+        function buildLoadConfig(cfg, paths) {
+            const envVars = sanitizeLoadEnvVars(cfg.envVars);
+            const baseUrl = typeof cfg.baseUrl === 'string' && cfg.baseUrl.trim() ? cfg.baseUrl.trim() : 'http://localhost:5000';
+            const dataDir = resolveLoadLocalPath(cfg.dataDir);
+            const resultDir = resolveLoadLocalPath(cfg.resultDir);
+            envVars.BASE_URL = baseUrl;
+            const config = {
+                vus: normalizeLoadVus(cfg.vus),
+                duration: normalizeLoadDuration(cfg.duration),
+                baseUrl,
+                scriptName: sanitizeLoadScriptName(cfg.scriptName),
+                dataDir,
+                resultDir,
+                runDir: paths?.runDir,
+                workDir: paths?.workDir,
+                resultPath: paths?.resultPath,
+                dataFilesCopied: paths?.dataFilesCopied,
+                envVars: redactLoadEnvVars(envVars),
+            };
+            return { config, envVars, dataDir, resultDir };
+        }
+        function flattenK6Checks(group) {
+            let passes = 0;
+            let fails = 0;
+            for (const check of group?.checks || []) {
+                passes += Number(check.passes || 0);
+                fails += Number(check.fails || 0);
+            }
+            for (const child of group?.groups || []) {
+                const nested = flattenK6Checks(child);
+                passes += nested.passes;
+                fails += nested.fails;
+            }
+            return { passes, fails };
+        }
+        function normalizeK6Summary(raw, exitCode) {
+            const metrics = raw?.metrics || {};
+            const duration = metrics.http_req_duration?.values || {};
+            const reqs = metrics.http_reqs?.values || {};
+            const failed = metrics.http_req_failed?.values || {};
+            const checks = flattenK6Checks(raw?.root_group);
+            let thresholdsPassed = 0;
+            let thresholdsFailed = 0;
+            for (const metric of Object.values(metrics)) {
+                for (const threshold of Object.values(metric?.thresholds || {})) {
+                    if (threshold?.ok === false)
+                        thresholdsFailed++;
+                    else if (threshold?.ok === true)
+                        thresholdsPassed++;
+                }
+            }
+            return {
+                totalRequests: typeof reqs.count === 'number' ? reqs.count : undefined,
+                rps: typeof reqs.rate === 'number' ? reqs.rate : undefined,
+                avgDuration: typeof duration.avg === 'number' ? duration.avg : undefined,
+                p90Duration: typeof duration['p(90)'] === 'number' ? duration['p(90)'] : undefined,
+                p95Duration: typeof duration['p(95)'] === 'number' ? duration['p(95)'] : undefined,
+                p99Duration: typeof duration['p(99)'] === 'number' ? duration['p(99)'] : undefined,
+                errorPct: typeof failed.rate === 'number' ? failed.rate * 100 : undefined,
+                testRunDurationMs: typeof raw?.state?.testRunDurationMs === 'number' ? raw.state.testRunDurationMs : undefined,
+                checksPassed: checks.passes,
+                checksFailed: checks.fails,
+                thresholdsPassed,
+                thresholdsFailed,
+                exitCode,
+            };
+        }
+        function readK6Summary(summaryPath, exitCode) {
+            try {
+                if (!fs.existsSync(summaryPath))
+                    return { exitCode };
+                return normalizeK6Summary(JSON.parse(fs.readFileSync(summaryPath, 'utf-8')), exitCode);
+            }
+            catch {
+                return { exitCode };
+            }
+        }
+        function readLoadRunIndex() {
+            try {
+                const p = path.join(loadRunsDir, 'index.json');
+                const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+                return Array.isArray(parsed) ? parsed : [];
+            }
+            catch {
+                return [];
+            }
+        }
+        function writeLoadRunIndex(items) {
+            fs.mkdirSync(loadRunsDir, { recursive: true });
+            fs.writeFileSync(path.join(loadRunsDir, 'index.json'), JSON.stringify(items, null, 2), 'utf-8');
+        }
+        function saveLoadRun() {
+            if (!loadState.runId)
+                return;
+            fs.mkdirSync(loadRunsDir, { recursive: true });
+            const record = {
+                ...loadState,
+                scriptName: loadState.config?.scriptName,
+                createdAt: new Date(loadState.startTime || Date.now()).toISOString(),
+            };
+            fs.writeFileSync(path.join(loadRunsDir, `${loadState.runId}.json`), JSON.stringify(record, null, 2), 'utf-8');
+            const index = readLoadRunIndex().filter(i => i.runId !== loadState.runId);
+            index.unshift({
+                runId: loadState.runId,
+                scriptName: loadState.config?.scriptName || 'Без названия',
+                createdAt: record.createdAt,
+                status: loadState.status,
+                startTime: loadState.startTime,
+                endTime: loadState.endTime,
+                config: loadState.config,
+                summary: loadState.summary,
+            });
+            const compact = index.slice(0, MAX_LOAD_RUN_HISTORY);
+            writeLoadRunIndex(compact);
+            for (const old of index.slice(MAX_LOAD_RUN_HISTORY)) {
+                try {
+                    fs.unlinkSync(path.join(loadRunsDir, `${old.runId}.json`));
+                }
+                catch { }
+                try {
+                    fs.rmSync(path.join(loadRunsDir, old.runId), { recursive: true, force: true });
+                }
+                catch { }
+            }
+        }
+        function loadLastRunIntoState() {
+            const latest = readLoadRunIndex()[0];
+            if (!latest)
+                return;
+            try {
+                const record = JSON.parse(fs.readFileSync(path.join(loadRunsDir, `${latest.runId}.json`), 'utf-8'));
+                if (record && typeof record === 'object')
+                    loadState = record;
+            }
+            catch { }
+        }
+        loadLastRunIntoState();
         // ── SSE clients ────────────────────────────────────────────────────────────
         const sseClients = new Set();
         function broadcast(event, payload = {}) {
@@ -4911,7 +5097,7 @@ a{color:var(--blue)}
                 req.on('data', (d) => { body += d; });
                 req.on('end', () => {
                     try {
-                        const { name, script } = JSON.parse(body);
+                        const { name, script, vus, duration, baseUrl, dataDir, resultDir } = JSON.parse(body);
                         if (!name || !script) {
                             res.writeHead(400, jsonH);
                             res.end(JSON.stringify({ error: 'name and script required' }));
@@ -4921,7 +5107,17 @@ a{color:var(--blue)}
                         const safeName = name.replace(/[^a-zA-Zа-яА-ЯёЁ0-9_\- ]/g, '_').slice(0, 80);
                         const date = new Date().toISOString().slice(0, 16).replace('T', ' ');
                         const fileName = `${Date.now()}-${safeName.replace(/\s+/g, '_')}.json`;
-                        const entry = { name: safeName, date, script, fileName };
+                        const entry = {
+                            name: safeName,
+                            date,
+                            script,
+                            fileName,
+                            vus: normalizeLoadVus(vus),
+                            duration: normalizeLoadDuration(duration),
+                            baseUrl: typeof baseUrl === 'string' && baseUrl.trim() ? baseUrl.trim() : 'http://localhost:5000',
+                            dataDir: resolveLoadLocalPath(dataDir),
+                            resultDir: resolveLoadLocalPath(resultDir),
+                        };
                         // overwrite if same name exists
                         const existing = fs.readdirSync(scriptsDir).find(f => {
                             try {
@@ -5011,6 +5207,31 @@ a{color:var(--blue)}
                 res.end(JSON.stringify(loadState));
                 return;
             }
+            if (url === '/api/load/runs' && req.method === 'GET') {
+                res.writeHead(200, jsonH);
+                res.end(JSON.stringify(readLoadRunIndex()));
+                return;
+            }
+            const loadRunMatch = url.match(/^\/api\/load\/runs\/([^/]+)$/);
+            if (loadRunMatch && req.method === 'GET') {
+                try {
+                    const runId = decodeURIComponent(loadRunMatch[1]);
+                    if (!/^[a-zA-Z0-9_-]+$/.test(runId)) {
+                        res.writeHead(400, jsonH);
+                        res.end(JSON.stringify({ error: 'Bad run id' }));
+                        return;
+                    }
+                    const runPath = path.join(loadRunsDir, `${runId}.json`);
+                    const record = JSON.parse(fs.readFileSync(runPath, 'utf-8'));
+                    res.writeHead(200, jsonH);
+                    res.end(JSON.stringify(record));
+                }
+                catch {
+                    res.writeHead(404, jsonH);
+                    res.end(JSON.stringify({ error: 'Run not found' }));
+                }
+                return;
+            }
             if (url === '/api/load/stop' && req.method === 'POST') {
                 if (loadProc) {
                     try {
@@ -5024,7 +5245,7 @@ a{color:var(--blue)}
                     loadState.status = 'stopped';
                     loadState.endTime = Date.now();
                 }
-                broadcast('load-done', { status: loadState.status, summary: loadState.summary });
+                broadcast('load-done', { runId: loadState.runId, status: loadState.status, summary: loadState.summary });
                 res.writeHead(200, jsonH);
                 res.end(JSON.stringify({ ok: true }));
                 return;
@@ -5053,9 +5274,20 @@ a{color:var(--blue)}
                         res.end(JSON.stringify({ error: 'No script provided' }));
                         return;
                     }
-                    const scriptPath = path.join(os.tmpdir(), `viberadar-k6-${Date.now()}.js`);
-                    const jsonOutPath = path.join(os.tmpdir(), `viberadar-k6-out-${Date.now()}.ndjson`);
+                    const runId = `load-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                    const runDir = path.join(loadRunsDir, runId);
+                    const workDir = path.join(runDir, 'work');
+                    const defaultResultDir = path.join(runDir, 'results');
+                    const initial = buildLoadConfig(cfg);
+                    const resultPath = initial.resultDir ? path.join(initial.resultDir, runId) : defaultResultDir;
+                    const scriptPath = path.join(workDir, 'script.js');
+                    const jsonOutPath = path.join(resultPath, 'metrics.ndjson');
+                    const summaryPath = path.join(resultPath, 'summary.json');
+                    let dataFilesCopied = 0;
                     try {
+                        fs.mkdirSync(workDir, { recursive: true });
+                        fs.mkdirSync(resultPath, { recursive: true });
+                        dataFilesCopied = copyLoadDataFiles(initial.dataDir, workDir);
                         fs.writeFileSync(scriptPath, script, 'utf-8');
                     }
                     catch (e) {
@@ -5063,25 +5295,36 @@ a{color:var(--blue)}
                         res.end(JSON.stringify({ error: e.message }));
                         return;
                     }
+                    const { config: loadConfig, envVars } = buildLoadConfig(cfg, {
+                        runDir,
+                        workDir,
+                        resultPath,
+                        dataFilesCopied,
+                    });
                     loadRunning = true;
                     loadState = {
-                        status: 'running', startTime: Date.now(), buckets: [], totalRequests: 0,
-                        totalErrors: 0, logs: [], script, config: cfg, summary: null,
+                        runId, status: 'running', startTime: Date.now(), buckets: [], totalRequests: 0,
+                        totalErrors: 0, logs: [], script, config: loadConfig, summary: null,
                     };
-                    broadcast('load-started', { config: cfg });
+                    broadcast('load-started', { runId, config: loadConfig });
                     res.writeHead(200, jsonH);
-                    res.end(JSON.stringify({ ok: true }));
-                    // Build --env flags from cfg.envVars (e.g. { TOKEN: 'abc', BASE_URL: '...' })
-                    const envVars = (typeof cfg.envVars === 'object' && cfg.envVars !== null)
-                        ? cfg.envVars
-                        : {};
+                    res.end(JSON.stringify({ ok: true, runId }));
                     const envFlags = [];
                     for (const [k, v] of Object.entries(envVars)) {
                         if (k && v !== undefined && v !== '')
                             envFlags.push('--env', `${k}=${v}`);
                     }
-                    loadProc = (0, child_process_1.spawn)('k6', ['run', ...envFlags, '--out', `json=${jsonOutPath}`, scriptPath], {
-                        cwd: projectRoot, env: { ...process.env }, shell: WIN, stdio: 'pipe',
+                    const args = [
+                        'run',
+                        '--vus', String(loadConfig.vus),
+                        '--duration', loadConfig.duration,
+                        ...envFlags,
+                        '--summary-export', summaryPath,
+                        '--out', `json=${jsonOutPath}`,
+                        scriptPath,
+                    ];
+                    loadProc = (0, child_process_1.spawn)('k6', args, {
+                        cwd: workDir, env: { ...process.env }, shell: WIN, stdio: 'pipe',
                     });
                     const addLog = (line) => {
                         loadState.logs.push(line);
@@ -5156,7 +5399,7 @@ a{color:var(--blue)}
                             }
                             if (changed) {
                                 const slice = loadState.buckets.slice(-30);
-                                broadcast('load-progress', { buckets: slice, total: loadState.totalRequests, errors: loadState.totalErrors });
+                                broadcast('load-progress', { runId: loadState.runId, buckets: slice, total: loadState.totalRequests, errors: loadState.totalErrors });
                             }
                         }
                         catch { }
@@ -5166,17 +5409,23 @@ a{color:var(--blue)}
                         loadRunning = false;
                         loadProc = null;
                         if (loadState.status === 'running') {
-                            loadState.status = (code === 0 || code === null) ? 'done' : 'done';
+                            loadState.status = code === 0 ? 'done' : 'error';
                         }
                         loadState.endTime = Date.now();
-                        loadState.summary = parseK6Summary(loadState.logs.join('\n'));
-                        broadcast('load-done', { status: loadState.status, summary: loadState.summary });
+                        loadState.summary = readK6Summary(summaryPath, code);
+                        if (loadState.summary?.totalRequests != null)
+                            loadState.totalRequests = loadState.summary.totalRequests;
+                        if (loadState.summary?.errorPct != null && loadState.summary.totalRequests != null) {
+                            loadState.totalErrors = Math.round(loadState.summary.totalRequests * (loadState.summary.errorPct / 100));
+                        }
+                        saveLoadRun();
+                        broadcast('load-done', { runId: loadState.runId, status: loadState.status, summary: loadState.summary });
                         try {
-                            fs.unlinkSync(scriptPath);
+                            fs.writeFileSync(path.join(resultPath, 'k6.log'), loadState.logs.join('\n'), 'utf-8');
                         }
                         catch { }
                         try {
-                            fs.unlinkSync(jsonOutPath);
+                            fs.writeFileSync(path.join(resultPath, 'config.json'), JSON.stringify(loadState.config, null, 2), 'utf-8');
                         }
                         catch { }
                     });
@@ -5187,9 +5436,15 @@ a{color:var(--blue)}
                         loadState.status = 'error';
                         loadState.endTime = Date.now();
                         addLog(`❌ k6 не запустился: ${err.message}`);
-                        broadcast('load-done', { status: 'error', summary: null });
+                        loadState.summary = { exitCode: null };
+                        saveLoadRun();
+                        broadcast('load-done', { runId: loadState.runId, status: 'error', summary: loadState.summary });
+                        try {
+                            fs.writeFileSync(path.join(resultPath, 'k6.log'), loadState.logs.join('\n'), 'utf-8');
+                        }
+                        catch { }
                         try {
-                            fs.unlinkSync(scriptPath);
+                            fs.writeFileSync(path.join(resultPath, 'config.json'), JSON.stringify(loadState.config, null, 2), 'utf-8');
                         }
                         catch { }
                     });