agy-cli-usage 0.3.1 → 0.4.1

package/{src → dist/src}/credentials.js

@@ -16,12 +16,10 @@
 //                                        and writes the token to a plain-JSON file)
 // If every backend fails, the caller falls back to the PTY path which drives
 // `agy` itself.
-
 import { execFileSync } from 'node:child_process';
 import { readFileSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-
 // OAuth client for the Antigravity CLI. This is an installed/desktop ("public")
 // OAuth client: per Google's own docs the client secret of an installed app is
 // "obviously not treated as a secret" — it ships inside the agy binary and is
@@ -33,55 +31,43 @@ import { join } from 'node:path';
 const OAUTH_CLIENT_ID = '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
 const OAUTH_CLIENT_SECRET = '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';
 const TOKEN_URL = 'https://oauth2.googleapis.com/token';
-
 const KEYRING_SERVICE = 'gemini';
 const KEYRING_ACCOUNT = 'antigravity';
 const B64_PREFIX = 'go-keyring-base64:';
-
-class CredentialError extends Error {}
-
+class CredentialError extends Error {
+}
 // --- raw keyring read --------------------------------------------------------
-
 async function readViaNapiEsm() {
-  try {
-    const mod = await import('@napi-rs/keyring');
-    const Entry = mod.Entry ?? mod.default?.Entry;
-    if (!Entry) return null;
-    return new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT).getPassword();
-  } catch {
-    return null;
-  }
+    try {
+        const { Entry } = await import('@napi-rs/keyring');
+        if (!Entry)
+            return null;
+        return new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT).getPassword() ?? null;
+    }
+    catch {
+        return null;
+    }
 }
-
 function readViaCli() {
-  try {
-    if (process.platform === 'darwin') {
-      return execFileSync(
-        'security',
-        ['find-generic-password', '-s', KEYRING_SERVICE, '-a', KEYRING_ACCOUNT, '-w'],
-        { encoding: 'utf8' },
-      ).trim();
+    try {
+        if (process.platform === 'darwin') {
+            return execFileSync('security', ['find-generic-password', '-s', KEYRING_SERVICE, '-a', KEYRING_ACCOUNT, '-w'], { encoding: 'utf8' }).trim();
+        }
+        if (process.platform === 'linux') {
+            return execFileSync('secret-tool', ['lookup', 'service', KEYRING_SERVICE, 'account', KEYRING_ACCOUNT], { encoding: 'utf8' }).trim();
+        }
     }
-    if (process.platform === 'linux') {
-      return execFileSync(
-        'secret-tool',
-        ['lookup', 'service', KEYRING_SERVICE, 'account', KEYRING_ACCOUNT],
-        { encoding: 'utf8' },
-      ).trim();
+    catch {
+        return null;
     }
-  } catch {
     return null;
-  }
-  return null;
 }
-
 // On Windows, agy stores the token in Credential Manager via Go's
 // zalando/go-keyring, whose target name is `service:account` ("gemini:antigravity").
 // @napi-rs/keyring (keyring-rs) uses a different target format and can't find it,
 // so we read the credential blob directly via the Win32 CredRead API through the
 // built-in powershell.exe (no extra dependency).
 const WIN_CRED_TARGET = `${KEYRING_SERVICE}:${KEYRING_ACCOUNT}`;
-
 const PS_READ_CRED = `$ErrorActionPreference='Stop'
 $sig=@'
 using System;
@@ -112,140 +98,136 @@ Add-Type -TypeDefinition $sig | Out-Null
 $b=[CredApi]::Read('${WIN_CRED_TARGET}')
 if($b -eq $null){ exit 1 }
 [Console]::Out.Write([Convert]::ToBase64String($b))`;
-
 function readViaWindowsCredman() {
-  if (process.platform !== 'win32') return null;
-  try {
-    const encoded = Buffer.from(PS_READ_CRED, 'utf16le').toString('base64');
-    const b64 = execFileSync(
-      'powershell.exe',
-      ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded],
-      { encoding: 'utf8' },
-    ).trim();
-    if (!b64) return null;
-    const raw = Buffer.from(b64, 'base64');
-    // go-keyring writes the value as UTF-8; tolerate UTF-16LE just in case.
-    const utf8 = raw.toString('utf8');
-    const looksValid = (s) => s.startsWith(B64_PREFIX) || s.trimStart().startsWith('{');
-    if (looksValid(utf8)) return utf8;
-    const utf16 = raw.toString('utf16le');
-    if (looksValid(utf16)) return utf16;
-    return utf8;
-  } catch {
-    return null;
-  }
+    if (process.platform !== 'win32')
+        return null;
+    try {
+        const encoded = Buffer.from(PS_READ_CRED, 'utf16le').toString('base64');
+        const b64 = execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], { encoding: 'utf8' }).trim();
+        if (!b64)
+            return null;
+        const raw = Buffer.from(b64, 'base64');
+        // go-keyring writes the value as UTF-8; tolerate UTF-16LE just in case.
+        const utf8 = raw.toString('utf8');
+        const looksValid = (s) => s.startsWith(B64_PREFIX) || s.trimStart().startsWith('{');
+        if (looksValid(utf8))
+            return utf8;
+        const utf16 = raw.toString('utf16le');
+        if (looksValid(utf16))
+            return utf16;
+        return utf8;
+    }
+    catch {
+        return null;
+    }
 }
