9router-manager 0.0.1

package/src/scan.js

@@ -0,0 +1,293 @@
+// src/scan.js
+// API + concurrent scan logic for 9Router Manager.
+//
+// Functions:
+//   - login():                 POST /api/auth/login, populate cookie store
+//   - getModels():             GET /v1/models, return array of model IDs
+//   - testSingleModel():       test 1 model with retry/backoff, return result tuple
+//   - testModelConcurrent():   fan-out with progress bar (cli-progress)
+//   - buildAuditData():        assemble the audit JSON shape
+//   - writeAudit():            async file write
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { SingleBar, Presets } from 'cli-progress';
+import { getAvailableProviders } from './combo.js';
+import { _resolveDbPath, _getDefaultAuditPath } from './env.js';
+
+const BASE_URL = process.env.NINEROUTER_BASE_URL || 'http://localhost:20128';
+const TIMEOUT_MS = (parseInt(process.env.NINEROUTER_TIMEOUT, 10) || 8) * 1000;
+const SLEEP_BETWEEN_TESTS_S = parseFloat(process.env.NINEROUTER_SLEEP) || 0.05;
+const MAX_RETRIES = parseInt(process.env.NINEROUTER_RETRY_429_MAX, 10) || 2;
+const RETRY_DELAY_S = parseFloat(process.env.NINEROUTER_RETRY_429_DELAY) || 3.0;
+const TEST_PROMPT = process.env.NINEROUTER_PROMPT || '1+1=?';
+const MAX_WORKERS = parseInt(process.env.NINEROUTER_MAX_WORKERS, 10) || 1;
+
+// Simple in-memory cookie store (single-session scan)
+const _cookies = new Map();
+function _setCookieFromResponse(res) {
+  // Node fetch has getSetCookie() in 18.14+ / 20+
+  const setCookies = typeof res.headers.getSetCookie === 'function'
+    ? res.headers.getSetCookie()
+    : (res.headers.get('set-cookie') ? [res.headers.get('set-cookie')] : []);
+  for (const sc of setCookies) {
+    const [pair] = sc.split(';');
+    const eq = pair.indexOf('=');
+    if (eq < 0) continue;
+    const name = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1).trim();
+    if (name) _cookies.set(name, value);
+  }
+}
+function _cookieHeader() {
+  if (_cookies.size === 0) return '';
+  return Array.from(_cookies.entries()).map(([k, v]) => `${k}=${v}`).join('; ');
+}
+
+// Resolved password state — set by cli.js (after interactive prompt or --password flag)
+// via setResolvedPassword(). Falls back to the env var so external callers (e.g.
+// bin/9router-manager.js invoked directly) keep working without code changes.
+let _resolvedPassword = null;
+
+export function setResolvedPassword(pwd) {
+  _resolvedPassword = pwd;
+}
+
+function _requirePassword() {
+  if (_resolvedPassword) return _resolvedPassword;
+  const envPwd = process.env.NINEROUTER_PASSWORD;
+  if (envPwd && envPwd !== '***ISI_PASSWORD_DISINI***') return envPwd;
+  console.error('[scan] NINEROUTER_PASSWORD tidak diset atau masih placeholder.');
+  throw new Error('NINEROUTER_PASSWORD required');
+}
+
+// ---- public API ----
+
+export async function login() {
+  const pwd = _requirePassword();
+  const res = await fetch(`${BASE_URL}/api/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ password: pwd }),
+    signal: AbortSignal.timeout(TIMEOUT_MS),
+  });
+  _setCookieFromResponse(res);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Login gagal: ${res.status} ${res.statusText}: ${text.slice(0, 200)}`);
+  }
+  return true;
+}
+
+export async function getModels() {
+  const res = await fetch(`${BASE_URL}/v1/models`, {
+    headers: { Cookie: _cookieHeader() },
+    signal: AbortSignal.timeout(TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    throw new Error(`GET /v1/models failed: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  // /v1/models returns { data: [{ id, ... }] } (OpenAI-compatible)
+  if (Array.isArray(data?.data)) {
+    return data.data.map((m) => m.id).filter(Boolean);
+  }
+  if (Array.isArray(data)) {
+    return data.map((m) => (typeof m === 'string' ? m : m.id)).filter(Boolean);
+  }
+  return [];
+}
+
+const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+function _generateVerifyToken(length = 8) {
+  let s = '';
+  for (let i = 0; i < length; i++) s += CHARS[Math.floor(Math.random() * CHARS.length)];
+  return s;
+}
+
+// Module-level verify context. When set by setVerifyContext(), testSingleModel
+// uses this exact token+prompt for ALL models in the run — so the audit can
+// record verify_token/verify_prompt matching the actual prompt sent.
+// Falls back to per-call random if unset.
+let _currentToken = null;
+let _currentPrompt = null;
+
+export function setVerifyContext(token, prompt) {
+  _currentToken = token;
+  _currentPrompt = prompt;
+}
+
+export function clearVerifyContext() {
+  _currentToken = null;
+  _currentPrompt = null;
+}
+
+// testSingleModel returns: { model, ok, detail, actual_model, elapsed_ms, elapsed_seconds }
+export async function testSingleModel(model, opts = {}) {
+  const maxRetries = opts.maxRetries ?? MAX_RETRIES;
+  const retryDelayS = opts.retryDelayS ?? RETRY_DELAY_S;
+  // Honor explicit opts > module context > auto-generate fallback
+  const verifyToken = opts.verifyToken ?? _currentToken ?? _generateVerifyToken(8);
+  const prompt = opts.prompt ?? _currentPrompt ?? `${TEST_PROMPT} (echo: ${verifyToken})`;
+
+  const start = Date.now();
+  let lastError = null;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Cookie: _cookieHeader(),
+        },
+        body: JSON.stringify({
+          model,
+          messages: [{ role: 'user', content: prompt }],
+          stream: false,
+        }),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+      });
+
+      if (res.status === 429 && attempt < maxRetries) {
+        await new Promise((r) => setTimeout(r, retryDelayS * 1000));
+        continue;
+      }
+
+      const elapsed = (Date.now() - start) / 1000;
+      const elapsedMs = (Date.now() - start);
+
+      if (!res.ok) {
+        const text = await res.text();
+        return {
+          model, ok: false,
+          detail: `HTTP ${res.status}: ${text.slice(0, 200)}`,
+          actual_model: null, elapsed_ms: elapsedMs, elapsed_seconds: elapsed,
+        };
+      }
+
+      const data = await res.json();
+      const actualModel = data?.model || model;
+      const content = data?.choices?.[0]?.message?.content || '';
+      const ok = content.includes(verifyToken);
+      return {
+        model, ok,
+        detail: ok ? 'token echoed' : `token missing: ${content.slice(0, 100)}`,
+        actual_model: actualModel, elapsed_ms: elapsedMs, elapsed_seconds: elapsed,
+      };
+    } catch (e) {
+      lastError = e;
+      if (attempt < maxRetries) {
+        await new Promise((r) => setTimeout(r, retryDelayS * 1000));
+        continue;
+      }
+    }
+  }
+
+  const elapsed = (Date.now() - start) / 1000;
+  return {
+    model, ok: false,
+    detail: lastError?.message || 'unknown error',
+    actual_model: null, elapsed_ms: Date.now() - start, elapsed_seconds: elapsed,
+  };
+}
+
+// testModelConcurrent: fan-out with workers, progress bar.
+// Sleep between tests is intentionally skipped here — concurrent tests share the
+// same network I/O budget and rate-limiting is handled via 429 retries instead.
+export async function testModelConcurrent(models, opts = {}) {
+  const maxWorkers = opts.maxWorkers ?? MAX_WORKERS;
+  const onProgress = opts.onProgress || (() => {});
+
+  const results = new Array(models.length);
+  let cursor = 0;
+  let completed = 0;
+  const total = models.length;
+
+  async function worker() {
+    while (true) {
+      const idx = cursor++;
+      if (idx >= models.length) return;
+      const model = models[idx];
+      const r = await testSingleModel(model);
+      results[idx] = r;
+      completed++;
+      onProgress({ completed, total, current: model, result: r });
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(maxWorkers, models.length || 1) }, () => worker());
+  await Promise.all(workers);
+
+  return results;
+}
+
+// Convenience: run with cli-progress bar
+export async function testModelConcurrentWithBar(models, opts = {}) {
+  const bar = new SingleBar(
+    { format: 'Testing |{bar}| {percentage}% | {value}/{total} | {model}', hideCursor: true },
+    Presets.shades_classic
+  );
+  bar.start(models.length, 0, { model: '...' });
+  const results = await testModelConcurrent(models, {
+    ...opts,
+    onProgress: ({ completed, total, current }) => {
+      bar.update(completed, { model: current });
+    },
+  });
+  bar.stop();
+  return results;
+}
+
+// ============================================================
+// AUDIT
+// ============================================================
+const AUDIT_PATH = process.env.NINEROUTER_AUDIT_PATH
+  ? _resolveDbPath(process.env.NINEROUTER_AUDIT_PATH)
+  : _getDefaultAuditPath();
+
+export async function writeAudit(auditData) {
+  // Ensure parent dir exists (mkdirSync recursive)
+  await fs.mkdir(path.dirname(AUDIT_PATH), { recursive: true });
+  await fs.writeFile(AUDIT_PATH, JSON.stringify(auditData, null, 2), 'utf-8');
+  console.error(`[scan] audit written: ${AUDIT_PATH}`);
+}
+
+// buildAuditData assembles the audit JSON. Schema is pinned by tests/audit-shape.test.js:
+//   - top-level fields (see audit-shape.test.js REQUIRED_TOP_LEVEL)
+//   - counts coerced to strings
+//   - actual_model propagated for every result (including failed/skipped)
+export function buildAuditData({
+  startedAt, finishedAt, durationSeconds,
+  verifyToken, verifyPrompt,
+  models, candidates, skipped,
+  okCount, failedCount,
+  oldModels, newModels,
+  results,
+}) {
+  const added = newModels.filter((m) => !oldModels.includes(m));
+  const removed = oldModels.filter((m) => !newModels.includes(m));
+  return {
+    started_at: startedAt,
+    finished_at: finishedAt,
+    duration_seconds: parseFloat(durationSeconds.toFixed(2)),
+    total_wall_seconds: parseFloat(durationSeconds.toFixed(2)),
+    verify_token: verifyToken,
+    verify_prompt: verifyPrompt,
+    discovered_count: String(models.length),
+    candidate_count: String(candidates.length),
+    skipped_count: String(skipped),
+    ok_count: String(okCount),
+    failed_count: String(failedCount),
+    old_combo_count: String(oldModels.length),
+    new_combo_count: String(newModels.length),
+    added,
+    removed,
+    results: results.map((r) => ({
+      model: r.model,
+      ok: !!r.ok,
+      detail: r.detail || '',
+      elapsed_ms: r.elapsed_ms || 0,
+      actual_model: r.actual_model ?? r.model ?? null,
+    })),
+  };
+}