agy-cli-usage 0.3.1 → 0.4.1

package/dist/src/pty-fallback.js

@@ -0,0 +1,221 @@
+// Fallback path: drive the real `agy` TUI in a pseudo-terminal, send `/usage`,
+// reconstruct the rendered screen with a headless VT emulator, and parse the
+// panel. Used only when the direct API path is unavailable (no readable
+// keyring, or the internal API changed). Slower and more brittle than the API
+// path, but uses agy's own auth so it works wherever agy itself works.
+//
+// Why a VT emulator: agy renders /usage in the alternate screen buffer using
+// cursor addressing, so naive ANSI-stripping yields nothing. We feed the raw
+// PTY bytes through @xterm/headless to get the final visible screen, then parse.
+//
+// Capture backend: python3 `pty` on POSIX (no native build), node-pty on
+// Windows (ConPTY). agy shows a welcome screen first, so `/usage` is sent after
+// a delay and the session is held open long enough to render.
+import { spawn } from 'node:child_process';
+import { writeFileSync, readFileSync, mkdtempSync, existsSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import { join, delimiter } from 'node:path';
+// Resolve the agy binary: explicit AGY_BIN, then PATH, then common install dir.
+function resolveAgy() {
+    const explicit = process.env.AGY_BIN;
+    if (explicit)
+        return explicit;
+    const exe = process.platform === 'win32' ? 'agy.exe' : 'agy';
+    for (const dir of (process.env.PATH || '').split(delimiter)) {
+        if (dir && existsSync(join(dir, exe)))
+            return join(dir, exe);
+    }
+    const local = join(homedir(), '.local', 'bin', exe);
+    if (existsSync(local))
+        return local;
+    return 'agy'; // last resort: let the OS resolve it
+}
+const AGY_BIN = resolveAgy();
+const COLS = 120;
+const ROWS = 60;
+const USAGE_AT_MS = 10_000; // send /usage after the welcome screen settles
+const TEARDOWN_MS = 23_000; // keep session open long enough to render
+// --- capture: returns raw PTY bytes (Buffer) or null --------------------------
+async function captureViaNodePty() {
+    // node-pty is an optional dependency; defeat static module resolution so the
+    // build doesn't require it (CI installs with --omit=optional).
+    const moduleName = 'node-pty';
+    let pty;
+    try {
+        pty = await import(moduleName);
+    }
+    catch {
+        return null;
+    }
+    return new Promise((resolve) => {
+        let term;
+        try {
+            term = pty.spawn(AGY_BIN, [], { name: 'xterm-256color', cols: COLS, rows: ROWS, cwd: process.cwd(), env: process.env });
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        const chunks = [];
+        term.onData((d) => chunks.push(Buffer.from(d, 'utf8')));
+        const t1 = setTimeout(() => { try {
+            term.write('/usage\r');
+        }
+        catch { /* ignore */ } }, USAGE_AT_MS);
+        const t2 = setTimeout(() => {
+            try {
+                term.write('\x03');
+            }
+            catch { /* ignore */ }
+            try {
+                term.kill();
+            }
+            catch { /* ignore */ }
+            resolve(Buffer.concat(chunks));
+        }, TEARDOWN_MS);
+        term.onExit(() => { clearTimeout(t1); clearTimeout(t2); resolve(Buffer.concat(chunks)); });
+    });
+}
+async function captureViaPython() {
+    if (process.platform === 'win32')
+        return null;
+    const dir = mkdtempSync(join(tmpdir(), 'agy-usage-'));
+    const helper = join(dir, 'drive.py');
+    const outFile = join(dir, 'out.bin');
+    writeFileSync(helper, `import os, pty, time, select, signal, struct, fcntl, termios
+AGY = ${JSON.stringify(AGY_BIN)}
+out = open(${JSON.stringify(outFile)}, "wb")
+pid, fd = pty.fork()
+if pid == 0:
+    os.execvpe(AGY, [AGY], os.environ)
+    os._exit(127)
+fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", ${ROWS}, ${COLS}, 0, 0))
+start = time.time(); sent = False
+while time.time() - start < ${TEARDOWN_MS / 1000}:
+    e = time.time() - start
+    r, _, _ = select.select([fd], [], [], 0.5)
+    if r:
+        try: d = os.read(fd, 8192)
+        except OSError: break
+        if not d: break
+        out.write(d); out.flush()
+    if not sent and e > ${USAGE_AT_MS / 1000}:
+        os.write(fd, b"/usage\\r"); sent = True
+try: os.write(fd, b"\\x03")
+except OSError: pass
+try: os.kill(pid, signal.SIGTERM)
+except Exception: pass
+out.close()
+`);
+    return new Promise((resolve) => {
+        const proc = spawn('python3', [helper], { stdio: 'ignore' });
+        proc.on('error', () => resolve(null));
+        proc.on('exit', () => {
+            try {
+                resolve(readFileSync(outFile));
+            }
+            catch {
+                resolve(null);
+            }
+        });
+    });
+}
+// --- VT reconstruction --------------------------------------------------------
+async function reconstructScreen(raw) {
+    const { Terminal } = await import('@xterm/headless');
+    const term = new Terminal({ cols: COLS, rows: ROWS, allowProposedApi: true, scrollback: 200 });
+    await new Promise((res) => term.write(raw, res));
+    const buf = term.buffer.active;
+    const lines = [];
+    // include scrollback so a panel taller than the viewport is still captured
+    for (let i = 0; i < buf.length; i++) {
+        const line = buf.getLine(i);
+        if (line)
+            lines.push(line.translateToString(true).replace(/\s+$/, ''));
+    }
+    term.dispose();
+    return lines.join('\n');
+}
+// --- parse --------------------------------------------------------------------
+function parseDuration(text) {
+    let seconds = 0;
+    const d = text.match(/(\d+)\s*day/i);
+    const h = text.match(/(\d+)\s*h(?:our)?/i);
+    const m = text.match(/(\d+)\s*m(?:in)?/i);
+    if (d)
+        seconds += +d[1] * 86400;
+    if (h)
+        seconds += +h[1] * 3600;
+    if (m)
+        seconds += +m[1] * 60;
+    return seconds || null;
+}
+/** Parse the reconstructed /usage screen text into { account, groups:[...] }. */
+export function parsePanel(text) {
+    const lines = text.split(/\r?\n/);
+    const account = text.match(/Account:\s*(\S+)/)?.[1] ?? null;
+    const groups = [];
+    let group = null;
+    let bucket = null;
+    const pushBucket = () => { if (group && bucket)
+        group.buckets.push(bucket); bucket = null; };
+    const pushGroup = () => { pushBucket(); if (group)
+        groups.push(group); group = null; };
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        if (/^[A-Z][A-Z0-9 &/]*MODELS$/.test(t)) {
+            pushGroup();
+            group = { name: t.replace(/\s+/g, ' '), models: '', buckets: [] };
+            continue;
+        }
+        const models = t.match(/^Models within this group:\s*(.+)$/i);
+        if (models && group) {
+            group.models = models[1].trim();
+            continue;
+        }
+        if (/^(Weekly Limit|Five Hour Limit|5[- ]?Hour Limit)$/i.test(t)) {
+            pushBucket();
+            const kind = /week/i.test(t) ? 'weekly' : '5h';
+            bucket = { kind, label: t, remainingFraction: null, resetsInSeconds: null, available: false, description: null };
+            continue;
+        }
+        if (bucket) {
+            const pct = t.match(/(\d+(?:\.\d+)?)\s*%/);
+            if (pct && bucket.remainingFraction == null)
+                bucket.remainingFraction = +pct[1] / 100;
+            if (/Quota available/i.test(t)) {
+                bucket.available = true;
+                bucket.remainingFraction = 1;
+            }
+            const refresh = t.match(/Refreshes in (.+)$/i);
+            if (refresh)
+                bucket.resetsInSeconds = parseDuration(refresh[1]);
+        }
+    }
+    pushGroup();
+    return { account, groups };
+}
+/** Run agy, capture /usage, reconstruct + parse the panel. */
+export async function captureUsageViaPty() {
+    const order = process.platform === 'win32'
+        ? [captureViaNodePty, captureViaPython]
+        : [captureViaPython, captureViaNodePty];
+    let raw = null;
+    for (const fn of order) {
+        raw = await fn();
+        if (raw && raw.length)
+            break;
+    }
+    if (!raw || !raw.length) {
+        throw new Error('No PTY backend captured agy output (need python3 on POSIX, or node-pty on Windows)');
+    }
+    const screen = await reconstructScreen(raw);
+    const parsed = parsePanel(screen);
+    if (!parsed.groups.length) {
+        throw new Error('Could not parse /usage panel from agy output');
+    }
+    return parsed;
+}
+//# sourceMappingURL=pty-fallback.js.map

package/dist/src/quota.d.ts

@@ -0,0 +1,7 @@
+import type { FetchResult, ParsedPanel, Snapshot } from './types.js';
+/** Build a normalized snapshot from the raw retrieveUserQuotaSummary response. */
+export declare function fromApi({ raw, host, account, tier }: FetchResult, nowMs?: number): Snapshot;
+/** Build a normalized snapshot from PTY-parsed groups (see pty-fallback.ts). */
+export declare function fromPty(parsed: ParsedPanel, nowMs?: number): Snapshot;
+/** Format a seconds duration like agy: "73h 53m" / "2h 7m" / "12m". */
+export declare function formatDuration(seconds: number | null): string | null;

package/dist/src/quota.js

@@ -0,0 +1,81 @@
+// Normalizes quota data from either source (direct API JSON or PTY-parsed text)
+// into one shape consumed by the renderer / JSON output / HTTP endpoint.
+function bucketKind(window, label) {
+    if (window === 'weekly' || /week/i.test(label))
+        return 'weekly';
+    if (window === '5h' || /5.?hour|five.?hour/i.test(label))
+        return '5h';
+    return window || label;
+}
+function secondsUntil(resetAt, now) {
+    if (!resetAt)
+        return null;
+    const ms = new Date(resetAt).getTime() - now;
+    return Number.isFinite(ms) ? Math.max(0, Math.round(ms / 1000)) : null;
+}
+/** Build a normalized snapshot from the raw retrieveUserQuotaSummary response. */
+export function fromApi({ raw, host, account, tier }, nowMs = Date.now()) {
+    const groups = (raw.groups ?? []).map((g) => ({
+        name: g.displayName ?? 'Models',
+        models: (g.description ?? '').replace(/^Models within this group:\s*/i, '').trim(),
+        buckets: (g.buckets ?? []).map((b) => {
+            const remaining = typeof b.remainingFraction === 'number' ? b.remainingFraction : null;
+            return {
+                kind: bucketKind(b.window, b.displayName ?? ''),
+                label: b.displayName ?? b.window ?? '',
+                remainingFraction: remaining,
+                usedFraction: remaining == null ? null : 1 - remaining,
+                resetAt: b.resetTime ?? null,
+                resetsInSeconds: secondsUntil(b.resetTime, nowMs),
+                available: remaining === 1,
+                description: b.description ?? null,
+            };
+        }),
+    }));
+    return {
+        account: account ?? null,
+        tier: tier ?? null,
+        fetchedAt: new Date(nowMs).toISOString(),
+        source: 'api',
+        host: host ?? null,
+        note: raw.description ?? null,
+        groups,
+    };
+}
+/** Build a normalized snapshot from PTY-parsed groups (see pty-fallback.ts). */
+export function fromPty(parsed, nowMs = Date.now()) {
+    const groups = (parsed.groups ?? []).map((g) => ({
+        name: g.name,
+        models: g.models ?? '',
+        buckets: (g.buckets ?? []).map((b) => ({
+            kind: b.kind,
+            label: b.label,
+            remainingFraction: b.remainingFraction ?? null,
+            usedFraction: b.remainingFraction == null ? null : 1 - b.remainingFraction,
+            resetAt: b.resetsInSeconds != null ? new Date(nowMs + b.resetsInSeconds * 1000).toISOString() : null,
+            resetsInSeconds: b.resetsInSeconds ?? null,
+            available: b.available ?? b.remainingFraction === 1,
+            description: b.description ?? null,
+        })),
+    }));
+    return {
+        account: parsed.account ?? null,
+        tier: null,
+        fetchedAt: new Date(nowMs).toISOString(),
+        source: 'pty',
+        host: null,
+        note: parsed.note ?? null,
+        groups,
+    };
+}
+/** Format a seconds duration like agy: "73h 53m" / "2h 7m" / "12m". */
+export function formatDuration(seconds) {
+    if (seconds == null)
+        return null;
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    if (h > 0)
+        return `${h}h ${m}m`;
+    return `${m}m`;
+}
+//# sourceMappingURL=quota.js.map

package/dist/src/render.d.ts

@@ -0,0 +1,3 @@
+import type { Snapshot } from './types.js';
+/** Returns the full panel as a string. */
+export declare function renderPanel(snap: Snapshot): string;

package/dist/src/render.js

@@ -0,0 +1,82 @@
+// Renders a normalized quota snapshot as a terminal panel, mirroring agy's
+// `/usage` layout (progress bar + percent + reset time per bucket).
+import { formatDuration } from './quota.js';
+const BAR_WIDTH = 50;
+const useColor = () => Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const c = (code, s) => (useColor() ? `\x1b[${code}m${s}\x1b[0m` : s);
+const dim = (s) => c('2', s);
+const bold = (s) => c('1', s);
+// remaining-based color: lots left = green, getting low = yellow/red.
+function barColor(remaining) {
+    if (remaining == null)
+        return '37';
+    if (remaining > 0.5)
+        return '32'; // green
+    if (remaining > 0.2)
+        return '33'; // yellow
+    return '31'; // red
+}
+function bar(remainingFraction) {
+    const frac = remainingFraction == null ? 0 : Math.max(0, Math.min(1, remainingFraction));
+    const filled = Math.round(frac * BAR_WIDTH);
+    const body = '█'.repeat(filled) + '░'.repeat(BAR_WIDTH - filled);
+    return useColor() ? `\x1b[${barColor(remainingFraction)}m${body}\x1b[0m` : body;
+}
+function bucketLine(b) {
+    const lines = [];
+    lines.push(`    ${bold(b.label)}`);
+    if (b.available) {
+        lines.push(`    [${bar(1)}] ${c('32', 'Quota available')}`);
+    }
+    else {
+        const pct = b.remainingFraction == null ? '—' : `${(b.remainingFraction * 100).toFixed(2)}%`;
+        const remainPct = b.remainingFraction == null ? '' : `${Math.round(b.remainingFraction * 100)}% remaining`;
+        const dur = formatDuration(b.resetsInSeconds);
+        const reset = dur ? ` · ${dim(`Refreshes in ${dur}`)}` : '';
+        lines.push(`    [${bar(b.remainingFraction)}] ${pct}`);
+        lines.push(`    ${dim(remainPct)}${reset}`);
+    }
+    return lines.join('\n');
+}
+/** Returns the full panel as a string. */
+export function renderPanel(snap) {
+    const out = [];
+    out.push('');
+    out.push(bold('  Models & Quota'));
+    if (snap.account)
+        out.push(`  ${dim('Account:')} ${snap.account}`);
+    out.push(`  ${dim(`source: ${snap.source}${snap.host ? ` · ${snap.host}` : ''} · ${snap.fetchedAt}`)}`);
+    out.push('');
+    for (const g of snap.groups) {
+        out.push(bold(`  ${g.name.toUpperCase()}`));
+        if (g.models)
+            out.push(`  ${dim(`Models within this group: ${g.models}`)}`);
+        out.push('');
+        for (const b of g.buckets) {
+            out.push(bucketLine(b));
+            out.push('');
+        }
+    }
+    if (snap.note) {
+        out.push(dim(wrap(snap.note, 76, '  │')));
+    }
+    return out.join('\n');
+}
+function wrap(text, width, prefix) {
+    const words = text.split(/\s+/);
+    const lines = [];
+    let cur = '';
+    for (const w of words) {
+        if ((cur + ' ' + w).trim().length > width) {
+            lines.push(prefix + cur);
+            cur = w;
+        }
+        else {
+            cur = (cur + ' ' + w).trim();
+        }
+    }
+    if (cur)
+        lines.push(prefix + cur);
+    return lines.join('\n');
+}
+//# sourceMappingURL=render.js.map

package/dist/src/server.d.ts

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

package/dist/src/server.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// Optional lightweight HTTP endpoint for dashboard integration.
+// Serves the normalized quota snapshot as JSON, going through the same 5-minute
+// cache as the CLI so polling clients never hammer the upstream API.
+//
+//   PORT=3007 node dist/src/server.js
+//   GET /quota   -> normalized snapshot JSON
+//   GET /healthz -> { ok: true }
+import { createServer } from 'node:http';
+import { getSnapshot } from './main.js';
+const PORT = Number(process.env.PORT) || 3007;
+const HOST = process.env.HOST || '127.0.0.1';
+const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+    if (url.pathname === '/healthz') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+        return;
+    }
+    if (url.pathname === '/quota') {
+        try {
+            const noCache = url.searchParams.get('refresh') === '1';
+            const snap = await getSnapshot({ source: 'auto', channel: 'auto', cache: !noCache });
+            res.writeHead(200, {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*',
+                'Cache-Control': 'public, max-age=300',
+            });
+            res.end(JSON.stringify(snap));
+        }
+        catch (err) {
+            res.writeHead(502, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+        }
+        return;
+    }
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'not found' }));
+});
+server.listen(PORT, HOST, () => {
+    process.stdout.write(`agy-usage server on http://${HOST}:${PORT}  (GET /quota)\n`);
+});
+//# sourceMappingURL=server.js.map