-
 // On headless Linux (no Secret Service) agy persists the token to a plain-JSON
 // file instead of the keyring. Same payload shape, no `go-keyring-base64:` prefix.
 function readViaFile() {
-  const candidates = [
-    process.env.AGY_OAUTH_TOKEN_FILE,
-    join(homedir(), '.gemini', 'antigravity-cli', 'antigravity-oauth-token'),
-  ].filter(Boolean);
-  for (const path of candidates) {
-    try {
-      if (existsSync(path)) {
-        const content = readFileSync(path, 'utf8').trim();
-        if (content) return content;
-      }
-    } catch {
-      // unreadable (perms) — try next candidate
+    const candidates = [
+        process.env.AGY_OAUTH_TOKEN_FILE,
+        join(homedir(), '.gemini', 'antigravity-cli', 'antigravity-oauth-token'),
+    ].filter((p) => Boolean(p));
+    for (const path of candidates) {
+        try {
+            if (existsSync(path)) {
+                const content = readFileSync(path, 'utf8').trim();
+                if (content)
+                    return content;
+            }
+        }
+        catch {
+            // unreadable (perms) — try next candidate
+        }
     }
-  }
-  return null;
+    return null;
 }
-
 async function readRawSecret() {
-  const fromNapi = await readViaNapiEsm();
-  if (fromNapi) return fromNapi;
-  const fromCli = readViaCli();
-  if (fromCli) return fromCli;
-  const fromWin = readViaWindowsCredman();
-  if (fromWin) return fromWin;
-  const fromFile = readViaFile();
-  if (fromFile) return fromFile;
-  return null;
+    const fromNapi = await readViaNapiEsm();
+    if (fromNapi)
+        return fromNapi;
+    const fromCli = readViaCli();
+    if (fromCli)
+        return fromCli;
+    const fromWin = readViaWindowsCredman();
+    if (fromWin)
+        return fromWin;
+    const fromFile = readViaFile();
+    if (fromFile)
+        return fromFile;
+    return null;
 }
-
 // --- decode ------------------------------------------------------------------
-
 export function decodeSecret(raw) {
-  const payload = raw.startsWith(B64_PREFIX)
-    ? Buffer.from(raw.slice(B64_PREFIX.length), 'base64').toString('utf8')
-    : raw;
-  let parsed;
-  try {
-    parsed = JSON.parse(payload);
-  } catch {
-    throw new CredentialError('Stored agy credential is not valid JSON');
-  }
-  const token = parsed.token ?? parsed;
-  if (!token?.access_token) {
-    throw new CredentialError('Stored agy credential has no access_token');
-  }
-  return {
-    accessToken: token.access_token,
-    refreshToken: token.refresh_token,
-    expiry: token.expiry ? new Date(token.expiry) : null,
-    authMethod: parsed.auth_method ?? null,
-  };
+    const payload = raw.startsWith(B64_PREFIX)
+        ? Buffer.from(raw.slice(B64_PREFIX.length), 'base64').toString('utf8')
+        : raw;
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        throw new CredentialError('Stored agy credential is not valid JSON');
+    }
+    const token = (parsed.token ?? parsed);
+    const accessToken = token.access_token;
+    if (typeof accessToken !== 'string' || !accessToken) {
+        throw new CredentialError('Stored agy credential has no access_token');
+    }
+    const expiry = token.expiry;
+    return {
+        accessToken,
+        refreshToken: typeof token.refresh_token === 'string' ? token.refresh_token : null,
+        expiry: typeof expiry === 'string' ? new Date(expiry) : null,
+        authMethod: typeof parsed.auth_method === 'string' ? parsed.auth_method : null,
+    };
 }
-
 // --- refresh -----------------------------------------------------------------
-
 function isExpired(cred, skewMs = 60_000) {
-  if (!cred.expiry) return false;
-  return cred.expiry.getTime() - Date.now() < skewMs;
+    if (!cred.expiry)
+        return false;
+    return cred.expiry.getTime() - Date.now() < skewMs;
 }
