quotacap 0.0.1

package/dist/src/config.js

@@ -0,0 +1,32 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+export function getConfigPath(p) {
+    if (p)
+        return p;
+    return path.join(os.homedir(), ".quotacap", "config.json");
+}
+export function getDbPath(p) {
+    if (p)
+        return p;
+    return path.join(os.homedir(), ".quotacap", "quotacap.db");
+}
+const ConfigSchema = z.object({
+    port: z.number().default(8787),
+    pollMinutes: z.number().default(15),
+    enabledProviders: z.array(z.string()).default(["claude"]),
+});
+export async function readConfig(p) {
+    try {
+        const raw = await fs.readFile(getConfigPath(p), "utf8");
+        return ConfigSchema.parse(JSON.parse(raw));
+    }
+    catch {
+        return ConfigSchema.parse({});
+    }
+}
+export async function writeConfig(c, p) {
+    await fs.mkdir(path.dirname(getConfigPath(p)), { recursive: true });
+    await fs.writeFile(getConfigPath(p), JSON.stringify(c, null, 2));
+}

package/dist/src/daemon.d.ts

@@ -0,0 +1,22 @@
+export declare function pollOnce(db: any, enabled: string[]): Promise<({
+    provider: string;
+    status: "fulfilled";
+    value: import("./adapters/types.js").Quota;
+    reason?: undefined;
+} | {
+    provider: string;
+    status: "skipped";
+    reason: any;
+    value?: undefined;
+} | {
+    provider: string;
+    status: "rejected";
+    reason: any;
+    value?: undefined;
+})[]>;
+export declare function startDaemon(): Promise<{
+    db: any;
+    timer: NodeJS.Timeout;
+    stop: () => void;
+}>;
+export declare const start: typeof startDaemon;

package/dist/src/daemon.js

@@ -0,0 +1,30 @@
+import { pollAll } from "./adapters/index.js";
+import { upsertQuota } from "./store/quotas.js";
+export async function pollOnce(db, enabled) {
+    const results = await pollAll(enabled);
+    for (const r of results) {
+        if (r.status === "fulfilled" && r.value)
+            upsertQuota(db, r.value);
+        else if (r.status === "rejected")
+            console.warn(`[quotacap] poll ${r.provider} failed: ${String(r.reason?.message ?? r.reason)}`);
+        // skipped (e.g. manual) is not a failure — no warning, not degraded
+    }
+    return results;
+}
+export async function startDaemon() {
+    const { getDbPath, readConfig } = await import("./config.js");
+    const { openDb, migrate } = await import("./store/db.js");
+    const db = openDb(getDbPath());
+    migrate(db);
+    const cfg = await readConfig();
+    const intervalMs = (cfg.pollMinutes ?? 15) * 60 * 1000;
+    // initial poll (fire-and-forget, don't block start)
+    pollOnce(db, cfg.enabledProviders).catch(e => console.warn("[quotacap] initial poll failed", e?.message ?? String(e)));
+    const jitter = Math.floor(Math.random() * 5000);
+    const timer = setInterval(() => { pollOnce(db, cfg.enabledProviders).catch(e => console.warn("[quotacap] interval poll failed", e?.message ?? String(e))); }, intervalMs + jitter);
+    // keep event loop alive — this is the only long-lived process per design
+    // (previous unref() caused immediate exit after the initial poll)
+    return { db, timer, stop: () => clearInterval(timer) };
+}
+// alias for plan's daemon.start() naming
+export const start = startDaemon;

package/dist/src/http/server.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+export declare function buildApp(db: any): FastifyInstance;
+export declare function getLastPollAt(app?: FastifyInstance): string | null;
+export declare function resetRefreshState(app?: FastifyInstance): void;

package/dist/src/http/server.js