package/dist/src/types.d.ts

@@ -0,0 +1,67 @@
+export type BucketKind = 'weekly' | '5h' | string;
+export interface RawBucket {
+    bucketId?: string;
+    displayName?: string;
+    window?: string;
+    resetTime?: string;
+    description?: string;
+    remainingFraction?: number;
+}
+export interface RawGroup {
+    displayName?: string;
+    description?: string;
+    buckets?: RawBucket[];
+}
+export interface RawQuotaResponse {
+    groups?: RawGroup[];
+    description?: string;
+}
+/** Result of api.fetchQuotaSummary. */
+export interface FetchResult {
+    raw: RawQuotaResponse;
+    host: string | null;
+    account: string | null;
+    tier: string | null;
+}
+export interface ParsedBucket {
+    kind: BucketKind;
+    label: string;
+    remainingFraction: number | null;
+    resetsInSeconds: number | null;
+    available: boolean;
+    description: string | null;
+}
+export interface ParsedGroup {
+    name: string;
+    models: string;
+    buckets: ParsedBucket[];
+}
+export interface ParsedPanel {
+    account: string | null;
+    groups: ParsedGroup[];
+    note?: string | null;
+}
+export interface Bucket {
+    kind: BucketKind;
+    label: string;
+    remainingFraction: number | null;
+    usedFraction: number | null;
+    resetAt: string | null;
+    resetsInSeconds: number | null;
+    available: boolean;
+    description: string | null;
+}
+export interface Group {
+    name: string;
+    models: string;
+    buckets: Bucket[];
+}
+export interface Snapshot {
+    account: string | null;
+    tier: string | null;
+    fetchedAt: string;
+    source: 'api' | 'pty';
+    host: string | null;
+    note: string | null;
+    groups: Group[];
+}

