pool-anything 0.1.0 → 0.1.1

package/dist/pool/index.js

@@ -37,6 +37,22 @@ sdb.exec(`
   CREATE INDEX IF NOT EXISTS idx_usage_pool_created ON usage(pool_id, created_at);
   CREATE INDEX IF NOT EXISTS idx_usage_key_created ON usage(key_id, created_at);
   CREATE INDEX IF NOT EXISTS idx_pools_provider ON pools(provider);
+  CREATE TABLE IF NOT EXISTS calls (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pool_id INTEGER NOT NULL REFERENCES pools(id) ON DELETE CASCADE,
+    key_id INTEGER NOT NULL REFERENCES pool_keys(id) ON DELETE CASCADE,
+    method TEXT NOT NULL DEFAULT 'POST',
+    path TEXT NOT NULL DEFAULT '',
+    status INTEGER,
+    tokens INTEGER NOT NULL DEFAULT 0,
+    body TEXT NOT NULL DEFAULT '',
+    truncated INTEGER NOT NULL DEFAULT 0,
+    encoding TEXT NOT NULL DEFAULT 'text',
+    content_type TEXT NOT NULL DEFAULT '',
+    error TEXT NOT NULL DEFAULT '',
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_calls_pool_created ON calls(pool_id, created_at);
 `);
 const FALLBACK_PROVIDERS = [
     {
@@ -108,6 +124,29 @@ export function mask(key) {
         return "****";
     return `${key.slice(0, 4)}…${key.slice(-2)}`;
 }
+/** Max response chars kept per call row — bounds DB growth (media relays are MBs). */
+export const CALLS_BODY_CHARS = 4000;
+/** Higher cap for binary media (audio/video/image base64) so generated files
+ *  stay playable/renderable from History. Still bounded: ~2MB per row worst case. */
+export const CALLS_MEDIA_CHARS = 2_000_000;
+/** Pick the storage slice for a relay body: text stays small, binary media
+ *  keeps enough bytes to stay playable/renderable. Pure (testable). */
+export function callBodyForStorage(relayBody, encoding, truncated) {
+    const cap = encoding === "base64" ? CALLS_MEDIA_CHARS : CALLS_BODY_CHARS;
+    if (relayBody.length <= cap)
+        return { body: relayBody, truncated };
+    return { body: relayBody.slice(0, cap), truncated: true };
+}
+export function logCall(c) {
+    try {
+        sdb
+            .prepare("INSERT INTO calls (pool_id, key_id, method, path, status, tokens, body, truncated, encoding, content_type, error) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(c.pool_id, c.key_id, c.method.slice(0, 16), c.path.slice(0, 2000), c.status, c.tokens, c.body.slice(0, CALLS_MEDIA_CHARS), c.truncated ? 1 : 0, c.encoding.slice(0, 16), c.contentType.slice(0, 256), c.error.slice(0, 500));
+    }
+    catch {
+        // Call logging must never break proxying.
+    }
+}
 export function providerKeyFields(provider) {
     return PROVIDERS.find((x) => x.id === provider)?.keyFields ?? ["api_key"];
 }

package/dist/proxy/forward.js

@@ -1,4 +1,4 @@
-import { sdb, getPool } from "../pool/index.js";
+import { sdb, getPool, logCall, callBodyForStorage } from "../pool/index.js";
 import { nextKeyRaw, markSuccess, markFailure } from "../pool/rotation.js";
 import { resolveTarget, resolveTargetForKey, effectiveApiKey, buildUpstreamRequest, validateQueryParams } from "../upstream/index.js";
 import { allowPrivateUpstream, proxyTimeoutMs } from "../config/env.js";
@@ -168,6 +168,25 @@ export function validateProxyOpts(opts) {
         if (!q.ok)
             return { ok: false, error: q.error };
     }
+    if (opts.body !== undefined && opts.form !== undefined)
+        return { ok: false, error: "body and form are mutually exclusive" };
+    if (opts.form !== undefined) {
+        if (typeof opts.form !== "object" || opts.form === null || Array.isArray(opts.form))
+            return { ok: false, error: "form must be an object" };
+        const entries = Object.entries(opts.form);
+        if (entries.length > 50)
+            return { ok: false, error: "too many form fields" };
+        let bytes = 0;
+        for (const [k, v] of entries) {
+            if (typeof k !== "string" || k.length === 0 || k.length > 256 || /[\r\n\x00]/.test(k))
+                return { ok: false, error: "invalid form field name" };
+            if (typeof v !== "string" || v.length > 8000 || /[\r\n\x00]/.test(v))
+                return { ok: false, error: "invalid form field value" };
+            bytes += k.length + v.length;
+        }
+        if (bytes > MAX_PROXY_BODY_BYTES)
+            return { ok: false, error: `proxy form too large (max ${Math.round(MAX_PROXY_BODY_BYTES / 1_000_000)}MB)` };
+    }
     if (opts.body !== undefined) {
         try {
             const s = JSON.stringify(opts.body);
@@ -224,6 +243,14 @@ async function readCappedBody(res, cap) {
 export function timeoutMs() {
     return proxyTimeoutMs();
 }
+/** POOL_DEBUG=1: per-request proxy trace on stderr (method/path/pool and
+ *  upstream statuses). Never logs bodies or key material. */
+function dlog(poolId, opts, tried, extra = "") {
+    if (process.env.POOL_DEBUG !== "1")
+        return;
+    const st = tried.map((t) => (t.status ?? "?")).join(",");
+    console.error(`[proxy] ${opts.method || "POST"} ${opts.path || "/"} pool=${poolId} tried=[${st}]${extra ? " " + extra : ""}`);
+}
 /**
  * Forward one request through the pool: rotate, send, fail over on
  * 429/5xx/network errors (key cools down, next key tried). Returns the
@@ -247,8 +274,10 @@ export async function forward(poolId, opts) {
         }
     }
     const valid = validateProxyOpts(opts);
-    if (!valid.ok)
+    if (!valid.ok) {
+        dlog(poolId, opts, [], `invalid: ${valid.error}`);
         return { status: 400, error: valid.error };
+    }
     // Bound failover: one client request must not fan out to every key in a
     // large pool (100 keys x timeout each would starve the single-thread server).
     const keyTotal = sdb.prepare("SELECT COUNT(*) AS n FROM pool_keys WHERE pool_id = ?").get(poolId).n;
@@ -257,6 +286,7 @@ export async function forward(poolId, opts) {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
         const sel = nextKeyRaw(poolId);
         if ("error" in sel) {
+            dlog(poolId, opts, tried, `no-key: ${sel.error}`);
             return { status: 400, error: sel.error, tried };
         }
         let req;
@@ -293,13 +323,16 @@ export async function forward(poolId, opts) {
         }
         catch {
             markFailure(sel.key_id);
+            logCall({ pool_id: poolId, key_id: sel.key_id, method: opts.method || "POST", path: opts.path || "/", status: null, tokens: 0, body: "", truncated: false, encoding: "text", contentType: "", error: "upstream network error" });
             tried.push({ key_id: sel.key_id, label: sel.label, detail: "upstream network error" });
             continue;
         }
         if (upstream.status >= 300 && upstream.status < 400) {
             // Redirects are not followed and are not the key's fault: report without cooling.
             await upstream.body?.cancel().catch(() => undefined);
+            logCall({ pool_id: poolId, key_id: sel.key_id, method: opts.method || "POST", path: opts.path || "/", status: upstream.status, tokens: 0, body: "", truncated: false, encoding: "text", contentType: "", error: "redirect not followed" });
             tried.push({ key_id: sel.key_id, label: sel.label, status: upstream.status });
+            dlog(poolId, opts, tried, "redirect");
             return { status: 400, error: `upstream redirected (HTTP ${upstream.status}, location not followed)`, tried };
         }
         let text = "";
@@ -315,6 +348,7 @@ export async function forward(poolId, opts) {
         }
         catch {
             markFailure(sel.key_id);
+            logCall({ pool_id: poolId, key_id: sel.key_id, method: opts.method || "POST", path: opts.path || "/", status: upstream.status, tokens: 0, body: "", truncated: false, encoding: "text", contentType: "", error: "upstream body error" });
             tried.push({ key_id: sel.key_id, label: sel.label, status: upstream.status, detail: "upstream body error" });
             await upstream.body?.cancel().catch(() => undefined);
             continue;
@@ -325,10 +359,13 @@ export async function forward(poolId, opts) {
         const relayBody = b64 !== undefined ? b64.slice(0, MAX_RELAY_CHARS) : text.slice(0, MAX_RELAY_CHARS);
         truncated = truncated || rawLen > MAX_RELAY_CHARS;
         const encoding = b64 !== undefined ? "base64" : "text";
+        const stored = callBodyForStorage(relayBody, encoding, truncated);
+        const callBase = { pool_id: poolId, key_id: sel.key_id, method: opts.method || "POST", path: opts.path || "/", body: stored.body, truncated: stored.truncated, encoding, contentType };
         if (upstream.status === 429 || upstream.status >= 500 || upstream.status === 401 || upstream.status === 403) {
             // 401/403 = invalid/revoked key: cool it so rotation skips it instead of
             // paying one dead upstream call on every subsequent request.
             markFailure(sel.key_id);
+            logCall({ ...callBase, status: upstream.status, tokens: 0, error: "" });
             tried.push({ key_id: sel.key_id, label: sel.label, status: upstream.status });
             await upstream.body?.cancel().catch(() => undefined);
             continue;
@@ -337,6 +374,8 @@ export async function forward(poolId, opts) {
             // Other 4xx: client/upstream error, not the key's fault. Passthrough
             // without cooling and without charging quota.
             tried.push({ key_id: sel.key_id, label: sel.label, status: upstream.status });
+            logCall({ ...callBase, status: upstream.status, tokens: 0, error: "" });
+            dlog(poolId, opts, tried, "passthrough");
             return { status: 200, key_id: sel.key_id, label: sel.label, masked: sel.masked, upstreamStatus: upstream.status, body: relayBody, encoding, contentType, truncated, tried };
         }
         markSuccess(sel.key_id, Date.now() - started);
@@ -344,7 +383,10 @@ export async function forward(poolId, opts) {
         if (Number.isInteger(tok) && tok > 0) {
             sdb.prepare("INSERT INTO usage (pool_id, key_id, tokens) VALUES (?, ?, ?)").run(poolId, sel.key_id, tok);
         }
+        logCall({ ...callBase, status: upstream.status, tokens: Number.isInteger(tok) && tok > 0 ? tok : 0, error: "" });
+        dlog(poolId, opts, tried, `ok upstream=${upstream.status}`);
         return { status: 200, key_id: sel.key_id, label: sel.label, masked: sel.masked, upstreamStatus: upstream.status, body: relayBody, encoding, contentType, truncated, tried };
     }
+    dlog(poolId, opts, tried, "all-failed");
     return { status: 400, error: "all keys failed or cooling down", tried };
 }

package/dist/router/api.js

@@ -2,11 +2,11 @@
 export const MAX_POOLS = 1000;
 export const MAX_KEYS_PER_POOL = 100;
 export const MAX_API_KEY_CHARS = 4096;
-/** Match /api/pools/:id[/next|/consume|/usage|/proxy] (never /keys). */
+/** Match /api/pools/:id[/next|/consume|/usage|/proxy|/calls] (never /keys). */
 export function matchPoolRoute(pathname) {
     if (pathname.includes("/keys"))
         return null;
-    const m = pathname.match(/^\/api\/pools\/(\d+)(\/next|\/consume|\/usage|\/proxy)?$/);
+    const m = pathname.match(/^\/api\/pools\/(\d+)(\/next|\/consume|\/usage|\/proxy|\/calls)?$/);
     if (!m)
         return null;
     return { poolId: Number(m[1]), sub: (m[2] ?? "") };

package/dist/server.js

@@ -10,9 +10,11 @@ import { sdb, PROVIDERS, mask, maskCredentials, normalizeCredentials, parseCrede
 import { nextKey, recordUsage } from "./pool/rotation.js";
 import { forward, MAX_TOKENS_PER_REQUEST, checkTarget } from "./proxy/forward.js";
 import { DOCS_URL } from "./admin/branding.js";
-import { page, keysPage, poolsPage, analyticsPage, playgroundPage, providerPage } from "./admin/pages.js";
+import { robotsTxt, sitemapXml } from "./admin/seo.js";
+import { page, keysPage, poolsPage, analyticsPage, historyPage, playgroundPage, providerPage } from "./admin/pages.js";
 import { MAX_POOLS, MAX_KEYS_PER_POOL, MAX_API_KEY_CHARS, matchPoolRoute, matchKeyRoute } from "./router/api.js";
 import { health, readiness, analyticsSnapshot } from "./observability/health.js";
+import { getVersionInfo, performUpdate } from "./version.js";
 const server = http.createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", "http://localhost");
     // CORS: only the hosted Pages tools UI (plus http loopback dev and
@@ -62,6 +64,15 @@ const server = http.createServer(async (req, res) => {
             send(res, 200, PROVIDERS);
             return;
         }
+        if (req.method === "GET" && url.pathname === "/api/version") {
+            send(res, 200, await getVersionInfo());
+            return;
+        }
+        if (req.method === "POST" && url.pathname === "/api/update") {
+            const r = await performUpdate();
+            send(res, r.ok ? 200 : 500, r);
+            return;
+        }
         if (req.method === "GET" && url.pathname === "/api/analytics") {
             const r = analyticsSnapshot();
             send(res, r.status, r.body);
@@ -120,6 +131,7 @@ const server = http.createServer(async (req, res) => {
             if (req.method === "DELETE" && !sub) {
                 sdb.exec("BEGIN IMMEDIATE");
                 try {
+                    sdb.prepare("DELETE FROM calls WHERE pool_id = ?").run(poolId);
                     sdb.prepare("DELETE FROM usage WHERE pool_id = ?").run(poolId);
                     sdb.prepare("DELETE FROM pool_keys WHERE pool_id = ?").run(poolId);
                     const r = sdb.prepare("DELETE FROM pools WHERE id = ?").run(poolId);
@@ -168,6 +180,14 @@ const server = http.createServer(async (req, res) => {
                 send(res, 200, { pool_id: s.id, used: s.used, usedInWindow: s.usedInWindow, quota: s.quota, quotaWindow: s.quotaWindow, remaining: s.remaining, perKey: s.perKey });
                 return;
             }
+            if (req.method === "GET" && sub === "/calls") {
+                const pool = getPool(poolId);
+                if (!pool)
+                    return send(res, 404, { error: "pool not found" });
+                const limit = Math.min(Math.max(Number(url.searchParams.get("limit")) || 50, 1), 200);
+                send(res, 200, sdb.prepare("SELECT id, pool_id, key_id, method, path, status, tokens, body, truncated, encoding, content_type, error, created_at FROM calls WHERE pool_id = ? ORDER BY id DESC LIMIT ?").all(poolId, limit));
+                return;
+            }
             if (req.method === "POST" && sub === "/proxy") {
                 // Media-aware limit: base64 image/audio/video payloads ride inside JSON.
                 const b = (await readJson(req, MAX_PROXY_BODY_BYTES));
@@ -189,13 +209,15 @@ const server = http.createServer(async (req, res) => {
                 if (!pool)
                     return send(res, 404, { error: "pool not found" });
                 const fields = providerKeyFields(pool.provider);
+                const now = Date.now();
                 const rows = sdb
-                    .prepare("SELECT id, label, api_key, COALESCE(credentials,'{}') AS credentials, info, created_at FROM pool_keys WHERE pool_id = ? ORDER BY id")
+                    .prepare("SELECT id, label, api_key, COALESCE(credentials,'{}') AS credentials, info, created_at, cooldown_until FROM pool_keys WHERE pool_id = ? ORDER BY id")
                     .all(poolId);
                 send(res, 200, rows.map((k) => {
                     const creds = parseCredentials(k.credentials);
                     return {
                         id: k.id, label: k.label, masked: mask(k.api_key), info: k.info, created_at: k.created_at,
+                        cooling: k.cooldown_until > now,
                         keyFields: fields,
                         credentials: Object.keys(creds).length > 0 ? maskCredentials(creds) : undefined,
                     };
@@ -268,12 +290,12 @@ const server = http.createServer(async (req, res) => {
             }
             if (req.method === "GET" && keyId !== undefined) {
                 const row = sdb
-                    .prepare("SELECT id, label, api_key, COALESCE(credentials,'{}') AS credentials, info, created_at FROM pool_keys WHERE id = ? AND pool_id = ?")
+                    .prepare("SELECT id, label, api_key, COALESCE(credentials,'{}') AS credentials, info, created_at, cooldown_until FROM pool_keys WHERE id = ? AND pool_id = ?")
                     .get(Number(keyId), poolId);
                 if (!row)
                     return send(res, 404, { error: "key not found" });
                 const creds = parseCredentials(row.credentials);
-                send(res, 200, { ...row, credentials: Object.keys(creds).length > 0 ? creds : undefined, masked: mask(row.api_key), maskedCredentials: Object.keys(creds).length > 0 ? maskCredentials(creds) : undefined });
+                send(res, 200, { ...row, cooling: row.cooldown_until > Date.now(), credentials: Object.keys(creds).length > 0 ? creds : undefined, masked: mask(row.api_key), maskedCredentials: Object.keys(creds).length > 0 ? maskCredentials(creds) : undefined });
                 return;
             }
             if (req.method === "PATCH" && keyId !== undefined) {
@@ -326,6 +348,7 @@ const server = http.createServer(async (req, res) => {
                 return;
             }
             if (req.method === "DELETE" && keyId !== undefined) {
+                sdb.prepare("DELETE FROM calls WHERE key_id = ?").run(Number(keyId));
                 sdb.prepare("DELETE FROM usage WHERE key_id = ?").run(Number(keyId));
                 const r = sdb.prepare("DELETE FROM pool_keys WHERE id = ? AND pool_id = ?").run(Number(keyId), poolId);
                 if (r.changes === 0)
@@ -370,6 +393,11 @@ const server = http.createServer(async (req, res) => {
             res.end(analyticsPage());
             return;
         }
+        if (req.method === "GET" && url.pathname === "/history") {
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.end(historyPage());
+            return;
+        }
         if (req.method === "GET" && url.pathname.startsWith("/provider/")) {
             const pid = url.pathname.slice("/provider/".length);
             if (!/^[a-z0-9-]+$/.test(pid)) {
@@ -402,6 +430,17 @@ const server = http.createServer(async (req, res) => {
             res.end(h.body);
             return;
         }
+        if (req.method === "GET" && url.pathname === "/robots.txt") {
+            res.writeHead(200, { "content-type": "text/plain; charset=utf-8", "cache-control": "public, max-age=3600" });
+            res.end(robotsTxt());
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/sitemap.xml") {
+            const ids = PROVIDERS.map((p) => p.id).filter((id) => typeof id === "string");
+            res.writeHead(200, { "content-type": "application/xml; charset=utf-8", "cache-control": "public, max-age=3600" });
+            res.end(sitemapXml(ids));
+            return;
+        }
         res.writeHead(404, { "content-type": "text/plain" });
         res.end("not found\n");
     }

package/dist/upstream/index.js

@@ -133,5 +133,15 @@ export function buildUpstreamRequest(target, apiKey, opts) {
         headers[target.keyHeader] = target.keyPrefix + apiKey;
     }
     const base = target.baseUrl.endsWith("/") ? target.baseUrl.slice(0, -1) : target.baseUrl;
+    if (opts.form !== undefined) {
+        // Form-only upstreams: urlencode fields and override the JSON content type.
+        // Caller content-type is dropped so the header can't lie about the body.
+        for (const k of Object.keys(headers)) {
+            if (k.toLowerCase() === "content-type")
+                delete headers[k];
+        }
+        headers["content-type"] = "application/x-www-form-urlencoded";
+        return { url: base + p, headers, body: new URLSearchParams(opts.form).toString() };
+    }
     return { url: base + p, headers, body: opts.body === undefined ? undefined : JSON.stringify(opts.body) };
 }

package/dist/version.js

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { PACKAGE_ROOT } from "./config/paths.js";
+export const PACKAGE_NAME = "pool-anything";
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const LATEST_TTL_MS = 5 * 60 * 1000;
+export function readCurrentVersion() {
+    try {
+        const raw = fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8");
+        const pkg = JSON.parse(raw);
+        return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function npmCmd() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+/** Numeric semver compare: >0 when a is newer, 0 when equal, <0 when older. */
+export function compareVersions(a, b) {
+    const norm = (v) => v
+        .trim()
+        .replace(/^v/i, "")
+        .split("-")[0]
+        .split(".")
+        .map((p) => {
+        const n = Number(p);
+        return Number.isFinite(n) ? n : 0;
+    });
+    const pa = norm(a);
+    const pb = norm(b);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+export async function fetchLatestVersion(timeoutMs = 6000) {
+    try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), timeoutMs);
+        try {
+            const r = await fetch(REGISTRY_URL, { signal: ctrl.signal });
+            if (!r.ok)
+                return null;
+            const j = (await r.json());
+            return typeof j.version === "string" ? j.version : null;
+        }
+        finally {
+            clearTimeout(t);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+let cachedLatest = null;
+export async function getVersionInfo() {
+    const current = readCurrentVersion();
+    const now = Date.now();
+    if (cachedLatest && now - cachedLatest.at < LATEST_TTL_MS) {
+        const latest = cachedLatest.version;
+        return {
+            current,
+            latest,
+            updateAvailable: latest !== null && compareVersions(latest, current) > 0,
+        };
+    }
+    const latest = await fetchLatestVersion();
+    cachedLatest = { version: latest, at: now };
+    return {
+        current,
+        latest,
+        updateAvailable: latest !== null && compareVersions(latest, current) > 0,
+    };
+}
+function runNpm(args) {
+    try {
+        const r = spawnSync(npmCmd(), args, { encoding: "utf8", timeout: 120_000 });
+        const out = `${r.stdout ?? ""}${r.stderr ?? ""}`.trim();
+        const err = r.error;
+        if (err)
+            return { ok: false, output: `npm ${args.join(" ")} failed: ${err.message}` };
+        return {
+            ok: r.status === 0,
+            output: out.slice(-2000) || (r.status === 0 ? "ok" : `npm exited with code ${r.status}`),
+        };
+    }
+    catch (e) {
+        return { ok: false, output: `npm ${args.join(" ")} failed: ${e.message}` };
+    }
+}
+export async function performUpdate() {
+    const previous = readCurrentVersion();
+    const latest = await fetchLatestVersion();
+    if (latest !== null && compareVersions(latest, previous) <= 0) {
+        return {
+            ok: true,
+            previous,
+            current: previous,
+            latest,
+            updated: false,
+            text: `Already on latest v${previous}.`,
+        };
+    }
+    const r = runNpm(["install", "-g", `${PACKAGE_NAME}@latest`]);
+    if (!r.ok) {
+        return {
+            ok: false,
+            previous,
+            current: previous,
+            latest,
+            updated: false,
+            text: `Update failed: ${r.output}`,
+            output: r.output,
+        };
+    }
+    // Bust the cached latest — the registry state is now what we run (or will
+    // run after restart).
+    cachedLatest = { version: latest, at: Date.now() };
+    const current = readCurrentVersion();
+    const target = latest ?? (current !== previous ? current : null);
+    if (target !== null && current === target && current !== previous) {
+        return {
+            ok: true,
+            previous,
+            current,
+            latest,
+            updated: true,
+            text: `Updated v${previous} → v${current}. Restart the shell/server to use it.`,
+            output: r.output,
+        };
+    }
+    // Source checkout (npm -g updates the global copy, not this tree) or a
+    // registry check that failed: the install succeeded, report what we know.
+    const suffix = target !== null ? ` (latest v${target}). Restart to use it.` : `. Restart to use it.`;
+    return {
+        ok: true,
+        previous,
+        current,
+        latest,
+        updated: true,
+        text: `Update installed${latest !== null ? ` v${previous} → v${latest}` : ""}${suffix} ${r.output}`.trim(),
+        output: r.output,
+    };
+}
+export function performUninstall() {
+    const r = runNpm(["uninstall", "-g", PACKAGE_NAME]);
+    if (!r.ok) {
+        return { ok: false, text: `Uninstall failed: ${r.output}`, output: r.output };
+    }
+    return {
+        ok: true,
+        text: `Uninstalled ${PACKAGE_NAME}. Your pools/keys in SQLite are untouched (remove ~/.pool-anything to wipe data).`,
+        output: r.output,
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pool-anything",
-  "version": "0.1.0",
-  "description": "Gather free-tier API keys from any provider into one pool and rotate through them — round-robin key selection, usage/quota tracking, and a drop-in HTTP proxy with a built-in web UI. Zero dependencies, TypeScript + SQLite.",
+  "version": "0.1.1",
+  "description": "Gather free-tier API keys from any provider into one pool and rotate through them — round-robin key selection, usage/quota tracking, and a drop-in HTTP proxy with a built-in web UI. Dependency-free server core, TypeScript + SQLite.",
   "keywords": [
     "api-key-pool",
     "key-rotation",
@@ -15,7 +15,7 @@
     "quota",
     "sqlite",
     "typescript",
-    "zero-dependency",
+    "ink-tui",
     "groq",
     "openrouter",
     "gemini",
@@ -62,7 +62,12 @@
   },
   "devDependencies": {
     "@types/node": "^22.7.4",
+    "@types/react": "^19.3.0",
     "tsx": "^4.19.1",
     "typescript": "^5.6.2"
+  },
+  "dependencies": {
+    "ink": "^7.1.1",
+    "react": "^19.3.0"
   }
 }