@clearlysh/beehaven 0.8.16

package/dist/commands/costs.js

@@ -0,0 +1,443 @@
+/**
+ * beehaven costs — Cloudflare cost report
+ *
+ * Queries CF GraphQL Analytics API and estimates monthly costs.
+ * Uses wrangler OAuth token for auth.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { color } from '../spinner.js';
+// CF Pricing (Workers Paid — $5/mo base)
+const PRICING = {
+    workerRequests: { included: 10_000_000, perMillion: 0.3 },
+    doRequests: { included: 1_000_000, perMillion: 0.15 },
+    doDurationGBs: { included: 400_000, perGBs: 12.5 },
+    r2StorageGB: { included: 10, perGB: 0.015 },
+    r2ClassA: { included: 1_000_000, perMillion: 4.5 },
+    r2ClassB: { included: 10_000_000, perMillion: 0.36 },
+    baseFee: 5.0,
+};
+function findWranglerToken() {
+    // macOS
+    const macPath = join(homedir(), 'Library/Preferences/.wrangler/config/default.toml');
+    // Linux/Windows
+    const linuxPath = join(homedir(), '.wrangler/config/default.toml');
+    const configPath = existsSync(macPath) ? macPath : existsSync(linuxPath) ? linuxPath : null;
+    if (!configPath)
+        return null;
+    const toml = readFileSync(configPath, 'utf-8');
+    const match = toml.match(/oauth_token\s*=\s*"([^"]+)"/);
+    return match?.[1] ?? null;
+}
+async function getAccountId(token) {
+    const res = await fetch('https://api.cloudflare.com/client/v4/accounts?page=1&per_page=1', {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    const json = (await res.json());
+    if (!json.result?.[0]?.id)
+        throw new Error('Could not determine account ID. Run: wrangler login');
+    return json.result[0].id;
+}
+async function gql(token, accountId, query) {
+    const res = await fetch('https://api.cloudflare.com/client/v4/graphql', {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query: query.replace(/\$ACCOUNT/g, accountId) }),
+    });
+    const json = (await res.json());
+    if (json.errors?.length)
+        throw new Error(json.errors.map((e) => e.message).join('; '));
+    return json.data.viewer.accounts[0];
+}
+function overage(usage, tier) {
+    const over = Math.max(0, usage - tier.included);
+    if (tier.perMillion)
+        return (over / 1_000_000) * tier.perMillion;
+    if (tier.perGB)
+        return over * tier.perGB;
+    if (tier.perGBs)
+        return over * tier.perGBs;
+    return 0;
+}
+function fmt(n) {
+    if (n >= 1_000_000)
+        return (n / 1_000_000).toFixed(2) + 'M';
+    if (n >= 1_000)
+        return (n / 1_000).toFixed(1) + 'K';
+    return n.toFixed(0);
+}
+function fmtBytes(bytes) {
+    if (bytes >= 1_073_741_824)
+        return (bytes / 1_073_741_824).toFixed(2) + ' GB';
+    if (bytes >= 1_048_576)
+        return (bytes / 1_048_576).toFixed(1) + ' MB';
+    if (bytes >= 1_024)
+        return (bytes / 1_024).toFixed(1) + ' KB';
+    return bytes + ' B';
+}
+function fmtUs(us) {
+    if (us < 1000)
+        return us + 'µs';
+    if (us < 1_000_000)
+        return (us / 1000).toFixed(1) + 'ms';
+    return (us / 1_000_000).toFixed(1) + 's';
+}
+function fmtDollars(n) {
+    return n < 0.01 && n > 0 ? '<$0.01' : '$' + n.toFixed(2);
+}
+function pad(s, len, right = false) {
+    return right ? s.padStart(len) : s.padEnd(len);
+}
+function table(headers, rows, aligns) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || '').length)));
+    const a = aligns || headers.map(() => false);
+    const sep = widths.map((w) => '─'.repeat(w + 2)).join('┼');
+    const line = (cells) => cells.map((c, i) => ' ' + pad(c, widths[i], a[i]) + ' ').join('│');
+    return [line(headers), sep, ...rows.map((r) => line(r))].join('\n');
+}
+export async function costs(opts = {}) {
+    const days = opts.days ?? 30;
+    // ── Per-action / per-conversation modes — read from the connected DO
+    //    instead of Cloudflare GraphQL. These dispatch to a convention
+    //    admin action the app implements against ActionCostLedger.
+    if (opts.perAction || opts.perConversation) {
+        return perCallReport(days, opts);
+    }
+    const token = findWranglerToken();
+    if (!token) {
+        console.error(color.red('✗') + ' Wrangler not authenticated. Run: wrangler login');
+        return;
+    }
+    const accountId = await getAccountId(token);
+    const now = new Date();
+    const from = new Date(now.getTime() - days * 86400_000);
+    const dateFrom = from.toISOString().split('.')[0] + 'Z';
+    const dateTo = now.toISOString().split('.')[0] + 'Z';
+    const proj = 30 / days;
+    console.log('');
+    console.log(`  ${color.bold('Cloudflare Cost Report')}`);
+    console.log(`  ${from.toISOString().split('T')[0]} → ${now.toISOString().split('T')[0]} (${days} days)`);
+    // Fetch all analytics in parallel
+    const [workers, dos, r2Ops, r2Storage] = await Promise.all([
+        gql(token, accountId, `{
+      viewer { accounts(filter: {accountTag: "$ACCOUNT"}) {
+        workersInvocationsAdaptive(limit: 20, filter: {
+          datetime_geq: "${dateFrom}", datetime_leq: "${dateTo}"
+        }, orderBy: [sum_requests_DESC]) {
+          sum { requests subrequests responseBodySize }
+          quantiles { cpuTimeP50 cpuTimeP99 }
+          dimensions { scriptName status }
+        }
+      }}
+    }`),
+        gql(token, accountId, `{
+      viewer { accounts(filter: {accountTag: "$ACCOUNT"}) {
+        durableObjectsInvocationsAdaptiveGroups(limit: 20, filter: {
+          datetime_geq: "${dateFrom}", datetime_leq: "${dateTo}"
+        }, orderBy: [sum_requests_DESC]) {
+          sum { requests wallTime }
+          quantiles { wallTimeP50 wallTimeP99 }
+          dimensions { scriptName }
+        }
+      }}
+    }`),
+        gql(token, accountId, `{
+      viewer { accounts(filter: {accountTag: "$ACCOUNT"}) {
+        r2OperationsAdaptiveGroups(limit: 30, filter: {
+          datetime_geq: "${dateFrom}", datetime_leq: "${dateTo}"
+        }, orderBy: [sum_requests_DESC]) {
+          sum { requests responseObjectSize }
+          dimensions { bucketName actionType }
+        }
+      }}
+    }`),
+        gql(token, accountId, `{
+      viewer { accounts(filter: {accountTag: "$ACCOUNT"}) {
+        r2StorageAdaptiveGroups(limit: 10, filter: {
+          datetime_geq: "${dateTo.split('T')[0]}T00:00:00Z",
+          datetime_leq: "${dateTo}"
+        }) {
+          max { objectCount payloadSize metadataSize }
+          dimensions { bucketName }
+        }
+      }}
+    }`),
+    ]);
+    // ── Workers ─────────────────────────────────────────
+    const byScript = new Map();
+    for (const r of workers.workersInvocationsAdaptive || []) {
+        const name = r.dimensions.scriptName;
+        const prev = byScript.get(name) || {
+            requests: 0,
+            subrequests: 0,
+            cpuP50: 0,
+            cpuP99: 0,
+            bytes: 0,
+        };
+        prev.requests += r.sum.requests;
+        prev.subrequests += r.sum.subrequests;
+        prev.cpuP50 = Math.max(prev.cpuP50, r.quantiles.cpuTimeP50);
+        prev.cpuP99 = Math.max(prev.cpuP99, r.quantiles.cpuTimeP99);
+        prev.bytes += r.sum.responseBodySize;
+        byScript.set(name, prev);
+    }
+    const totalWorkerReqs = [...byScript.values()].reduce((s, v) => s + v.requests, 0);
+    console.log('');
+    console.log('  ' + color.bold('Workers'));
+    console.log('  ' +
+        table(['Script', 'Requests', 'Subreqs', 'CPU p50', 'CPU p99', 'Egress'], [...byScript.entries()]
+            .sort((a, b) => b[1].requests - a[1].requests)
+            .map(([name, v]) => [
+            name === '__unknown__' ? '(deleted)' : name,
+            fmt(v.requests),
+            fmt(v.subrequests),
+            fmtUs(v.cpuP50),
+            fmtUs(v.cpuP99),
+            fmtBytes(v.bytes),
+        ]), [false, true, true, true, true, true])
+            .split('\n')
+            .join('\n  '));
+    // ── Durable Objects ─────────────────────────────────
+    const doRows = (dos.durableObjectsInvocationsAdaptiveGroups || []).map((r) => ({
+        name: r.dimensions.scriptName,
+        requests: r.sum.requests,
+        wallTimeUs: r.sum.wallTime,
+        p50Us: r.quantiles.wallTimeP50,
+        p99Us: r.quantiles.wallTimeP99,
+    }));
+    const totalDoReqs = doRows.reduce((s, r) => s + r.requests, 0);
+    // Hibernatable DOs: estimate active time from requests × p50 (not raw wallTime which includes WS idle)
+    const estActiveUs = doRows.reduce((s, r) => s + r.requests * r.p50Us, 0);
+    const estActiveSec = estActiveUs / 1_000_000;
+    const doGBs = estActiveSec * 0.128; // 128MB minimum per DO
+    console.log('');
+    console.log('  ' + color.bold('Durable Objects') + color.dim(' (hibernatable — billing excludes WS idle)'));
+    console.log('  ' +
+        table(['Script', 'Requests', 'p50', 'p99', 'Est. Active'], doRows
+            .sort((a, b) => b.requests - a.requests)
+            .map((r) => {
+            const sec = (r.requests * r.p50Us) / 1_000_000;
+            return [
+                r.name,
+                fmt(r.requests),
+                fmtUs(r.p50Us),
+                fmtUs(r.p99Us),
+                sec < 60 ? sec.toFixed(1) + 's' : (sec / 60).toFixed(1) + 'min',
+            ];
+        }), [false, true, true, true, true])
+            .split('\n')
+            .join('\n  '));
+    // ── R2 ──────────────────────────────────────────────
+    const classAOps = new Set([
+        'PutObject',
+        'ListObjects',
+        'DeleteObject',
+        'DeleteObjects',
+        'PutBucket',
+        'ListMultipartUploads',
+        'ListBuckets',
+    ]);
+    let totalClassA = 0, totalClassB = 0;
+    const r2Buckets = new Map();
+    for (const r of r2Ops.r2OperationsAdaptiveGroups || []) {
+        const bucket = r.dimensions.bucketName || '(global)';
+        const prev = r2Buckets.get(bucket) || { classA: 0, classB: 0, egress: 0 };
+        if (classAOps.has(r.dimensions.actionType)) {
+            prev.classA += r.sum.requests;
+            totalClassA += r.sum.requests;
+        }
+        else {
+            prev.classB += r.sum.requests;
+            totalClassB += r.sum.requests;
+        }
+        prev.egress += r.sum.responseObjectSize || 0;
+        r2Buckets.set(bucket, prev);
+    }
+    let totalR2Bytes = 0;
+    const r2Sizes = new Map();
+    for (const r of r2Storage.r2StorageAdaptiveGroups || []) {
+        const bytes = r.max.payloadSize + r.max.metadataSize;
+        totalR2Bytes += bytes;
+        r2Sizes.set(r.dimensions.bucketName, { objects: r.max.objectCount, bytes });
+    }
+    console.log('');
+    console.log('  ' + color.bold('R2 Storage'));
+    console.log('  ' +
+        table(['Bucket', 'Objects', 'Size', 'Writes', 'Reads', 'Egress'], [...r2Sizes.entries()]
+            .sort((a, b) => b[1].bytes - a[1].bytes)
+            .map(([name, s]) => {
+            const ops = r2Buckets.get(name) || { classA: 0, classB: 0, egress: 0 };
+            return [
+                name,
+                fmt(s.objects),
+                fmtBytes(s.bytes),
+                fmt(ops.classA),
+                fmt(ops.classB),
+                fmtBytes(ops.egress),
+            ];
+        }), [false, true, true, true, true, true])
+            .split('\n')
+            .join('\n  '));
+    // ── Cost Summary ────────────────────────────────────
+    const wCost = overage(totalWorkerReqs * proj, PRICING.workerRequests);
+    const doReqCost = overage(totalDoReqs * proj, PRICING.doRequests);
+    const doDurCost = overage(doGBs * proj, PRICING.doDurationGBs);
+    const r2sCost = overage(totalR2Bytes / 1_073_741_824, PRICING.r2StorageGB);
+    const r2aCost = overage(totalClassA * proj, PRICING.r2ClassA);
+    const r2bCost = overage(totalClassB * proj, PRICING.r2ClassB);
+    const total = PRICING.baseFee + wCost + doReqCost + doDurCost + r2sCost + r2aCost + r2bCost;
+    console.log('');
+    console.log('  ' + color.bold('Estimated Monthly Cost'));
+    console.log('  ' +
+        table(['Line Item', 'Usage/mo', 'Free Tier', 'Cost'], [
+            ['Workers Paid (base)', '—', '—', fmtDollars(PRICING.baseFee)],
+            [
+                'Worker Requests',
+                fmt(totalWorkerReqs * proj),
+                fmt(PRICING.workerRequests.included),
+                fmtDollars(wCost),
+            ],
+            [
+                'DO Requests',
+                fmt(totalDoReqs * proj),
+                fmt(PRICING.doRequests.included),
+                fmtDollars(doReqCost),
+            ],
+            [
+                'DO Duration',
+                (doGBs * proj).toFixed(1) + ' GB-s',
+                fmt(PRICING.doDurationGBs.included) + ' GB-s',
+                fmtDollars(doDurCost),
+            ],
+            ['R2 Storage', fmtBytes(totalR2Bytes), '10 GB', fmtDollars(r2sCost)],
+            [
+                'R2 Class A',
+                fmt(totalClassA * proj),
+                fmt(PRICING.r2ClassA.included),
+                fmtDollars(r2aCost),
+            ],
+            [
+                'R2 Class B',
+                fmt(totalClassB * proj),
+                fmt(PRICING.r2ClassB.included),
+                fmtDollars(r2bCost),
+            ],
+            ['', '', '', '────────'],
+            ['TOTAL', '', '', fmtDollars(total)],
+        ], [false, true, true, true])
+            .split('\n')
+            .join('\n  '));
+    console.log('');
+    if (total <= PRICING.baseFee) {
+        console.log('  ' + color.green('All usage within free tiers.') + ' Only paying the $5 base fee.');
+    }
+    else {
+        console.log(`  Overage: ${fmtDollars(total - PRICING.baseFee)} above $5 base fee.`);
+    }
+    console.log(`  Based on ${days} days, projected to 30-day month.`);
+    console.log('');
+}
+/**
+ * --per-action / --per-conversation report. Reads from the connected
+ * DO's `admin:cost-report` action — a convention action the app
+ * implements by calling `ActionCostLedger.byAction()` / `byConversation()`.
+ *
+ * If the action isn't registered (the app hasn't adopted the SDK
+ * primitive), print an install hint instead of a confusing error.
+ */
+async function perCallReport(days, opts) {
+    const { isDaemonRunning, daemonGetConnection, daemonRpc } = await import('../daemon-client.js');
+    if (!(await isDaemonRunning())) {
+        console.error(color.red('✗') + ' Daemon not running. Start it:  beehaven start --headless\n    (or open the Hive Mac app, which runs one for you.)');
+        return;
+    }
+    const conn = await daemonGetConnection();
+    if (!conn) {
+        console.error(color.red('✗') + ' No connected DO. Run `beehaven connect <address>` first.');
+        return;
+    }
+    const sinceMs = Date.now() - days * 86400_000;
+    const gatewayAction = conn.buildingType === 'shopifyStore' ? 'admin:store-rpc' : `admin:${conn.buildingType}-rpc`;
+    try {
+        const reportInput = {
+            sinceMs,
+            includeByAction: !!opts.perAction,
+            includeByConversation: !!opts.perConversation,
+            conversationLimit: 50,
+        };
+        const res = await daemonRpc(gatewayAction, {
+            storeId: conn.buildingId,
+            action: 'admin:cost-report',
+            input: reportInput,
+        });
+        const report = res?.result ?? res;
+        if (!report) {
+            console.log(`  No cost data for the last ${days} day(s).`);
+            return;
+        }
+        console.log('');
+        console.log(`  ${color.bold(`Cost Report — ${conn.buildingType}/${conn.buildingId}`)}`);
+        console.log(`  Last ${days} day(s)`);
+        if (report.totals) {
+            const totalCents = Math.round((report.totals.totalMicroCents ?? 0) / 1000);
+            console.log(`  Total calls: ${report.totals.calls}  |  Total: ${fmtDollars(totalCents / 100)}`);
+        }
+        if (opts.perAction && Array.isArray(report.byAction) && report.byAction.length > 0) {
+            console.log('');
+            console.log('  ' + color.bold('Per action'));
+            console.log('  ' +
+                table(['Action', 'Calls', 'Total', 'Avg / call', 'Avg ms'], report.byAction.map((r) => [
+                    r.action,
+                    fmt(r.calls),
+                    fmtDollars((r.totalMicroCents ?? 0) / 100_000),
+                    fmtDollars((r.avgMicroCents ?? 0) / 100_000),
+                    r.avgDurationMs ? Math.round(r.avgDurationMs).toString() : '—',
+                ]), [false, true, true, true, true])
+                    .split('\n')
+                    .join('\n  '));
+        }
+        if (opts.perConversation &&
+            Array.isArray(report.byConversation) &&
+            report.byConversation.length > 0) {
+            console.log('');
+            console.log('  ' + color.bold('Per conversation'));
+            console.log('  ' +
+                table(['Conversation', 'Calls', 'Actions', 'Total'], report.byConversation.map((r) => [
+                    r.conversationId.slice(0, 32),
+                    fmt(r.calls),
+                    fmt(r.actions),
+                    fmtDollars((r.totalMicroCents ?? 0) / 100_000),
+                ]), [false, true, true, true])
+                    .split('\n')
+                    .join('\n  '));
+        }
+        console.log('');
+    }
+    catch (err) {
+        const msg = String(err?.message ?? err);
+        if (/unknown action|action not found|admin:cost-report/i.test(msg)) {
+            console.error(color.yellow('!') + ' The connected DO does not implement `admin:cost-report`.');
+            console.error('  Adopt the ActionCostLedger pattern:');
+            console.error('');
+            console.error("    import { ActionCostLedger } from '@clearly-sh/beehaven-core/server';");
+            console.error('');
+            console.error('    class MyShop extends Workspace {');
+            console.error('      costs = new ActionCostLedger(this.state.storage.sql);');
+            console.error("      costReport = this.action('admin:cost-report', {");
+            console.error("        input: { sinceMs: 'number', includeByAction: 'boolean', includeByConversation: 'boolean', conversationLimit: 'number' },");
+            console.error('        handler: async (input) => ({');
+            console.error('          totals: this.costs.totals(input.sinceMs),');
+            console.error('          byAction: input.includeByAction ? this.costs.byAction(input.sinceMs) : undefined,');
+            console.error('          byConversation: input.includeByConversation ? this.costs.byConversation(input.sinceMs, input.conversationLimit) : undefined,');
+            console.error('        }),');
+            console.error('      });');
+            console.error('    }');
+            console.error('');
+            console.error('  Then call costs.append({...}) inside each action handler.');
+        }
+        else {
+            console.error(color.red('✗') + ' ' + msg);
+        }
+    }
+}