@@ -0,0 +1,142 @@
+import Fastify from "fastify";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { webHtml } from "../webHtml.js";
+import { webAssets } from "../webAssets.js";
+// per-app state registry for backward-compat helpers
+const appStates = new WeakMap();
+const allStates = new Set();
+export function buildApp(db) {
+    const state = { lastPollAt: null, lastRefreshAt: 0, lastRefreshResult: null };
+    const app = Fastify({ logger: false });
+    appStates.set(app, state);
+    allStates.add(state);
+    app.addHook("onClose", async () => {
+        appStates.delete(app);
+        allStates.delete(state);
+    });
+    // expose for per-app helpers
+    app._quotacapState = state;
+    app.get("/health", async () => ({ ok: true, uptime: process.uptime(), lastPollAt: state.lastPollAt }));
+    app.get("/api/quotas", async () => {
+        const { getAllLatest } = await import("../store/quotas.js");
+        const quotas = getAllLatest(db);
+        const now = Date.now();
+        return quotas.map((q) => {
+            const fetched = q.fetchedAt ? new Date(q.fetchedAt).getTime() : 0;
+            const ageMs = fetched ? now - fetched : Infinity;
+            const stale = ageMs > 60 * 60 * 1000;
+            return { ...q, stale, ageMs };
+        });
+    });
+    app.get("/api/recommendation", async (req) => {
+        const { getAllLatest } = await import("../store/quotas.js");
+        const quotas = getAllLatest(db);
+        if (!quotas.length) {
+            return { use: "none", reason: "no quotas yet", alternatives: [], advisories: [] };
+        }
+        let recommend;
+        try {
+            recommend = (await import("../advisory/engine.js")).recommend;
+        }
+        catch {
+            return { use: quotas[0]?.provider ?? "none", reason: "advisory not yet implemented", alternatives: quotas };
+        }
+        try {
+            const task = req.query?.task ?? "any";
+            return recommend(quotas, task);
+        }
+        catch (e) {
+            return { use: quotas[0]?.provider ?? "none", reason: `advisory error: ${e?.message ?? String(e)}`, alternatives: quotas };
+        }
+    });
+    app.post("/api/refresh", async () => {
+        const now = Date.now();
+        if (now - state.lastRefreshAt < 60_000 && state.lastRefreshResult) {
+            return state.lastRefreshResult;
+        }
+        try {
+            const { pollOnce } = await import("../daemon.js");
+            const { readConfig } = await import("../config.js");
+            const cfg = await readConfig();
+            const results = await pollOnce(db, cfg.enabledProviders);
+            const fulfilled = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+            const rejected = results.filter((r) => r.status === "rejected").map((r) => ({ provider: r.provider, reason: String(r.reason?.message ?? r.reason) }));
+            state.lastPollAt = new Date().toISOString();
+            state.lastRefreshAt = now;
+            state.lastRefreshResult = { fulfilled, rejected, lastPollAt: state.lastPollAt, results, degraded: rejected.length > 0 };
+            return state.lastRefreshResult;
+        }
+        catch (e) {
+            return { fulfilled: [], rejected: [{ provider: "all", reason: String(e?.message ?? e) }], lastPollAt: state.lastPollAt, degraded: true, error: String(e?.message ?? e) };
+        }
+    });
+    // serve built vite assets at /assets/* (web/dist/assets/*)
+    app.get("/assets/*", async (req, reply) => {
+        const assetPath = req.params["*"] ?? "";
+        // guard path traversal
+        if (assetPath.includes(".."))
+            return reply.status(400).send("bad path");
+        const candidates = [
+            path.join(path.dirname(fileURLToPath(import.meta.url)), "../../web/dist/assets", assetPath),
+            path.join(process.cwd(), "web/dist/assets", assetPath),
+        ];
+        for (const p of candidates) {
+            try {
+                const data = fs.readFileSync(p);
+                const ext = path.extname(p);
+                const type = ext === ".js" ? "application/javascript" : ext === ".css" ? "text/css" : ext === ".map" ? "application/json" : "application/octet-stream";
+                return reply.type(type).send(data);
+            }
+            catch { }
+        }
+        const embedded = webAssets[assetPath];
+        if (embedded !== undefined) {
+            const ext = path.extname(assetPath);
+            const type = ext === ".js" ? "application/javascript" : ext === ".css" ? "text/css" : ext === ".map" ? "application/json" : "application/octet-stream";
+            return reply.type(type).send(embedded);
+        }
+        return reply.status(404).send("not found");
+    });
+    app.get("/", async (_req, reply) => {
+        const candidates = [
+            path.join(path.dirname(fileURLToPath(import.meta.url)), "../../web/dist/index.html"),
+            path.join(path.dirname(fileURLToPath(import.meta.url)), "../../web/index.html"),
+            path.join(process.cwd(), "web/dist/index.html"),
+            path.join(process.cwd(), "web/index.html"),
+        ];
+        for (const p of candidates) {
+            try {
+                const html = fs.readFileSync(p, "utf8");
+                return reply.type("text/html").send(html);
+            }
+            catch { }
+        }
+        return reply.type("text/html").send(webHtml ?? `<!doctype html><title>QuotaCap</title><div id=app>loading…</div>`);
+    });
+    return app;
+}
+export function getLastPollAt(app) {
+    if (app && appStates.has(app))
+        return appStates.get(app).lastPollAt;
+    // fallback: most recent state (for tests without app arg)
+    let last = null;
+    for (const s of allStates)
+        last = s.lastPollAt;
+    return last;
+}
+export function resetRefreshState(app) {
+    if (app && appStates.has(app)) {
+        const s = appStates.get(app);
+        s.lastPollAt = null;
+        s.lastRefreshAt = 0;
+        s.lastRefreshResult = null;
+        return;
+    }
+    for (const s of allStates) {
+        s.lastPollAt = null;
+        s.lastRefreshAt = 0;
+        s.lastRefreshResult = null;
+    }
+}

