quotacap 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Carlos Boeing
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# QuotaCap
+
+**Cross-harness AI quota dashboard + harness-callable advice.**
+
+One place to see how much of each AI subscription you've used. Shows when it resets and what to burn next. Goal is 100% use at reset.
+
+Polls pluggable adapters (Claude, Codex, Gemini, Kimi, Grok, OpenCode). Stores history in SQLite. Serves:
+
+* **Web dashboard** at `http://localhost:8787` — banner + 7-day strip + table with burn vs ideal. Includes stale badges and degraded banner.
+* **CLI** `quotacap` / `npx quotacap` — `status`, `advise --json`, `ingest`, `web`, `init`, `daemon`
+* **MCP server** — `get_quotas`, `get_recommendation`, `forecast` for any harness
+
+Runs local-only by default. No prompts or file contents leave your machine.
+
+## Install
+
+```bash
+# Binary — no Node needed (macOS + Linux, arm64/x64)
+curl -fsSL https://raw.githubusercontent.com/carlosboeing/quotacap/main/install.sh | sh
+
+# Or via npm (requires Node 22.13+; node:sqlite needs --experimental-sqlite before 22.13)
+npm install -g quotacap   # global install
+npx quotacap              # run without install
+```
+
+The binary is a self-contained Bun-compiled executable from GitHub Releases.
+The npm package runs the same CLI on Node. Both put `quotacap` on your PATH.
+
+## Quick start
+
+```bash
+quotacap init
+quotacap ingest --provider kimi --text "Current week: 22% used · resets Aug 29 at 11am"
+quotacap status --json
+quotacap web                          # http://localhost:8787
+quotacap advise --json                # tries HTTP, falls back to local DB
+quotacap advise --json --task heavy
+```
+
+## HTTP API
+
+```bash
+curl http://localhost:8787/health
+curl http://localhost:8787/api/quotas
+curl "http://localhost:8787/api/recommendation?task=any"
+curl -X POST http://localhost:8787/api/refresh
+```
+
+* `GET /health` → `{ok, uptime, lastPollAt}`
+* `GET /api/quotas` → `Quota[]` with `stale`, `ageMs`
+* `GET /api/recommendation?task=any` → `{use, reason, advisories}`
+* `POST /api/refresh` → `{fulfilled, rejected, lastPollAt, degraded}` — debounced 60s, always 200
+* `GET /` → `web/dist/index.html` if built, else `web/index.html`
+
+## CLI
+
+```
+quotacap status [--json]
+quotacap advise [--json] [--task any|heavy|light]
+quotacap ingest --provider <id> --text "..."
+quotacap web [--port 8787]
+quotacap daemon [--foreground]
+quotacap init
+```
+
+`advise` fetches `http://localhost:$port/api/recommendation` with 2s timeout. Falls back to local `recommend()` when daemon is down.
+
+## MCP
+
+```json
+{
+  "mcpServers": {
+    "quotacap": { "command": "quotacap", "args": ["mcp"] }
+  }
+}
+```
+
+Use `"command": "npx", "args": ["quotacap", "mcp"]` when installed via npm only.
+Tools: `get_quotas`, `get_recommendation`, `forecast`. Wrapper over HTTP. Set `QUOTACAP_URL` to override.
+
+## How it works
+
+```
+Adapters (claude-cli ✓, manual ✓, others → manual-paste)
+  → daemon (poll 15m + jitter, SQLite ~/.quotacap/quotacap.db)
+  → HTTP :8787
+  → dashboard + CLI + MCP (same handler)
+```
+
+Adapters are isolated. One failure does not block others. Uses `Promise.allSettled` and per-adapter catch. `POST /api/refresh` always 200.
+
+## Config
+
+`~/.quotacap/config.json`:
+
+```json
+{ "port": 8787, "pollMinutes": 15, "enabledProviders": ["claude"] }
+```
+
+DB is `~/.quotacap/quotacap.db` (`quotas`, `snapshots`).
+
+## Development
+
+```bash
+npm test              # vitest run (10 files) — builds first via pretest
+bun test tests/bun/   # bun-runtime tests (sqlite adapter, MCP translation)
+npm run build         # vite build → embed web assets → tsc → flatten dist → chmod bin
+npm run build:bin     # bun build --compile (current platform, or pass targets)
+npx tsc --noEmit
+```
+
+The `store/db.ts` adapter picks `node:sqlite` on Node and `bun:sqlite` on Bun, so
+the same code runs as an npm package and as a compiled binary.
+
+See `.workbench/2-design/2026-08-28-quotacap-design.md` for spec. See `docs/ROADMAP.md` for next steps.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/adapters/claude.d.ts

