pool-anything 0.1.0

package/dist/cli/repl.js

@@ -0,0 +1,470 @@
+/**
+ * Interactive REPL: readline loop + command handlers over the pool SQLite DB.
+ * Reuses pool/rotation/router helpers — no duplicated quota or rotation logic.
+ */
+import readline from "node:readline";
+import { sdb, PROVIDERS, mask, poolSummary, isMultiFieldProvider, normalizeCredentials } from "../pool/index.js";
+import { nextKey, recordUsage } from "../pool/rotation.js";
+import { MAX_KEYS_PER_POOL, MAX_API_KEY_CHARS } from "../router/api.js";
+import { HOST, PORT } from "../config/env.js";
+import { parse, suggest } from "./nl.js";
+import { banner, poolsBox, usageBlock, helpBox, maskTip, fmtFull } from "./ui.js";
+function allPools() {
+    return sdb.prepare("SELECT id, provider, name FROM pools ORDER BY id").all();
+}
+/** Resolve free-text ref: numeric id, provider id, or name substring. */
+export function resolvePool(ref) {
+    const pools = allPools();
+    if (pools.length === 0)
+        return null;
+    const t = ref.trim().toLowerCase();
+    if (!t)
+        return pools[0];
+    if (/^\d+$/.test(t)) {
+        const hit = pools.find((p) => p.id === Number(t));
+        if (hit)
+            return hit;
+    }
+    const byProvider = pools.filter((p) => p.provider.toLowerCase() === t);
+    if (byProvider.length > 0)
+        return byProvider[0];
+    const byName = pools.filter((p) => p.name.toLowerCase().includes(t));
+    if (byName.length > 0)
+        return byName[0];
+    const byProviderSub = pools.filter((p) => p.provider.toLowerCase().includes(t));
+    if (byProviderSub.length > 0)
+        return byProviderSub[0];
+    return null;
+}
+function needPool(ref) {
+    const p = resolvePool(ref);
+    if (!p) {
+        console.log(ref.trim() ? `No pool matches "${ref.trim()}". Try 'list pools'.` : "No pools yet — try: create pool <name> for <provider>.");
+    }
+    return p;
+}
+function cmdListPools() {
+    const rows = sdb.prepare("SELECT id, provider, name FROM pools ORDER BY id").all().map((p) => {
+        const s = poolSummary(p.id);
+        const keyCount = sdb.prepare("SELECT COUNT(*) AS n FROM pool_keys WHERE pool_id = ?").get(p.id).n;
+        return {
+            id: p.id, name: p.name, provider: p.provider, keys: keyCount,
+            used: s?.usedInWindow ?? 0, quota: s?.quota ?? null, active: keyCount > 0,
+        };
+    });
+    console.log(poolsBox(rows));
+}
+function cmdListProviders() {
+    for (const p of PROVIDERS)
+        console.log(`- ${p.id} — ${p.name} (${p.quota || "no quota"})`);
+}
+function cmdListKeys(ref) {
+    const pool = needPool(ref);
+    if (!pool)
+        return;
+    const rows = sdb
+        .prepare("SELECT id, label, api_key FROM pool_keys WHERE pool_id = ? ORDER BY id")
+        .all(pool.id);
+    if (rows.length === 0) {
+        console.log(`Pool #${pool.id} "${pool.name}" has no keys. Try: add keys to ${pool.provider}.`);
+        return;
+    }
+    console.log(`Keys in pool #${pool.id} "${pool.name}":`);
+    for (const k of rows)
+        console.log(`  #${k.id} ${k.label} (${mask(k.api_key)})`);
+    console.log(maskTip());
+}
+function cmdUsage(ref) {
+    const pool = needPool(ref);
+    if (!pool)
+        return;
+    const s = poolSummary(pool.id);
+    if (!s) {
+        console.log("Pool not found.");
+        return;
+    }
+    const cooling = sdb.prepare("SELECT COUNT(*) AS n FROM pool_keys WHERE pool_id = ? AND cooldown_until > ?").get(pool.id, Date.now()).n;
+    console.log(usageBlock({ id: s.id, name: s.name, provider: s.provider, used: s.usedInWindow, quota: s.quota, remaining: s.remaining, keys: s.keys, cooling }));
+    for (const k of s.perKey) {
+        const row = sdb.prepare("SELECT api_key FROM pool_keys WHERE id = ?").get(k.id);
+        console.log(`  ${k.label} (${mask(row?.api_key ?? "")}): ${fmtFull(k.used)} tok`);
+    }
+}
+function cmdNext(ref) {
+    const pool = needPool(ref);
+    if (!pool)
+        return;
+    const sel = nextKey(pool.id);
+    if ("error" in sel) {
+        console.log(`Error: ${sel.error}`);
+        return;
+    }
+    console.log(`Next key in pool #${pool.id}: #${sel.key_id} ${sel.label} (${sel.masked})`);
+}
+function cmdConsume(tokens, ref) {
+    const pool = needPool(ref);
+    if (!pool)
+        return;
+    const r = recordUsage(pool.id, tokens);
+    if ("error" in r) {
+        console.log(`Error: ${r.error}`);
+        return;
+    }
+    console.log(`Recorded ${fmtFull(tokens)} tokens on #${r.key_id} ${r.label} (${r.masked}).`);
+}
+function cmdCreatePool(name, provider, ask) {
+    return (async () => {
+        let n = name.trim();
+        let pv = provider.trim().toLowerCase();
+        if (!pv)
+            pv = (await ask("Provider id (e.g. groq)? ")).trim().toLowerCase();
+        const known = PROVIDERS.find((p) => p.id === pv);
+        if (!known) {
+            console.log(`Unknown provider "${pv}". Try 'list providers'.`);
+            return;
+        }
+        if (!n)
+            n = (await ask(`Name for the new ${known.name} pool? `)).trim();
+        if (!n) {
+            console.log("Cancelled (empty name).");
+            return;
+        }
+        if (n.length > 80) {
+            console.log("Name must be <= 80 characters.");
+            return;
+        }
+        const r = sdb.prepare("INSERT INTO pools (provider, name) VALUES (?, ?)").run(known.id, n);
+        console.log(`✓ Created pool #${r.lastInsertRowid} "${n}" (${known.id}). Add keys with: add keys to ${known.id}`);
+    })();
+}
+function cmdDeletePool(ref, ask) {
+    return (async () => {
+        const pool = needPool(ref);
+        if (!pool)
+            return;
+        const ans = (await ask(`Delete pool #${pool.id} "${pool.name}" and its keys? [y/N] `)).trim().toLowerCase();
+        if (ans !== "y" && ans !== "yes") {
+            console.log("Cancelled.");
+            return;
+        }
+        sdb.exec("BEGIN IMMEDIATE");
+        try {
+            sdb.prepare("DELETE FROM usage WHERE pool_id = ?").run(pool.id);
+            sdb.prepare("DELETE FROM pool_keys WHERE pool_id = ?").run(pool.id);
+            sdb.prepare("DELETE FROM pools WHERE id = ?").run(pool.id);
+            sdb.exec("COMMIT");
+        }
+        catch (e) {
+            try {
+                sdb.exec("ROLLBACK");
+            }
+            catch { /* already rolled back */ }
+            throw e;
+        }
+        console.log(`✓ Deleted pool #${pool.id} "${pool.name}".`);
+    })();
+}
+/** Insert pasted lines as keys. Returns counts. Shared by interactive + piped import. */
+export function insertKeys(pool, rawLines) {
+    const existing = sdb.prepare("SELECT COUNT(*) AS n FROM pool_keys WHERE pool_id = ?").get(pool.id).n;
+    const multi = isMultiFieldProvider(pool.provider);
+    let added = 0;
+    let skipped = 0;
+    for (const raw of rawLines) {
+        if (existing + added >= MAX_KEYS_PER_POOL)
+            break;
+        if (multi) {
+            let obj;
+            try {
+                obj = JSON.parse(raw);
+            }
+            catch {
+                skipped++;
+                continue;
+            }
+            const norm = normalizeCredentials(pool.provider, obj);
+            if (!norm.ok) {
+                skipped++;
+                continue;
+            }
+            const single = norm.value["apiKey"] ?? norm.value["api_key"] ?? norm.value["apiToken"] ?? Object.values(norm.value)[0] ?? "";
+            sdb.prepare("INSERT INTO pool_keys (pool_id, label, api_key, credentials) VALUES (?, ?, ?, ?)").run(pool.id, `key ${existing + added + 1}`, single, JSON.stringify(norm.value));
+            added++;
+        }
+        else {
+            const key = raw.trim();
+            if (!key || /[\r\n\0]/.test(key)) {
+                skipped++;
+                continue;
+            }
+            if (key.length > MAX_API_KEY_CHARS) {
+                skipped++;
+                continue;
+            }
+            const dup = sdb.prepare("SELECT id FROM pool_keys WHERE pool_id = ? AND api_key = ?").get(pool.id, key);
+            if (dup) {
+                skipped++;
+                continue;
+            }
+            sdb.prepare("INSERT INTO pool_keys (pool_id, label, api_key) VALUES (?, ?, ?)").run(pool.id, `key ${existing + added + 1}`, key);
+            added++;
+        }
+    }
+    return { added, skipped };
+}
+function importPrompt(pool, expected) {
+    console.log(`✓ Opening key import mode for "${pool.name}" (pool #${pool.id})`);
+    if (isMultiFieldProvider(pool.provider)) {
+        console.log("This provider needs multi-field credentials: paste one JSON object per line.");
+    }
+    else {
+        console.log("Paste API keys (one per line, empty line to finish):");
+    }
+    if (expected !== null)
+        console.log(`(expecting ~${expected} keys)`);
+}
+function liveStats(poolId) {
+    const reqMin = sdb.prepare("SELECT COUNT(*) AS n FROM usage WHERE pool_id = ? AND created_at >= datetime('now','-1 minute')").get(poolId).n;
+    const tokMin = sdb.prepare("SELECT COALESCE(SUM(tokens),0) AS t FROM usage WHERE pool_id = ? AND created_at >= datetime('now','-1 minute')").get(poolId).t;
+    const lat = sdb.prepare("SELECT AVG(latency_ms) AS a FROM pool_keys WHERE pool_id = ? AND latency_ms IS NOT NULL").get(poolId);
+    const perKey = sdb
+        .prepare("SELECT k.id, k.label, k.api_key AS apiKey, COALESCE(SUM(u.tokens),0) AS used FROM pool_keys k LEFT JOIN usage u ON u.key_id = k.id WHERE k.pool_id = ? GROUP BY k.id ORDER BY k.id")
+        .all(poolId);
+    return { reqMin, tokMin, avgLatency: lat.a, perKey };
+}
+async function cmdWatch(ref) {
+    const pool = needPool(ref);
+    if (!pool)
+        return;
+    console.log(`🔄 Pool #${pool.id} "${pool.name}" — live usage  [auto-refresh 2s, press q to exit]`);
+    await new Promise((resolve) => {
+        const render = () => {
+            const st = liveStats(pool.id);
+            readline.cursorTo(process.stdout, 0, 0);
+            readline.clearScreenDown(process.stdout);
+            console.log(`🔄 Pool #${pool.id} "${pool.name}" — live usage  [auto-refresh 2s, press q to exit]`);
+            console.log(`  Requests: ${st.reqMin}/min  │ Tokens: ${st.tokMin}/min  │ Avg latency: ${st.avgLatency === null ? "—" : `${(st.avgLatency / 1000).toFixed(1)}s`}`);
+            for (const k of st.perKey)
+                console.log(`  ${k.label} (${mask(k.apiKey)}): ${fmtFull(k.used)} tok`);
+            console.log(`  ─────────────────────────────────────────`);
+        };
+        render();
+        const timer = setInterval(render, 2000);
+        const stdin = process.stdin;
+        const wasRaw = stdin.isTTY && typeof stdin.setRawMode === "function";
+        if (wasRaw)
+            stdin.setRawMode(true);
+        stdin.resume();
+        const onKey = (buf) => {
+            const ch = buf.toString();
+            if (ch === "q" || ch === "Q" || ch === "\u0003" || ch === "\u001b") {
+                cleanup();
+                resolve();
+            }
+        };
+        const cleanup = () => {
+            clearInterval(timer);
+            stdin.off("data", onKey);
+            if (wasRaw)
+                stdin.setRawMode(false);
+            stdin.pause();
+        };
+        stdin.on("data", onKey);
+    });
+    console.log("Stopped watching.");
+}
+let serverStarted = false;
+async function cmdServe() {
+    if (serverStarted) {
+        console.log(`Server already running on http://${HOST}:${PORT}`);
+        return;
+    }
+    serverStarted = true;
+    await import("../server.js");
+}
+export async function runLine(input, ask, hooks) {
+    const intent = parse(input);
+    switch (intent.kind) {
+        case "exit": return "exit";
+        case "help":
+            console.log(helpBox());
+            return "ok";
+        case "clear":
+            console.clear();
+            return "ok";
+        case "version": {
+            const { readFileSync } = await import("node:fs");
+            const { PACKAGE_ROOT } = await import("../config/paths.js");
+            const { join } = await import("node:path");
+            try {
+                const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8"));
+                console.log(pkg.version ?? "0.0.0");
+            }
+            catch {
+                console.log("0.0.0");
+            }
+            return "ok";
+        }
+        case "list-pools":
+            cmdListPools();
+            return "ok";
+        case "list-providers":
+            cmdListProviders();
+            return "ok";
+        case "list-keys":
+            cmdListKeys(intent.ref);
+            return "ok";
+        case "usage":
+            cmdUsage(intent.ref);
+            return "ok";
+        case "next":
+            cmdNext(intent.ref);
+            return "ok";
+        case "consume":
+            cmdConsume(intent.tokens, intent.ref);
+            return "ok";
+        case "create-pool":
+            await cmdCreatePool(intent.name, intent.provider, ask);
+            return "ok";
+        case "delete-pool":
+            await cmdDeletePool(intent.ref, ask);
+            return "ok";
+        case "add-keys": {
+            const pool = needPool(intent.ref);
+            if (!pool)
+                return "ok";
+            importPrompt(pool, intent.count);
+            return { pool, expected: intent.count, lines: [] };
+        }
+        case "watch": {
+            hooks?.pauseInput?.();
+            try {
+                await cmdWatch(intent.ref);
+            }
+            finally {
+                hooks?.resumeInput?.();
+            }
+            return "ok";
+        }
+        case "serve":
+            await cmdServe();
+            return "ok";
+        case "unknown": {
+            const s = suggest(input, PROVIDERS.map((p) => p.id));
+            console.log(`I didn't understand that.${s ? ` Did you mean '${s}'?` : ""} Type '.help' for commands.`);
+            return "ok";
+        }
+    }
+}
+export async function startRepl(version) {
+    console.log(banner(version));
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "pool-anything > " });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    let importing = null;
+    rl.prompt();
+    rl.on("line", (raw) => {
+        void (async () => {
+            // Key-import mode: collect pasted lines until blank / .done / Ctrl+D (close).
+            if (importing) {
+                if (raw.trim() === "" || raw.trim() === ".done") {
+                    const st = importing;
+                    importing = null;
+                    if (st.lines.length === 0) {
+                        console.log("No keys pasted — nothing added.");
+                    }
+                    else {
+                        const { added, skipped } = insertKeys(st.pool, st.lines);
+                        console.log(`✓ Added ${added} key${added === 1 ? "" : "s"} to pool #${st.pool.id}${skipped > 0 ? ` (${skipped} skipped: blank/duplicate/invalid)` : ""}.`);
+                    }
+                }
+                else {
+                    importing.lines.push(raw);
+                    if (importing.expected !== null && importing.lines.length >= importing.expected) {
+                        const st = importing;
+                        importing = null;
+                        const { added, skipped } = insertKeys(st.pool, st.lines);
+                        console.log(`✓ Added ${added} key${added === 1 ? "" : "s"} to pool #${st.pool.id}${skipped > 0 ? ` (${skipped} skipped: blank/duplicate/invalid)` : ""}.`);
+                    }
+                    else {
+                        rl.prompt();
+                        return;
+                    }
+                }
+                rl.prompt();
+                return;
+            }
+            try {
+                const done = await runLine(raw, ask, { pauseInput: () => rl.pause(), resumeInput: () => rl.resume() });
+                if (typeof done === "object") {
+                    importing = done;
+                    rl.setPrompt("... ");
+                }
+                else {
+                    rl.setPrompt("pool-anything > ");
+                    if (done === "exit")
+                        rl.close();
+                }
+            }
+            catch (e) {
+                console.log(`Error: ${e.message}`);
+            }
+            if (rl.closed !== true)
+                rl.prompt();
+        })();
+    });
+    rl.on("close", () => {
+        // Ctrl+D during import finishes with what was pasted.
+        if (importing && importing.lines.length > 0) {
+            const { added, skipped } = insertKeys(importing.pool, importing.lines);
+            console.log(`\n✓ Added ${added} key${added === 1 ? "" : "s"} to pool #${importing.pool.id}${skipped > 0 ? ` (${skipped} skipped)` : ""}.`);
+            importing = null;
+        }
+    });
+    await new Promise((resolve) => rl.on("close", () => resolve()));
+    console.log("Goodbye!");
+}
+/** One-shot: run a single NL command without the interactive loop. */
+export async function execOnce(command) {
+    const intent = parse(command);
+    // Non-interactive key import reads pasted keys from piped stdin.
+    if (intent.kind === "add-keys") {
+        const pool = needPool(intent.ref);
+        if (!pool)
+            return 1;
+        if (process.stdin.isTTY) {
+            console.log("Interactive paste needs a TTY — run `pool-anything` and type the command there, or pipe keys via stdin.");
+            return 1;
+        }
+        const text = await new Promise((resolve) => {
+            let buf = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (c) => { buf += c; });
+            process.stdin.on("end", () => resolve(buf));
+        });
+        const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+        if (lines.length === 0) {
+            console.log("No keys on stdin — nothing added.");
+            return 1;
+        }
+        const { added, skipped } = insertKeys(pool, lines);
+        console.log(`✓ Added ${added} key${added === 1 ? "" : "s"} to pool #${pool.id}${skipped > 0 ? ` (${skipped} skipped)` : ""}.`);
+        return 0;
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    try {
+        const r = await runLine(command, ask);
+        if (typeof r === "object") {
+            console.log("Key import needs an interactive shell — run `pool-anything` without arguments.");
+            return 1;
+        }
+        return 0;
+    }
+    catch (e) {
+        console.error(`Error: ${e.message}`);
+        return 1;
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/cli/ui.js

@@ -0,0 +1,81 @@
+/** Box/table rendering for the REPL. Zero dependencies; pure functions (testable). */
+export function fmtFull(n) {
+    return Math.round(n).toLocaleString("en-US");
+}
+/** 12450 -> "12.4k", 28000 -> "28k", 999 -> "999", 1.5M handled. */
+export function fmtCompact(n) {
+    if (n < 1000)
+        return String(Math.round(n));
+    if (n < 1_000_000) {
+        const k = n / 1000;
+        return `${k >= 100 ? Math.round(k) : Math.round(k * 10) / 10}k`;
+    }
+    const m = n / 1_000_000;
+    return `${m >= 100 ? Math.round(m) : Math.round(m * 10) / 10}M`;
+}
+function box(lines) {
+    const width = Math.max(...lines.map((l) => l.length), 0);
+    const pad = (l) => `│ ${l.padEnd(width)} │`;
+    return [`┌${"─".repeat(width + 2)}┐`, ...lines.map(pad), `└${"─".repeat(width + 2)}┘`].join("\n");
+}
+export function banner(version) {
+    return [
+        `╔${"═".repeat(62)}╗`,
+        `║ ${`pool-anything v${version} — API key pooler`.padEnd(60)} ║`,
+        `║ ${`Type '.help' for commands, 'exit' to quit`.padEnd(60)} ║`,
+        `╚${"═".repeat(62)}╝`,
+    ].join("\n");
+}
+export function poolsBox(pools) {
+    if (pools.length === 0)
+        return "(no pools yet — try: create pool <name> for <provider>)";
+    const header = `${pools.length} active pool${pools.length === 1 ? "" : "s"}`;
+    const lines = pools.map((p) => {
+        const usage = p.quota === null ? `${fmtCompact(p.used)} tokens` : `${fmtCompact(p.used)} / ${fmtCompact(p.quota * p.keys)} tokens`;
+        const state = p.active ? "" : ", inactive";
+        return `#${p.id} "${p.name}" (${p.provider}) — ${p.keys} key${p.keys === 1 ? "" : "s"}, ${usage}${state}`;
+    });
+    const width = Math.max(header.length, ...lines.map((l) => l.length));
+    const out = [`┌${"─".repeat(width + 2)}┐`, `│ ${header.padEnd(width)} │`, `├${"─".repeat(width + 2)}┤`];
+    for (const l of lines)
+        out.push(`│ ${l.padEnd(width)} │`);
+    out.push(`└${"─".repeat(width + 2)}┘`);
+    return out.join("\n");
+}
+export function usageBlock(u) {
+    const bar = "━".repeat(45);
+    const quota = u.quota === null ? "unlimited" : fmtFull(u.quota * u.keys);
+    const remaining = u.remaining === null ? "—" : fmtFull(u.remaining);
+    const pct = u.quota === null || u.quota * u.keys === 0 ? "" : ` (${Math.round((u.used / (u.quota * u.keys)) * 100)}% exhausted)`;
+    return [
+        `Pool #${u.id}: ${u.name} (${u.provider})`,
+        bar,
+        ` Used: ${fmtFull(u.used)} tokens | Quota: ${quota} | Remaining: ${remaining}${pct}`,
+        ` Status: ${u.cooling > 0 ? `${u.cooling} key${u.cooling === 1 ? "" : "s"} cooling` : "OK"} | Keys: ${u.keys} active, ${u.cooling} cooling`,
+        bar,
+    ].join("\n");
+}
+export function helpBox() {
+    const rows = [
+        ["list pools", "show all pools with key counts + usage"],
+        ["list providers", "show known providers"],
+        ["list keys [for <pool>]", "masked keys in a pool"],
+        ["show usage for <pool>", "token usage, quota, per-key breakdown"],
+        ["add [N] keys to <pool>", "paste keys (one per line, empty line to finish)"],
+        ["create pool <name> for <provider>", "make a new pool"],
+        ["delete pool <name>", "remove a pool (asks to confirm)"],
+        ["watch <pool>", "live usage, refreshes every 2s (q to exit)"],
+        ["next [for <pool>]", "rotate: show the next key (masked)"],
+        ["consume <n> [on <pool>]", "record token usage"],
+        ["serve", "start the web UI + API server"],
+        ["clear", "clear the screen"],
+        ["exit", "quit"],
+    ];
+    const w = Math.max(...rows.map(([c]) => c.length));
+    return ["Commands:", ...rows.map(([c, d]) => `  ${c.padEnd(w)}  ${d}`)].join("\n");
+}
+export function maskTip() {
+    return "Keys are shown masked (gsk_…ab) — raw values never print.";
+}
+// Re-export box helper for tests (kept trivial on purpose).
+export { box };