-
 async function refreshAccessToken(refreshToken) {
-  const body = new URLSearchParams({
-    grant_type: 'refresh_token',
-    refresh_token: refreshToken,
-    client_id: OAUTH_CLIENT_ID,
-    client_secret: OAUTH_CLIENT_SECRET,
-  });
-  const res = await fetch(TOKEN_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    body: body.toString(),
-  });
-  if (!res.ok) {
-    throw new CredentialError(`Token refresh failed: HTTP ${res.status} ${await res.text()}`);
-  }
-  const json = await res.json();
-  return json.access_token;
+    const body = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        client_id: OAUTH_CLIENT_ID,
+        client_secret: OAUTH_CLIENT_SECRET,
+    });
+    const res = await fetch(TOKEN_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    if (!res.ok) {
+        throw new CredentialError(`Token refresh failed: HTTP ${res.status} ${await res.text()}`);
+    }
+    const json = (await res.json());
+    return json.access_token;
 }
-
-// --- public API --------------------------------------------------------------
-
 /**
  * Returns a valid access token for the Cloud Code API, refreshing if needed.
  * Throws CredentialError if no credential can be read from any keyring backend
  * (the caller should then consider the PTY fallback).
- * @returns {Promise<{ accessToken: string, authMethod: string|null }>}
  */
 export async function getAccessToken() {
-  const raw = await readRawSecret();
-  if (!raw) {
-    throw new CredentialError(
-      'Could not read agy credential from the OS keyring or token file. ' +
-        'Is agy logged in on this machine? (set AGY_OAUTH_TOKEN_FILE to override the path, ' +
-        'or use --source pty)',
-    );
-  }
-  const cred = decodeSecret(raw);
-  if (isExpired(cred) && cred.refreshToken) {
-    const fresh = await refreshAccessToken(cred.refreshToken);
-    return { accessToken: fresh, authMethod: cred.authMethod };
-  }
-  return { accessToken: cred.accessToken, authMethod: cred.authMethod };
+    const raw = await readRawSecret();
+    if (!raw) {
+        throw new CredentialError('Could not read agy credential from the OS keyring or token file. ' +
+            'Is agy logged in on this machine? (set AGY_OAUTH_TOKEN_FILE to override the path, ' +
+            'or use --source pty)');
+    }
+    const cred = decodeSecret(raw);
+    if (isExpired(cred) && cred.refreshToken) {
+        const fresh = await refreshAccessToken(cred.refreshToken);
+        return { accessToken: fresh, authMethod: cred.authMethod };
+    }
+    return { accessToken: cred.accessToken, authMethod: cred.authMethod };
 }
-
 /** Whether a keyring-based credential is readable at all (no refresh attempted). */
 export async function hasCredential() {
-  return (await readRawSecret()) != null;
+    return (await readRawSecret()) != null;
 }
-
 export { CredentialError };
+//# sourceMappingURL=credentials.js.map

package/dist/src/main.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import type { Snapshot } from './types.js';
+export interface CliOptions {
+    json: boolean;
+    watch: number | null;
+    source: 'auto' | 'api' | 'pty';
+    channel: 'auto' | 'daily' | 'prod';
+    cache: boolean;
+    command: 'update' | null;
+    check: boolean;
+    version?: boolean;
+    help?: boolean;
+}
+/** Subset of options needed to produce a snapshot (also usable from server.ts). */
+export interface SnapshotOptions {
+    source: 'auto' | 'api' | 'pty';
+    channel: 'auto' | 'daily' | 'prod';
+    cache: boolean;
+}
+export declare function getSnapshot(opts: SnapshotOptions): Promise<Snapshot>;

