@prohost/cli 0.8.3 → 0.10.0

package/dist/usage/service.js

@@ -0,0 +1,299 @@
+/**
+ * The `prohost usage start` loop: every five minutes, report each login's
+ * remaining capacity and upload the token totals that changed.
+ *
+ * Built to run unattended for weeks. Nothing in a tick can throw out of it:
+ * a missing key, an unreachable server, a 404 from a server that doesn't have
+ * the routes yet, a probe that hangs — each is logged once, backed off
+ * (see `backoff.ts`), and the loop carries on.
+ */
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadAccounts, machineId as machineIdFor } from '../agent/accounts.js';
+import { postJson } from '../agent/api.js';
+import { Backoff } from './backoff.js';
+import { resolveUsageKey, usageStateDir, writePrivateFile } from './config.js';
+import { accountConfigDir } from './discovery.js';
+import { buildReportFrame, defaultProber, probeAccounts } from './quota.js';
+import { batches, loadScanState, pendingKey, rowsForPending, saveScanState, scanUsage } from './scanner.js';
+export const REPORTS_PATH = '/v1/usage/reports';
+export const TOKEN_TOTALS_PATH = '/v1/usage/token-totals';
+/** Tick cadence. */
+export const USAGE_INTERVAL_MS = 5 * 60_000;
+/** Partial uploads of one day's rows for one account before they are given up on. */
+export const MAX_PARTIAL_STRIKES = 3;
+/** Skips that will never turn into an acceptance from this machine. */
+const PERMANENT_SKIPS = new Set(['not_owned', 'other_source', 'out_of_range']);
+/** Read `{accepted, acceptedAccountKeys?, skipped?}` from a 2xx body. */
+export function parseAcceptance(body, sent) {
+    let parsed = {};
+    try {
+        parsed = JSON.parse(body ?? '');
+    }
+    catch {
+        /* fall through */
+    }
+    const accepted = typeof parsed?.accepted === 'number' && Number.isFinite(parsed.accepted) ? parsed.accepted : sent;
+    const keys = Array.isArray(parsed?.acceptedAccountKeys)
+        ? new Set(parsed.acceptedAccountKeys.filter((k) => typeof k === 'string'))
+        : undefined;
+    let skipped;
+    if (Array.isArray(parsed?.skipped)) {
+        skipped = new Map();
+        for (const entry of parsed.skipped) {
+            const item = entry;
+            if (typeof item?.accountKey === 'string') {
+                skipped.set(item.accountKey, typeof item.reason === 'string' ? item.reason : 'unknown');
+            }
+        }
+    }
+    return { accepted, ...(keys ? { keys } : {}), ...(skipped ? { skipped } : {}) };
+}
+export function scanStatePath(env = process.env) {
+    return path.join(usageStateDir(env), 'scan.json');
+}
+export function statusPath(env = process.env) {
+    return path.join(usageStateDir(env), 'status.json');
+}
+export function loadStatus(env = process.env) {
+    try {
+        const parsed = JSON.parse(readFileSync(statusPath(env), 'utf8'));
+        return {
+            version: 1,
+            pid: parsed.pid,
+            lastTickAt: parsed.lastTickAt,
+            lastReport: parsed.lastReport,
+            lastTotals: parsed.lastTotals,
+            accounts: parsed.accounts && typeof parsed.accounts === 'object' ? parsed.accounts : {},
+        };
+    }
+    catch {
+        return { version: 1, accounts: {} };
+    }
+}
+/** One process's reporter. Holds the backoff state and the scan cursor in memory. */
+export class UsageService {
+    options;
+    env;
+    log;
+    now;
+    prober;
+    reportBackoff;
+    totalsBackoff;
+    scan;
+    status;
+    warned = new Set();
+    /**
+     * Accounts whose report the server has accepted from this process. The
+     * server takes token totals only for accounts this machine has already
+     * reported (and skips the rest), so totals for any other account wait —
+     * which also makes the first tick, and the tick after a login is
+     * discovered, report before it uploads. Kept in memory only: a restart
+     * always reports first anyway.
+     */
+    reportedKeys = new Set();
+    constructor(options = {}) {
+        this.options = options;
+        this.env = options.env ?? process.env;
+        this.log = options.log ?? ((line) => process.stdout.write(`${new Date().toISOString()} ${line}\n`));
+        this.now = options.now ?? Date.now;
+        this.prober = options.prober ?? defaultProber();
+        this.reportBackoff = new Backoff('usage report', this.now);
+        this.totalsBackoff = new Backoff('token totals', this.now);
+        this.status = loadStatus(this.env);
+    }
+    warnOnce(key, line) {
+        if (this.warned.has(key))
+            return;
+        this.warned.add(key);
+        this.log(line);
+    }
+    /** One full pass. Never throws. */
+    async tick() {
+        const result = { reported: false, uploadedRows: 0 };
+        try {
+            const key = resolveUsageKey(this.env);
+            if (!key) {
+                this.warnOnce('no_key', 'Not connected — run `prohost usage connect --key <api key>`. Checking again each tick.');
+                return { ...result, skipped: 'no_key' };
+            }
+            this.warned.delete('no_key');
+            const machineId = machineIdFor(this.env);
+            if (!machineId) {
+                this.warnOnce('no_machine_id', 'Could not create this machine\'s id in the accounts root; nothing can be reported.');
+                return { ...result, skipped: 'no_machine_id' };
+            }
+            const api = { baseUrl: key.baseUrl, apiKey: key.apiKey, fetchImpl: this.options.fetchImpl };
+            const machine = this.options.machine ?? os.hostname();
+            const records = loadAccounts(this.env);
+            // Forget what was learned about logins that have since been removed.
+            const live = new Set(records.map((r) => r.key));
+            for (const key of Object.keys(this.status.accounts))
+                if (!live.has(key))
+                    delete this.status.accounts[key];
+            // ── Capacity ──────────────────────────────────────────────────────
+            await probeAccounts(records, this.status.accounts, { prober: this.prober, now: this.now });
+            if (this.reportBackoff.ready() && records.length > 0) {
+                const { frame, omitted } = buildReportFrame({ machineId, machine, records, cache: this.status.accounts });
+                if (omitted > 0)
+                    this.warnOnce('omitted', `${omitted} account(s) beyond the ${frame.accounts.length} a report carries were left out.`);
+                const response = await postJson(api, REPORTS_PATH, frame, undefined, true);
+                this.note(this.reportBackoff, response);
+                const sent = frame.accounts.map((a) => a.accountKey);
+                const acceptance = response.ok ? parseAcceptance(response.body, sent.length) : { accepted: 0 };
+                this.status.lastReport = { ...this.callRecord(response, sent.length), accepted: acceptance.accepted };
+                result.reported = response.ok && acceptance.accepted > 0;
+                if (acceptance.keys) {
+                    // The server named the accounts it took (another teammate's login
+                    // on this machine, say, is not among them): exactly those. A
+                    // throttled one was taken before and still counts as it did.
+                    for (const key of sent) {
+                        const reason = acceptance.skipped?.get(key);
+                        if (acceptance.keys.has(key))
+                            this.reportedKeys.add(key);
+                        else if (reason !== 'throttled')
+                            this.reportedKeys.delete(key);
+                        if (reason && PERMANENT_SKIPS.has(reason)) {
+                            this.warnOnce(`report_skip:${key}:${reason}`, `usage report: account ${key.slice(0, 8)}… skipped (${reason}); its usage belongs to another user or source.`);
+                        }
+                    }
+                }
+                else if (acceptance.accepted > 0) {
+                    // A count alone can't say which. Treat every account as reported
+                    // and let the token-totals endpoint skip the ones it doesn't know —
+                    // requiring all of them would starve every login on a machine that
+                    // holds one the server will never take. 0 is the server's "too soon
+                    // after the last frame" answer and reports nothing.
+                    for (const key of sent)
+                        this.reportedKeys.add(key);
+                }
+            }
+            // ── Token totals ─────────────────────────────────────────────────
+            this.scan ??= loadScanState(scanStatePath(this.env));
+            const scanned = scanUsage(records.map((r) => ({ key: r.key, runtime: r.runtime, dir: accountConfigDir(r, this.env) })), this.scan, { now: this.now(), timeZone: this.options.timeZone });
+            // The state can run to megabytes; rewrite it only when a file was read.
+            if (scanned.filesRead > 0)
+                saveScanState(scanStatePath(this.env), this.scan);
+            if (this.totalsBackoff.ready() && this.scan.dirty.length > 0) {
+                result.uploadedRows = await this.uploadDirty(api, machineId, machine);
+            }
+        }
+        catch (err) {
+            this.log(`usage tick failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            this.status.lastTickAt = new Date(this.now()).toISOString();
+            this.status.pid = process.pid;
+            try {
+                writePrivateFile(statusPath(this.env), `${JSON.stringify(this.status, null, 2)}\n`);
+            }
+            catch {
+                /* status is informational */
+            }
+        }
+        return result;
+    }
+    /**
+     * Upload pending (day, account) rows in batches, for reported accounts only.
+     *
+     * A pair is done once the server takes it (its account is in
+     * `acceptedAccountKeys`, or — from an older server that only counts — its
+     * whole batch was accepted). A skip with a reason is handled by reason:
+     * `not_owned` / `other_source` / `out_of_range` will never be accepted, so
+     * the pair is done (logged once); `throttled` is retried next tick as is;
+     * `not_reported` waits for the next accepted report. Any other skip, and
+     * `not_reported`, costs a strike; after {@link MAX_PARTIAL_STRIKES} the pair
+     * is given up on (logged once), so nothing is resent forever. Pairs whose
+     * account has never been reported wait without a strike, and are not sent.
+     */
+    async uploadDirty(api, machineId, machine) {
+        const scan = this.scan;
+        const rows = rowsForPending(scan, scan.dirty);
+        const ready = rows.filter((r) => this.reportedKeys.has(r.accountKey));
+        const done = new Set();
+        const pendingWithRows = new Set(rows.map((r) => pendingKey(r.day, r.accountKey)));
+        // Pending pairs with nothing to send (all-zero) are simply done.
+        for (const pair of scan.dirty)
+            if (!pendingWithRows.has(pair))
+                done.add(pair);
+        let sent = 0;
+        let gaveUp = 0;
+        for (const batch of batches(ready)) {
+            const response = await postJson(api, TOKEN_TOTALS_PATH, { machineId, machine, days: batch }, undefined, true);
+            this.note(this.totalsBackoff, response);
+            const acceptance = response.ok ? parseAcceptance(response.body, batch.length) : { accepted: 0 };
+            this.status.lastTotals = { ...this.callRecord(response, batch.length), accepted: acceptance.accepted };
+            if (!response.ok)
+                break;
+            sent += acceptance.accepted;
+            const pairs = new Map(); // pair → accountKey
+            for (const row of batch)
+                pairs.set(pendingKey(row.day, row.accountKey), row.accountKey);
+            for (const [pair, accountKey] of pairs) {
+                const taken = acceptance.keys ? acceptance.keys.has(accountKey) : acceptance.accepted >= batch.length;
+                if (taken) {
+                    done.add(pair);
+                    delete scan.strikes[pair];
+                    continue;
+                }
+                const reason = acceptance.skipped?.get(accountKey);
+                if (reason === 'throttled')
+                    continue; // pending as is; next tick
+                if (reason && PERMANENT_SKIPS.has(reason)) {
+                    done.add(pair);
+                    delete scan.strikes[pair];
+                    this.warnOnce(`totals_skip:${accountKey}:${reason}`, `token totals: account ${accountKey.slice(0, 8)}… skipped (${reason}); those rows will not be resent.`);
+                    continue;
+                }
+                // `not_reported`, or skipped without a reason: report it again first.
+                this.reportedKeys.delete(accountKey);
+                const strikes = (scan.strikes[pair] ?? 0) + 1;
+                if (strikes >= MAX_PARTIAL_STRIKES) {
+                    done.add(pair);
+                    delete scan.strikes[pair];
+                    gaveUp += 1;
+                }
+                else {
+                    scan.strikes[pair] = strikes;
+                }
+            }
+        }
+        if (gaveUp > 0) {
+            this.warnOnce('gave_up', `token totals: the server skipped some rows ${MAX_PARTIAL_STRIKES} times in a row (a login it doesn't ` +
+                'attribute to this key, most likely); they are no longer resent.');
+        }
+        scan.dirty = scan.dirty.filter((pair) => !done.has(pair));
+        saveScanState(scanStatePath(this.env), scan);
+        return sent;
+    }
+    note(backoff, response) {
+        const line = backoff.record(response);
+        if (line)
+            this.log(line);
+    }
+    callRecord(response, count) {
+        return { at: new Date(this.now()).toISOString(), ok: response.ok, status: response.status, count };
+    }
+}
+/** Sleep that ends early on abort. */
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve();
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', done);
+            resolve();
+        }
+        signal?.addEventListener('abort', done, { once: true });
+    });
+}
+/** Tick until aborted. */
+export async function runUsageLoop(service, options = {}) {
+    while (!options.signal?.aborted) {
+        await service.tick();
+        await sleep(options.intervalMs ?? USAGE_INTERVAL_MS, options.signal);
+    }
+}

package/dist/version.d.ts

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export declare const CLI_VERSION = "0.8.3";
+export declare const CLI_VERSION = "0.10.0";
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
-export declare const USER_AGENT = "prohost-cli/0.8.3";
+export declare const USER_AGENT = "prohost-cli/0.10.0";

package/dist/version.js

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export const CLI_VERSION = '0.8.3';
+export const CLI_VERSION = '0.10.0';
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
 export const USER_AGENT = `prohost-cli/${CLI_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prohost/cli",
-  "version": "0.8.3",
+  "version": "0.10.0",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",