package/dist/src/types.js

@@ -0,0 +1,3 @@
+// Shared types for agy-cli-usage.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/update.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Installed version, read from this package's package.json.
+ * NOTE: this module compiles to dist/src/update.js, so package.json (at the
+ * package root) is two levels up.
+ */
+export declare function currentVersion(): string;
+/**
+ * Compare two dotted versions numerically (prerelease tags ignored).
+ * Returns negative if a<b, 0 if equal, positive if a>b.
+ */
+export declare function semverCompare(a: string, b: string): number;
+/** Latest published version: prefer the user's configured registry (npm view), fall back to public. */
+export declare function latestVersion(): Promise<string | null>;
+/** Run the update flow. Returns the intended process exit code. */
+export declare function runUpdate({ checkOnly }?: {
+    checkOnly?: boolean;
+}): Promise<number>;

package/dist/src/update.js

@@ -0,0 +1,87 @@
+// Self-update + version helpers for the CLI.
+//
+// `agy-cli-usage update`        check the registry and `npm install -g` if newer
+// `agy-cli-usage update --check` report only, don't install
+// `agy-cli-usage --version`     print the installed version
+import { execFileSync, spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+const PKG_NAME = 'agy-cli-usage';
+/**
+ * Installed version, read from this package's package.json.
+ * NOTE: this module compiles to dist/src/update.js, so package.json (at the
+ * package root) is two levels up.
+ */
+export function currentVersion() {
+    const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    return pkg.version;
+}
+/**
+ * Compare two dotted versions numerically (prerelease tags ignored).
+ * Returns negative if a<b, 0 if equal, positive if a>b.
+ */
+export function semverCompare(a, b) {
+    const norm = (v) => String(v)
+        .replace(/^v/, '')
+        .split('-')[0]
+        .split('.')
+        .map((n) => parseInt(n, 10) || 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;
+}
+/** Latest published version: prefer the user's configured registry (npm view), fall back to public. */
+export async function latestVersion() {
+    try {
+        const out = execFileSync('npm', ['view', PKG_NAME, 'version'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (out)
+            return out;
+    }
+    catch {
+        // npm missing or offline — try the public registry directly
+    }
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${PKG_NAME}/latest`);
+        if (res.ok)
+            return (await res.json()).version;
+    }
+    catch {
+        // offline
+    }
+    return null;
+}
+/** Run the update flow. Returns the intended process exit code. */
+export async function runUpdate({ checkOnly = false } = {}) {
+    const current = currentVersion();
+    const latest = await latestVersion();
+    if (!latest) {
+        process.stderr.write('Could not determine the latest version (offline or npm unavailable).\n');
+        return 1;
+    }
+    if (semverCompare(latest, current) <= 0) {
+        process.stdout.write(`agy-cli-usage is up to date (${current}).\n`);
+        return 0;
+    }
+    process.stdout.write(`Update available: ${current} -> ${latest}\n`);
+    if (checkOnly) {
+        process.stdout.write('Run `agy-cli-usage update` to install it.\n');
+        return 0;
+    }
+    process.stdout.write(`Installing ${PKG_NAME}@${latest} globally…\n`);
+    const r = spawnSync('npm', ['install', '-g', `${PKG_NAME}@${latest}`], { stdio: 'inherit' });
+    if (r.error) {
+        process.stderr.write(`Failed to run npm: ${r.error.message}\nInstall manually: npm install -g ${PKG_NAME}@latest\n`);
+        return 1;
+    }
+    if (r.status === 0)
+        process.stdout.write(`Updated to ${latest}.\n`);
+    return r.status ?? 0;
+}
+//# sourceMappingURL=update.js.map

package/package.json

@@ -1,24 +1,28 @@
 {
   "name": "agy-cli-usage",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Headless usage/quota monitor for the Antigravity CLI (agy) — reads Cloud Code quota directly, with a PTY fallback. No IDE required.",
   "type": "module",
+  "types": "dist/src/main.d.ts",
   "bin": {
-    "agy-cli-usage": "src/main.js",
-    "agy-usage": "src/main.js"
+    "agy-cli-usage": "dist/src/main.js",
+    "agy-usage": "dist/src/main.js"
   },
   "scripts": {
-    "start": "node src/main.js",
-    "serve": "node server.js",
-    "test": "node --test",
-    "check": "node --check src/main.js && node --check server.js"
+    "build": "tsc",
+    "check": "tsc --noEmit",
+    "pretest": "tsc",
+    "test": "node --test dist/test/unit.test.js",
+    "start": "tsc && node dist/src/main.js",
+    "serve": "tsc && node dist/src/server.js",
+    "prepack": "tsc"
   },
   "engines": {
     "node": ">=18"
   },
   "files": [
-    "src/",
-    "server.js",
+    "dist/src/**/*.js",
+    "dist/src/**/*.d.ts",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
@@ -49,5 +53,9 @@
   "optionalDependencies": {
     "node-pty": "^1.0.0"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "typescript": "^6.0.3"
+  }
 }