package/dist/src/main.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+// agy-usage — Antigravity CLI (agy) usage/quota monitor.
+//
+// Usage:
+//   agy-usage                 one-shot panel (like agy's /usage)
+//   agy-usage --json          machine-readable JSON
+//   agy-usage --watch [secs]  refresh every N seconds (default 60)
+//   agy-usage --source api|pty|auto   data source (default auto: api, fall back to pty)
+//   agy-usage --channel daily|prod    Cloud Code host (default: auto-detect)
+//   agy-usage --no-cache      bypass the 5-minute cache
+//   agy-usage --refresh       force a fresh fetch (alias for --no-cache)
+//   agy-usage update [--check]  self-update via npm
+//   agy-usage --version | -v  print the installed version
+import { getAccessToken, CredentialError } from './credentials.js';
+import { fetchQuotaSummary } from './api.js';
+import { captureUsageViaPty } from './pty-fallback.js';
+import { fromApi, fromPty } from './quota.js';
+import { renderPanel } from './render.js';
+import { currentVersion, runUpdate } from './update.js';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CACHE_DIR = join(process.env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'agy-usage');
+const CACHE_FILE = join(CACHE_DIR, 'quota.json');
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const errMessage = (e) => (e instanceof Error ? e.message : String(e));
+function parseArgs(argv) {
+    const o = {
+        json: false, watch: null, source: 'auto', channel: 'auto', cache: true, command: null, check: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === 'update' && o.command == null)
+            o.command = 'update';
+        else if (a === '--json')
+            o.json = true;
+        else if (a === '--watch') {
+            const n = Number(argv[i + 1]);
+            if (Number.isFinite(n)) {
+                o.watch = n;
+                i++;
+            }
+            else
+                o.watch = 60;
+        }
+        else if (a === '--source')
+            o.source = (argv[++i] ?? 'auto');
+        else if (a === '--channel')
+            o.channel = (argv[++i] ?? 'auto');
+        else if (a === '--no-cache' || a === '--refresh')
+            o.cache = false;
+        else if (a === '--check')
+            o.check = true;
+        else if (a === '-v' || a === '--version')
+            o.version = true;
+        else if (a === '-h' || a === '--help')
+            o.help = true;
+    }
+    return o;
+}
+const HELP = `agy-usage — Antigravity CLI (agy) usage/quota monitor
+
+  agy-usage                 one-shot panel
+  agy-usage --json          machine-readable JSON
+  agy-usage --watch [secs]  auto-refresh (default 60s)
+  agy-usage --source <auto|api|pty>
+  agy-usage --channel <auto|daily|prod>
+  agy-usage --no-cache | --refresh
+  agy-usage update [--check]  self-update via npm (--check: report only)
+  agy-usage --version | -v
+`;
+// --- cache -------------------------------------------------------------------
+function readCache() {
+    try {
+        const { ts, snap } = JSON.parse(readFileSync(CACHE_FILE, 'utf8'));
+        if (Date.now() - ts < CACHE_TTL_MS)
+            return snap;
+    }
+    catch {
+        /* no/expired cache */
+    }
+    return null;
+}
+function writeCache(snap) {
+    try {
+        mkdirSync(CACHE_DIR, { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), snap }));
+    }
+    catch {
+        /* cache is best-effort */
+    }
+}
+export async function getSnapshot(opts) {
+    if (opts.cache && opts.source !== 'pty') {
+        const cached = readCache();
+        if (cached)
+            return cached;
+    }
+    let snap;
+    if (opts.source === 'pty') {
+        snap = fromPty(await captureUsageViaPty());
+    }
+    else {
+        try {
+            const { accessToken } = await getAccessToken();
+            const raw = await fetchQuotaSummary(accessToken, { channel: opts.channel === 'auto' ? undefined : opts.channel });
+            snap = fromApi(raw);
+        }
+        catch (err) {
+            if (opts.source === 'api')
+                throw err;
+            // auto: fall back to PTY
+            process.stderr.write(`[api failed: ${errMessage(err)}] falling back to PTY (agy)…\n`);
+            snap = fromPty(await captureUsageViaPty());
+        }
+    }
+    writeCache(snap);
+    return snap;
+}
+// --- main --------------------------------------------------------------------
+async function once(opts) {
+    const snap = await getSnapshot(opts);
+    if (opts.json)
+        process.stdout.write(JSON.stringify(snap, null, 2) + '\n');
+    else
+        process.stdout.write(renderPanel(snap) + '\n');
+}
+async function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    if (opts.help) {
+        process.stdout.write(HELP);
+        return;
+    }
+    if (opts.version) {
+        process.stdout.write(currentVersion() + '\n');
+        return;
+    }
+    if (opts.command === 'update') {
+        process.exit(await runUpdate({ checkOnly: opts.check }));
+    }
+    if (opts.watch != null) {
+        const intervalMs = Math.max(5, opts.watch) * 1000;
+        const tick = async () => {
+            try {
+                if (!opts.json)
+                    process.stdout.write('\x1b[2J\x1b[H'); // clear screen
+                await once(opts);
+            }
+            catch (err) {
+                process.stderr.write(`error: ${errMessage(err)}\n`);
+            }
+        };
+        await tick();
+        setInterval(tick, intervalMs);
+    }
+    else {
+        await once(opts);
+    }
+}
+main().catch((err) => {
+    if (err instanceof CredentialError) {
+        process.stderr.write(`credential error: ${err.message}\n`);
+    }
+    else {
+        process.stderr.write(`error: ${errMessage(err)}\n`);
+    }
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map

package/dist/src/pty-fallback.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedPanel } from './types.js';
+/** Parse the reconstructed /usage screen text into { account, groups:[...] }. */
+export declare function parsePanel(text: string): ParsedPanel;
+/** Run agy, capture /usage, reconstruct + parse the panel. */
+export declare function captureUsageViaPty(): Promise<ParsedPanel>;