pool-anything 0.1.0 → 0.1.1

package/dist/cli/repl.js

@@ -1,248 +1,77 @@
 /**
- * Interactive REPL: readline loop + command handlers over the pool SQLite DB.
- * Reuses pool/rotation/router helpers — no duplicated quota or rotation logic.
+ * Plain-text frontend over the command core: readline REPL fallback + one-shot exec.
+ * The rich interactive shell lives in tui.tsx (Ink); this stays script-friendly.
  */
 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 { PROVIDERS } from "../pool/index.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;
+import { parse } from "./nl.js";
+import { banner, poolsBox, usageBlock, maskTip, fmtFull } from "./ui.js";
+import { dispatch, insertKeys, liveStats } from "./commands.js";
+/** Render one result as plain text. Returns an import state when pasting begins. */
+export function renderResult(r) {
+    switch (r.kind) {
+        case "exit": return null;
+        case "clear":
+            console.clear();
+            return null;
+        case "message":
+            console.log(r.text);
+            return null;
+        case "pools":
+            console.log(poolsBox(r.pools));
+            return null;
+        case "providers":
+            for (const p of PROVIDERS)
+                console.log(`- ${p.id} — ${p.name} (${p.quota || "no quota"})`);
+            return null;
+        case "keys": {
+            if (r.keys.length === 0) {
+                console.log(`Pool #${r.pool.id} "${r.pool.name}" has no keys. Try: add keys to ${r.pool.provider}.`);
+                return null;
             }
-            sdb.prepare("INSERT INTO pool_keys (pool_id, label, api_key) VALUES (?, ?, ?)").run(pool.id, `key ${existing + added + 1}`, key);
-            added++;
+            console.log(`Keys in pool #${r.pool.id} "${r.pool.name}":`);
+            for (const k of r.keys)
+                console.log(`  #${k.id} ${k.label} (${k.masked})`);
+            console.log(maskTip());
+            return null;
+        }
+        case "usage": {
+            console.log(usageBlock(r.view));
+            for (const k of r.perKey)
+                console.log(`  ${k.label} (${k.masked}): ${fmtFull(k.used)} tok`);
+            return null;
+        }
+        case "import":
+            console.log(`✓ Opening key import mode for "${r.pool.name}" (pool #${r.pool.id})`);
+            console.log(r.hint);
+            return { pool: r.pool, expected: r.expected, lines: [] };
+        case "watch": {
+            void watchPlain(r.pool);
+            return null;
         }
+        case "serve":
+            console.log(r.already ? `Server already running on http://${HOST}:${PORT}` : `Serving on http://${HOST}:${PORT}`);
+            return null;
     }
-    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):");
+export function finishImport(st) {
+    if (st.lines.length === 0) {
+        console.log("No keys pasted — nothing added.");
+        return;
     }
-    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 };
+    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)` : ""}.`);
 }
-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]`);
+async function watchPlain(pool) {
+    const { mask } = await import("../pool/index.js");
+    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(`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`);
@@ -273,88 +102,22 @@ async function cmdWatch(ref) {
     });
     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";
-        }
-    }
+/** Execute one line in the plain frontend. Returns "exit" or a pending import. */
+export async function runLine(input, ask) {
+    const r = await dispatch(input, ask);
+    if (r.kind === "exit")
+        return "exit";
+    if (r.kind === "watch") {
+        await watchPlain(r.pool);
+        return "ok";
+    }
+    const imp = renderResult(r);
+    // A confirmed uninstall removes the binary out from under us — show the
+    // result, then leave the shell instead of prompting on a dead install.
+    if (parse(input).kind === "uninstall" &&
+        r.kind === "message" && r.tone === "ok")
+        return "exit";
+    return imp ?? "ok";
 }
 export async function startRepl(version) {
     console.log(banner(version));
@@ -364,26 +127,18 @@ export async function startRepl(version) {
     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)` : ""}.`);
-                    }
+                    finishImport(st);
                 }
                 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)` : ""}.`);
+                        finishImport(st);
                     }
                     else {
                         rl.prompt();
@@ -394,7 +149,7 @@ export async function startRepl(version) {
                 return;
             }
             try {
-                const done = await runLine(raw, ask, { pauseInput: () => rl.pause(), resumeInput: () => rl.resume() });
+                const done = await runLine(raw, ask);
                 if (typeof done === "object") {
                     importing = done;
                     rl.setPrompt("... ");
@@ -413,10 +168,9 @@ export async function startRepl(version) {
         })();
     });
     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)` : ""}.`);
+            console.log("");
+            finishImport(importing);
             importing = null;
         }
     });
@@ -426,11 +180,13 @@ export async function startRepl(version) {
 /** 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)
+        const { resolvePool } = await import("./commands.js");
+        const pool = resolvePool(intent.ref);
+        if (!pool) {
+            console.log(intent.ref.trim() ? `No pool matches "${intent.ref.trim()}".` : "No pools yet.");
             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;
@@ -453,11 +209,19 @@ export async function execOnce(command) {
     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") {
+        const r = await dispatch(command, ask);
+        if (r.kind === "import") {
             console.log("Key import needs an interactive shell — run `pool-anything` without arguments.");
             return 1;
         }
+        if (r.kind === "watch") {
+            rl.close();
+            await watchPlain(r.pool);
+            return 0;
+        }
+        if (r.kind === "exit" || r.kind === "clear")
+            return 0;
+        renderResult(r);
         return 0;
     }
     catch (e) {