package/dist/src/mcp/server.d.ts

@@ -0,0 +1,41 @@
+export declare const tools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            task?: undefined;
+            provider?: undefined;
+        };
+        required: never[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            task: {
+                type: string;
+                enum: string[];
+            };
+            provider?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            provider: {
+                type: string;
+            };
+            task?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function handleTool(name: string, args: any): Promise<any>;
+export declare function runMcpServer(): Promise<void>;

package/dist/src/mcp/server.js

@@ -0,0 +1,101 @@
+export const tools = [
+    { name: "get_quotas", description: "All quotas with resets and health", inputSchema: { type: "object", properties: {}, required: [] } },
+    { name: "get_recommendation", description: "Which provider to use next", inputSchema: { type: "object", properties: { task: { type: "string", enum: ["any", "heavy", "light"] } } } },
+    { name: "forecast", description: "Burn vs ideal + waste for a provider", inputSchema: { type: "object", properties: { provider: { type: "string" } }, required: ["provider"] } },
+];
+async function fetchJson(path) {
+    const base = process.env.QUOTACAP_URL ?? "http://localhost:8787";
+    try {
+        const r = await fetch(`${base}${path}`, { signal: AbortSignal.timeout(5000) });
+        if (!r.ok)
+            throw new Error(`HTTP ${r.status}`);
+        return r.json();
+    }
+    catch (e) {
+        // any transport failure (node or bun wording) is a daemon-down situation
+        throw new Error(`daemon not running, run quotacap web — ${e?.message ?? String(e)}`);
+    }
+}
+export async function handleTool(name, args) {
+    if (name === "get_quotas")
+        return fetchJson("/api/quotas");
+    if (name === "get_recommendation")
+        return fetchJson(`/api/recommendation?task=${args?.task ?? "any"}`);
+    if (name === "forecast") {
+        if (!args?.provider)
+            throw new Error("provider required");
+        const [quotas, rec] = await Promise.all([fetchJson("/api/quotas"), fetchJson(`/api/recommendation`)]);
+        const q = quotas.find((x) => x.provider === args.provider);
+        if (!q)
+            throw new Error(`unknown provider ${args.provider}`);
+        return { quota: q, advisory: rec.advisories?.find((a) => a.provider === args.provider) };
+    }
+    throw new Error(`unknown tool ${name}`);
+}
+export async function runMcpServer() {
+    // Minimal MCP JSON-RPC stdio server — handles initialize, tools/list, tools/call, ping
+    const readline = await import("node:readline");
+    const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+    const respond = (id, result) => {
+        process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+    };
+    const error = (id, code, message) => {
+        process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+    };
+    rl.on("line", async (line) => {
+        if (!line.trim())
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const { id, method, params } = msg;
+        // notifications have no id — no response
+        const isNotification = id === undefined;
+        try {
+            if (method === "initialize") {
+                if (!isNotification)
+                    respond(id, { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "quotacap", version: "0.0.1" } });
+            }
+            else if (method === "notifications/initialized") {
+                // no-op
+            }
+            else if (method === "tools/list") {
+                if (!isNotification)
+                    respond(id, { tools });
+            }
+            else if (method === "tools/call") {
+                const toolName = params?.name;
+                const toolArgs = params?.arguments ?? {};
+                try {
+                    const result = await handleTool(toolName, toolArgs);
+                    const content = [{ type: "text", text: JSON.stringify(result, null, 2) }];
+                    if (!isNotification)
+                        respond(id, { content });
+                }
+                catch (e) {
+                    const content = [{ type: "text", text: e?.message ?? String(e) }];
+                    if (!isNotification)
+                        respond(id, { content, isError: true });
+                }
+            }
+            else if (method === "ping") {
+                if (!isNotification)
+                    respond(id, {});
+            }
+            else {
+                if (!isNotification)
+                    error(id, -32601, `Method not found: ${method}`);
+            }
+        }
+        catch (e) {
+            if (!isNotification)
+                error(id, -32603, e?.message ?? String(e));
+        }
+    });
+    // keep alive
+    process.stdin.resume();
+}