@@ -0,0 +1,7 @@
+import type { Quota } from "./types.js";
+export declare function parseClaudeUsage(result: string, now?: Date): Quota;
+export declare const claudeAdapter: {
+    id: string;
+    requiresAuth: string;
+    poll(): Promise<Quota>;
+};

package/dist/adapters/claude.js

@@ -0,0 +1,78 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { parse, isValid } from "date-fns";
+import { fromZonedTime, formatInTimeZone } from "date-fns-tz";
+const exec = promisify(execFile);
+const BRISBANE_TZ = "Australia/Brisbane";
+const RESET_FORMATS = [
+    "MMM d 'at' h:mma yyyy",
+    "MMM d 'at' ha yyyy",
+    "MMM d 'at' h:mm a yyyy",
+    "MMM d 'at' h a yyyy",
+];
+function tryParseWithYear(raw, year) {
+    const withYear = `${raw.trim()} ${year}`;
+    const normalized = withYear.replace(/([ap]m)\b/gi, (m) => m.toUpperCase());
+    for (const fmt of RESET_FORMATS) {
+        const d = parse(normalized, fmt, new Date());
+        if (isValid(d)) {
+            return fromZonedTime(d, BRISBANE_TZ);
+        }
+    }
+    return null;
+}
+function parseBrisbaneReset(resetsRaw, now) {
+    const trimmed = resetsRaw.trim();
+    if (!trimmed)
+        return null;
+    const yearStr = formatInTimeZone(now, BRISBANE_TZ, "yyyy");
+    const year = parseInt(yearStr, 10);
+    let utc = tryParseWithYear(trimmed, year);
+    if (!utc)
+        return null;
+    if (utc.getTime() < now.getTime()) {
+        const utcNext = tryParseWithYear(trimmed, year + 1);
+        if (utcNext) {
+            const diff = utcNext.getTime() - now.getTime();
+            if (diff >= 0 && diff < 8 * 86400000) {
+                utc = utcNext;
+            }
+            else {
+                // stale / out-of-range (e.g. monthly-plan string) — fallback to now+7d
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+        // if utc was past and no valid next-year within window, treat as stale
+        if (utc.getTime() < now.getTime())
+            return null;
+    }
+    return formatInTimeZone(utc, BRISBANE_TZ, "yyyy-MM-dd'T'HH:mm:ssXXX");
+}
+export function parseClaudeUsage(result, now = new Date()) {
+    const sessionMatch = result.match(/Current session:\s+(\d+)% used[^·]*·\s*resets\s+([^\n(]+?)\s*\(/);
+    const weeklyMatch = result.match(/Current week \(all models\):\s+(\d+)% used[^·]*·\s*resets\s+([^\n(]+?)\s*\(/);
+    const usedPct = weeklyMatch ? parseInt(weeklyMatch[1], 10) : 0;
+    const sessionPct = sessionMatch ? parseInt(sessionMatch[1], 10) : undefined;
+    const resetsRaw = weeklyMatch?.[2].trim() ?? "";
+    let resetsAt = parseBrisbaneReset(resetsRaw, now);
+    if (!resetsAt)
+        resetsAt = new Date(now.getTime() + 7 * 86400000).toISOString();
+    return {
+        provider: "claude", plan: "max", usedPct, sessionPct,
+        resetsAt, periodStart: new Date(now.getTime() - 7 * 86400000).toISOString(),
+        raw: result, source: "cli", fetchedAt: now.toISOString()
+    };
+}
+export const claudeAdapter = {
+    id: "claude",
+    requiresAuth: "keychain:Claude Code-credentials",
+    async poll() {
+        const { stdout } = await exec("claude", ["-p", "/usage", "--output-format", "json"], { timeout: 8000 });
+        const parsed = JSON.parse(stdout);
+        const result = parsed.result ?? stdout;
+        return parseClaudeUsage(result);
+    }
+};

package/dist/adapters/index.d.ts

@@ -0,0 +1,18 @@
+import type { Adapter } from "./types.js";
+export declare const adapters: Record<string, Adapter>;
+export declare function pollAll(enabled: string[]): Promise<({
+    provider: string;
+    status: "fulfilled";
+    value: import("./types.js").Quota;
+    reason?: undefined;
+} | {
+    provider: string;
+    status: "skipped";
+    reason: any;
+    value?: undefined;
+} | {
+    provider: string;
+    status: "rejected";
+    reason: any;
+    value?: undefined;
+})[]>;

package/dist/adapters/index.js

@@ -0,0 +1,33 @@
+import { claudeAdapter } from "./claude.js";
+import { manualAdapter } from "./manual.js";
+export const adapters = {
+    claude: claudeAdapter,
+    manual: manualAdapter,
+};
+function withTimeout(p, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+        Promise.resolve(p).then((v) => { clearTimeout(timer); resolve(v); }, (e) => { clearTimeout(timer); reject(e); });
+    });
+}
+export async function pollAll(enabled) {
+    const rawJobs = enabled.map(id => {
+        const a = adapters[id];
+        if (!a)
+            return Promise.reject(new Error(`unknown adapter ${id}`));
+        // manual adapter has no poll capability — skip without degraded
+        if (id === "manual")
+            return Promise.reject(new Error("manual skipped — use ingest"));
+        return withTimeout(a.poll(), 8000);
+    });
+    const settled = await Promise.allSettled(rawJobs);
+    return settled.map((s, i) => {
+        const id = enabled[i];
+        if (s.status === "fulfilled")
+            return { provider: id, status: "fulfilled", value: s.value };
+        const msg = String(s.reason?.message ?? s.reason);
+        if (msg.includes("manual skipped"))
+            return { provider: id, status: "skipped", reason: s.reason };
+        return { provider: id, status: "rejected", reason: s.reason };
+    });
+}

package/dist/adapters/manual.d.ts

@@ -0,0 +1,8 @@
+import type { Quota } from "./types.js";
+export declare function parseManualUsage(provider: string, text: string, now?: Date): Quota;
+export declare const manualAdapter: {
+    id: string;
+    requiresAuth: string;
+    ingest(provider: string, text: string): Promise<Quota>;
+    poll(): Promise<Quota>;
+};

package/dist/adapters/manual.js

@@ -0,0 +1,25 @@
+export function parseManualUsage(provider, text, now = new Date()) {
+    const m = text.match(/(\d+)% used/);
+    const usedPct = m ? parseInt(m[1], 10) : 0;
+    const resetsAt = new Date(now.getTime() + 3 * 86400000).toISOString();
+    return {
+        provider,
+        plan: "unknown",
+        usedPct,
+        resetsAt,
+        periodStart: new Date(now.getTime() - 7 * 86400000).toISOString(),
+        raw: text,
+        source: "manual",
+        fetchedAt: now.toISOString(),
+    };
+}
+export const manualAdapter = {
+    id: "manual",
+    requiresAuth: "none",
+    async ingest(provider, text) {
+        return parseManualUsage(provider, text);
+    },
+    async poll() {
+        throw new Error("manual has no poll — use ingest");
+    },
+};

package/dist/adapters/types.d.ts

@@ -0,0 +1,17 @@
+export interface Quota {
+    provider: string;
+    plan: string;
+    usedPct: number;
+    sessionPct?: number;
+    resetsAt: string;
+    periodStart: string;
+    raw: string;
+    source: "cli" | "api" | "scrape" | "manual";
+    fetchedAt: string;
+}
+export interface Adapter {
+    id: string;
+    requiresAuth: string;
+    poll(): Promise<Quota>;
+}
+export declare const UNIMPLEMENTED: (id: string) => Error;

package/dist/adapters/types.js

@@ -0,0 +1 @@
+export const UNIMPLEMENTED = (id) => new Error(`${id} adapter not implemented — use manual-paste`);

package/dist/advisory/engine.d.ts

@@ -0,0 +1,11 @@
+import type { Quota } from "../adapters/types.js";
+import type { Advisory } from "./types.js";
+export declare function computeAdvisory(q: Quota, burnRate: number, now?: Date): Advisory;
+export declare function recommend(quotas: Quota[], _task: string, burnByProvider?: Map<string, number>, now?: Date): {
+    use: string;
+    reason: string;
+    wastePct: number;
+    idealRate: number;
+    alternatives: Quota[];
+    advisories: Advisory[];
+};

package/dist/advisory/engine.js

@@ -0,0 +1,26 @@
+export function computeAdvisory(q, burnRate, now = new Date()) {
+    const resets = new Date(q.resetsAt);
+    const daysLeft = Math.max(0.1, (resets.getTime() - now.getTime()) / 86400000);
+    const remaining = 100 - q.usedPct;
+    const idealRate = remaining / daysLeft;
+    const wastePct = Math.max(0, remaining - burnRate * daysLeft);
+    let urgency = "on track";
+    if (wastePct > 30 && daysLeft < 3)
+        urgency = "burn now";
+    else if (wastePct > 20 && daysLeft < 7)
+        urgency = "use soon";
+    else if (burnRate > idealRate * 1.4)
+        urgency = "slow down";
+    else if (wastePct > 10)
+        urgency = "save";
+    return { provider: q.provider, daysLeft, remaining, idealRate, burnRate, wastePct, urgency };
+}
+export function recommend(quotas, _task, burnByProvider = new Map(), now = new Date()) {
+    if (!quotas.length)
+        return { use: "none", reason: "no quotas yet", wastePct: 0, idealRate: 0, alternatives: [], advisories: [] };
+    const advisories = quotas.map(q => computeAdvisory(q, burnByProvider.get(q.provider) ?? 2, now));
+    const burnNow = advisories.filter(a => a.urgency === "burn now");
+    const pool = burnNow.length ? burnNow : advisories;
+    const use = pool.sort((a, b) => b.wastePct - a.wastePct)[0];
+    return { use: use.provider, reason: `${Math.round(use.wastePct)}% waste in ${use.daysLeft.toFixed(1)}d`, wastePct: use.wastePct, idealRate: use.idealRate, alternatives: quotas, advisories };
+}

package/dist/advisory/types.d.ts

@@ -0,0 +1,10 @@
+export type Urgency = "burn now" | "use soon" | "slow down" | "save" | "on track";
+export interface Advisory {
+    provider: string;
+    daysLeft: number;
+    remaining: number;
+    idealRate: number;
+    burnRate: number;
+    wastePct: number;
+    urgency: Urgency;
+}

package/dist/advisory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import { buildApp } from "../http/server.js";
+import { openDb, migrate } from "../store/db.js";
+import { getDbPath, readConfig } from "../config.js";
+function ensureDbDir() { try {
+    fs.mkdirSync(path.dirname(getDbPath()), { recursive: true });
+}
+catch { } }
+const program = new Command();
+program.name("quotacap").version("0.0.1");
+program.command("status").option("--json", "json").action(async (opts) => {
+    ensureDbDir();
+    const db = openDb(getDbPath());
+    migrate(db);
+    const { getAllLatest } = await import("../store/quotas.js");
+    const quotas = getAllLatest(db);
+    if (opts.json)
+        console.log(JSON.stringify(quotas, null, 2));
+    else
+        console.table(quotas);
+});
+program.command("advise").option("--json", "json").option("--task <t>", "task", "any").action(async (opts) => {
+    ensureDbDir();
+    const db = openDb(getDbPath());
+    migrate(db);
+    try {
+        const r = await fetch(`http://localhost:${(await readConfig()).port}/api/recommendation?task=${opts.task}`, { signal: AbortSignal.timeout(2000) });
+        const j = await r.json();
+        console.log(opts.json ? JSON.stringify(j, null, 2) : `${j.use}: ${j.reason}`);
+    }
+    catch {
+        const { recommend } = await import("../advisory/engine.js");
+        const { getAllLatest } = await import("../store/quotas.js");
+        const quotas = getAllLatest(db);
+        if (!quotas.length) {
+            console.log(opts.json ? JSON.stringify({ use: "none", reason: "no quotas yet" }, null, 2) : "none: no quotas yet");
+            return;
+        }
+        const rec = recommend(quotas, opts.task);
+        console.log(opts.json ? JSON.stringify(rec, null, 2) : `${rec.use}: ${rec.reason}`);
+    }
+});
+program.command("ingest").requiredOption("--provider <p>").requiredOption("--text <t>").action(async (o) => {
+    ensureDbDir();
+    const db = openDb(getDbPath());
+    migrate(db);
+    const { parseManualUsage } = await import("../adapters/manual.js");
+    const { upsertQuota } = await import("../store/quotas.js");
+    upsertQuota(db, parseManualUsage(o.provider, o.text));
+    console.log("ingested");
+});
+program.command("web").option("--port <n>").action(async (o) => {
+    ensureDbDir();
+    const db = openDb(getDbPath());
+    migrate(db);
+    const app = buildApp(db);
+    const port = o.port ? parseInt(o.port) : (await readConfig()).port;
+    await app.listen({ port, host: "127.0.0.1" });
+    console.log(`QuotaCap at http://localhost:${port}`);
+});
+program.command("init").action(async () => {
+    const { readConfig, writeConfig } = await import("../config.js");
+    const c = await readConfig();
+    await writeConfig(c);
+    console.log(JSON.stringify(c, null, 2));
+});
+program.command("daemon").option("--foreground", "keep foreground (default: true)").action(async (o) => {
+    const { startDaemon } = await import("../daemon.js");
+    const { timer } = await startDaemon();
+    console.log("QuotaCap daemon started" + (o.foreground !== false ? " (foreground)" : ""));
+    // keep alive until SIGINT/SIGTERM — timer is ref'd so event loop stays alive
+    process.on("SIGINT", () => { clearInterval(timer); process.exit(0); });
+    process.on("SIGTERM", () => { clearInterval(timer); process.exit(0); });
+    // explicitly keep process alive if interval was somehow unref'd elsewhere
+    if (timer.ref)
+        timer.ref();
+});
+program.command("mcp").description("start MCP server (stdio over HTTP)").action(async () => {
+    const mod = await import("../mcp/server.js");
+    // if run with --help, commander handles it before action; this is the real server
+    await mod.runMcpServer();
+});
+program.parseAsync();

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare function getConfigPath(p?: string): string;
+export declare function getDbPath(p?: string): string;
+declare const ConfigSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    pollMinutes: z.ZodDefault<z.ZodNumber>;
+    enabledProviders: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    pollMinutes: number;
+    enabledProviders: string[];
+}, {
+    port?: number | undefined;
+    pollMinutes?: number | undefined;
+    enabledProviders?: string[] | undefined;
+}>;
+export type Config = z.infer<typeof ConfigSchema>;
+export declare function readConfig(p?: string): Promise<Config>;
+export declare function writeConfig(c: Config, p?: string): Promise<void>;
+export {};

package/dist/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/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/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/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;