package/dist/src/store/db.d.ts

@@ -0,0 +1,2 @@
+export declare function openDb(path: string): any;
+export declare function migrate(db: any): void;

package/dist/src/store/db.js

@@ -0,0 +1,18 @@
+// node:sqlite under node, bun:sqlite under bun — same sync API surface used here.
+// Variable specifier keeps vite/rollup from statically resolving the other runtime's builtin.
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const BUN_SQLITE = "bun:sqlite";
+let SQLite;
+try {
+    SQLite = require("node:sqlite").DatabaseSync;
+}
+catch {
+    SQLite = require(BUN_SQLITE).Database;
+}
+export function openDb(path) { return new SQLite(path); }
+export function migrate(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS quotas(id INTEGER PRIMARY KEY, provider TEXT, plan TEXT, used_pct REAL, resets_at TEXT, period_start TEXT, raw TEXT, source TEXT, fetched_at TEXT);
+           CREATE TABLE IF NOT EXISTS snapshots(day TEXT, provider TEXT, used_pct REAL, burn_rate REAL, ideal_rate REAL, PRIMARY KEY(day, provider));
+           CREATE INDEX IF NOT EXISTS idx_quotas_provider ON quotas(provider);`);
+}

package/dist/src/store/quotas.d.ts

@@ -0,0 +1,5 @@
+export declare function upsertQuota(db: any, q: any): void;
+export declare function getLatestByProvider(db: any, provider: string): any;
+export declare function getAllLatest(db: any): any;
+export declare const getQuotas: typeof getAllLatest;
+export declare function getSnapshots(db: any): any;

package/dist/src/store/quotas.js

@@ -0,0 +1,28 @@
+function mapRow(row) {
+    if (!row)
+        return row;
+    // normalize snake_case DB row to camelCase Quota shape while keeping snake fields for compat
+    return {
+        ...row,
+        usedPct: row.used_pct ?? row.usedPct,
+        resetsAt: row.resets_at ?? row.resetsAt,
+        periodStart: row.period_start ?? row.periodStart,
+        fetchedAt: row.fetched_at ?? row.fetchedAt,
+    };
+}
+export function upsertQuota(db, q) {
+    db.prepare(`INSERT INTO quotas(provider, plan, used_pct, resets_at, period_start, raw, source, fetched_at) VALUES(?,?,?,?,?,?,?,?)`).run(q.provider, q.plan, q.usedPct, q.resetsAt, q.periodStart, q.raw, q.source, q.fetchedAt);
+    const day = new Date().toISOString().slice(0, 10);
+    db.prepare(`INSERT INTO snapshots(day, provider, used_pct) VALUES(?,?,?) ON CONFLICT(day, provider) DO UPDATE SET used_pct=excluded.used_pct`).run(day, q.provider, q.usedPct);
+}
+export function getLatestByProvider(db, provider) {
+    const row = db.prepare(`SELECT * FROM quotas WHERE provider=? ORDER BY fetched_at DESC LIMIT 1`).get(provider);
+    return mapRow(row);
+}
+export function getAllLatest(db) {
+    const rows = db.prepare(`SELECT * FROM quotas WHERE id IN (SELECT MAX(id) FROM quotas GROUP BY provider)`).all();
+    return rows.map(mapRow);
+}
+// alias for plan's getQuotas naming
+export const getQuotas = getAllLatest;
+export function getSnapshots(db) { return db.prepare(`SELECT * FROM snapshots ORDER BY day DESC`).all(); }

package/dist/src/webAssets.d.ts

@@ -0,0 +1 @@
+export declare const webAssets: Record<string, string>;