@agentgrant.cash/cli 1.0.0

package/dist/cli/commands/portfolio.js

@@ -0,0 +1,224 @@
+import { buildContext, emit, ui, formatPortfolioView, computeNetWorthUsd, formatMoney, formatAgentFunds, resolveDisplayPrefs, displayDescriptor, fetchPusdBalanceUsd, DEFAULT_PREFS, } from "../../lib/index.js";
+/**
+ * Combined worth in one place: INVESTMENTS (money side — gold, cash, bitcoin,
+ * ethereum, perps, borrowed PLUS the prediction balance + open bets and earn/
+ * staked positions the backend summary can't see) and SPENDING (agent side —
+ * live-service funds + their status). Each side is fetched independently: if one
+ * isn't connected or briefly fails, the other still shows.
+ */
+/** The earn vaults to probe for staked value, with their display labels. */
+const EARN_PROBE = [
+    { symbol: "USDT", label: "Cash", priced: "stable" },
+    { symbol: "USDC", label: "USDC", priced: "stable" },
+    { symbol: "WETH", label: "Ethereum", priced: "eth" },
+];
+// Independent deadlines per pool so a slow probe can't stall the whole view.
+// Predictions gets more headroom: in the fallback path it does a positions call
+// plus a deposit-wallet lookup plus an on-chain pUSD read against public RPCs,
+// and trimming it too early was hiding deposited-but-unbet balances entirely.
+const PREDICTION_DEADLINE_MS = 9_000;
+const EARN_DEADLINE_MS = 5_000;
+function settledValue(r) {
+    return r.status === "fulfilled" ? r.value : null;
+}
+/** Resolve `p`, but give up with `fallback` after `ms` so a slow probe can't stall the view. */
+function withDeadline(p, ms, fallback) {
+    return Promise.race([p, new Promise((resolve) => setTimeout(() => resolve(fallback), ms))]);
+}
+/** Build display prefs from the user's profile + FX rate. USD defaults on any failure. */
+async function loadDisplayPrefs(ctx) {
+    try {
+        const user = (await ctx.money.getUser());
+        const currency = typeof user?.currency === "string" && user.currency.trim()
+            ? user.currency.trim().toUpperCase()
+            : "USD";
+        let rate = 1;
+        if (currency !== "USD") {
+            try {
+                const fx = await ctx.money.getFiatRate(currency);
+                if (fx && typeof fx.price === "number" && fx.price > 0)
+                    rate = fx.price;
+            }
+            catch {
+                /* FX unavailable → render USD */
+            }
+        }
+        return resolveDisplayPrefs(user, rate);
+    }
+    catch {
+        return DEFAULT_PREFS;
+    }
+}
+/** Live ETH/USD price for valuing a WETH earn position. null when unavailable. */
+async function ethUsdPrice(ctx) {
+    try {
+        const arr = (await ctx.money.getCryptoPrices());
+        const found = Array.isArray(arr) ? arr.find((e) => e?.currency === "ETH") : undefined;
+        return typeof found?.price === "number" && found.price > 0 ? found.price : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Prediction available cash + open-bet value. Best-effort; {} on any failure.
+ *
+ * Available cash comes from the SAME source the predictions screen uses: the
+ * backend `/polymarket/positions` `cashUsd` field (an on-chain pUSD read done
+ * server-side via a reliable RPC). For older backends that don't return it we
+ * fall back to reading the deposit wallet's pUSD balance directly from a public
+ * Polygon RPC. Both the positions call and the deposit-wallet lookup run in
+ * parallel so the fallback adds no latency in the common case.
+ */
+export async function gatherPredictions(ctx) {
+    const [positionsR, walletR] = await Promise.allSettled([
+        ctx.money.polymarketPositions(),
+        ctx.money.polymarketDepositWallet(),
+    ]);
+    const extras = {};
+    const positions = settledValue(positionsR);
+    // Open-bet value (only when there are live positions).
+    if (positions && positions.valueUsd > 0) {
+        extras.predictionPositionsUsd = positions.valueUsd;
+        extras.predictionPnlUsd = positions.pnlUsd;
+    }
+    // Available-to-bet cash: prefer the backend's server-side value (matches the
+    // predictions screen), else read the deposit wallet's pUSD balance directly.
+    if (positions && typeof positions.cashUsd === "number") {
+        extras.predictionAvailableUsd = positions.cashUsd;
+    }
+    else {
+        const wallet = settledValue(walletR);
+        if (wallet?.address) {
+            const bal = await fetchPusdBalanceUsd(wallet.address);
+            if (typeof bal === "number")
+                extras.predictionAvailableUsd = bal;
+        }
+    }
+    return extras;
+}
+/** Earn (staked) positions across the vaults, valued in USD. Best-effort; [] on any failure. */
+async function gatherEarn(ctx) {
+    const [ethPriceR, ...earnRs] = await Promise.allSettled([
+        ethUsdPrice(ctx),
+        ...EARN_PROBE.map((p) => ctx.money.getEarnPosition(p.symbol)),
+    ]);
+    const ethPrice = settledValue(ethPriceR);
+    const earn = [];
+    earnRs.forEach((r, i) => {
+        const p = settledValue(r);
+        if (!p)
+            return;
+        const probe = EARN_PROBE[i];
+        const amount = Number(p.assetsFormatted);
+        if (!Number.isFinite(amount) || amount <= 0)
+            return;
+        const price = probe.priced === "eth" ? (typeof ethPrice === "number" ? ethPrice : null) : 1;
+        if (price == null || price <= 0)
+            return; // can't value WETH without a price → skip
+        const earnedTok = p.earnedFormatted != null ? Number(p.earnedFormatted) : null;
+        earn.push({
+            label: probe.label,
+            valueUsd: amount * price,
+            earnedUsd: earnedTok != null && Number.isFinite(earnedTok) ? earnedTok * price : null,
+            apy: typeof p.netApy === "number" ? p.netApy : null,
+        });
+    });
+    return earn;
+}
+/**
+ * Gather the money pools the backend summary can't see — the on-chain prediction
+ * balance + open bets, and earn (staked) positions. Both run concurrently under
+ * independent deadlines: every probe is best-effort, a failure or slow backend
+ * silently omits that line, and neither can stall the command.
+ */
+async function gatherExtras(ctx) {
+    const [pred, earn] = await Promise.all([
+        withDeadline(gatherPredictions(ctx), PREDICTION_DEADLINE_MS, {}),
+        withDeadline(gatherEarn(ctx), EARN_DEADLINE_MS, []),
+    ]);
+    return earn.length ? { ...pred, earn } : pred;
+}
+async function gather(cmd) {
+    const ctx = buildContext(cmd);
+    const [prefsR, moneyR, extrasR, agentR] = await Promise.allSettled([
+        ctx.money.connected ? loadDisplayPrefs(ctx) : Promise.resolve(DEFAULT_PREFS),
+        ctx.money.connected
+            ? ctx.money.getPortfolio("full")
+            : Promise.resolve(null),
+        ctx.money.connected ? gatherExtras(ctx) : Promise.resolve({}),
+        ctx.agent.connected
+            ? ctx.agent.balance()
+            : Promise.resolve(null),
+    ]);
+    return {
+        ctx,
+        prefs: prefsR.status === "fulfilled" ? prefsR.value : DEFAULT_PREFS,
+        money: moneyR.status === "fulfilled" ? moneyR.value : null,
+        extras: extrasR.status === "fulfilled" ? extrasR.value : {},
+        moneyFailed: moneyR.status === "rejected",
+        agent: agentR.status === "fulfilled" ? agentR.value : null,
+        agentFailed: agentR.status === "rejected",
+    };
+}
+/** Indent every line of a block by two spaces. */
+function indent(block) {
+    return block
+        .split("\n")
+        .map((l) => (l ? `  ${l}` : l))
+        .join("\n");
+}
+export function registerPortfolio(program) {
+    const run = async (cmd) => {
+        const g = await gather(cmd);
+        const { ctx, prefs, money, extras, moneyFailed, agent, agentFailed } = g;
+        emit(ctx, {
+            investments: money
+                ? {
+                    ...money,
+                    // One canonical net worth across ALL pools (holdings + perps + earn +
+                    // predictions − debt). The backend sub-totals exclude predictions+earn;
+                    // this is the honest figure programmatic consumers should read.
+                    netWorthUsd: computeNetWorthUsd(money, extras),
+                    netWorthDisplay: formatMoney(computeNetWorthUsd(money, extras), prefs),
+                    extras,
+                    display: displayDescriptor(prefs),
+                }
+                : null,
+            spending: agent,
+        }, () => {
+            if (!ctx.money.connected && !ctx.agent.connected)
+                return "Not connected yet. Run `grant login`.";
+            const lines = [ui.title("Your Grant Cash"), ""];
+            // ── Investments (money side) ──
+            lines.push(ui.title("Investments"));
+            if (!ctx.money.connected) {
+                lines.push(ui.dim("  Not connected."));
+            }
+            else if (money) {
+                lines.push(indent(formatPortfolioView(money, prefs, extras)));
+            }
+            else {
+                lines.push(ui.amber(`  ${moneyFailed ? "Temporarily unavailable." : "—"}`));
+            }
+            lines.push("");
+            // ── Spending (agent side) ──
+            lines.push(ui.title("Spending") + ui.dim("  — live pay-per-use services"));
+            if (!ctx.agent.connected) {
+                lines.push(ui.dim("  Not connected."));
+            }
+            else if (agent) {
+                lines.push(formatAgentFunds(agent));
+            }
+            else {
+                lines.push(ui.amber(`  ${agentFailed ? "Temporarily unavailable." : "—"}`));
+            }
+            return lines.join("\n");
+        });
+    };
+    program
+        .command("portfolio")
+        .alias("balance")
+        .description("Your combined worth — investments (gold, cash, bitcoin, ethereum, perps, predictions, earn) and agent spending money")
+        .action((_opts, cmd) => run(cmd));
+}

package/dist/cli/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { isJsonMode, printError } from "../lib/index.js";
+/**
+ * Load `.env` from the PACKAGE ROOT only (never the cwd), so an installed CLI
+ * can't pick up a stray `.env` in whatever folder it's run from and silently
+ * repoint at the wrong backend. Already-exported shell vars win.
+ */
+function loadDotEnv(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return;
+    }
+    for (const line of raw.split("\n")) {
+        const m = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+        if (!m)
+            continue;
+        const key = m[1];
+        if (process.env[key] !== undefined)
+            continue;
+        let val = m[2].trim();
+        if ((val.startsWith('"') && val.endsWith('"')) ||
+            (val.startsWith("'") && val.endsWith("'"))) {
+            // Quoted value: keep everything inside the quotes verbatim (a `#` here is data).
+            val = val.slice(1, -1);
+        }
+        else {
+            // Unquoted value: strip a trailing inline comment (whitespace + `#…`), the
+            // dotenv convention. Prevents `KEY=http://x  # note` from capturing the note.
+            val = val.replace(/\s+#.*$/, "").trim();
+        }
+        process.env[key] = val;
+    }
+}
+loadDotEnv(fileURLToPath(new URL("../../.env", import.meta.url)));
+import { registerAuth } from "./commands/auth.js";
+import { registerPortfolio } from "./commands/portfolio.js";
+import { registerMoney } from "./commands/money.js";
+import { registerAgent } from "./commands/agent.js";
+import { registerMeta } from "./commands/meta.js";
+// ── full investing surface ported from the standalone Perfolio CLI ──
+import { registerTrade } from "./perfolio-commands/trade.js";
+import { registerMarket } from "./perfolio-commands/market.js";
+import { registerDiscover } from "./perfolio-commands/discover.js";
+import { registerBorrow } from "./perfolio-commands/borrow.js";
+import { registerEarn } from "./perfolio-commands/earn.js";
+import { registerHyperliquid } from "./perfolio-commands/hyperliquid.js";
+import { registerPolymarket } from "./perfolio-commands/polymarket.js";
+import { registerAccount } from "./perfolio-commands/account.js";
+import { registerTx } from "./perfolio-commands/tx.js";
+import { registerSession } from "./perfolio-commands/session.js";
+import { registerLoans } from "./perfolio-commands/loans.js";
+let version = "0.0.0";
+try {
+    version =
+        JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version ??
+            version;
+}
+catch {
+    /* fall back */
+}
+const program = new Command();
+program
+    .name("grant")
+    .description("Grant Cash — one CLI for your money (gold, cash, bitcoin, ethereum, perps, prediction markets, borrow, earn) and your agent (pay-per-use services).")
+    .version(version)
+    .option("--json", "machine-readable JSON output")
+    .option("--creds-file <path>", "override ~/.grant-cash/credentials.json");
+registerAuth(program);
+registerPortfolio(program);
+registerMoney(program);
+registerAgent(program);
+// ── investing surface (gold, cash, bitcoin, ethereum, perps, predictions, …) ──
+registerTrade(program);
+registerMarket(program);
+registerDiscover(program);
+registerBorrow(program);
+registerEarn(program);
+registerHyperliquid(program);
+registerPolymarket(program);
+registerLoans(program);
+registerAccount(program);
+registerTx(program);
+registerSession(program);
+registerMeta(program);
+program.parseAsync(process.argv).catch((err) => {
+    const json = isJsonMode(Boolean(program.opts().json));
+    process.exit(printError(json, err));
+});

package/dist/cli/money-helpers.js

@@ -0,0 +1,189 @@
+import pc from "picocolors";
+import { PerfolioClient, AssetResolver, baseUrls, resolveCredsPath, loadCredentials, saveCredentials, openBrowser, waitForSign, resolveDisplayPrefs, DEFAULT_PREFS, resolveCashToUsd, resolveCashTargetToAssetQty, } from "../lib/index.js";
+import { waitForTx } from "../lib/verify.js";
+/** PerfolioClient needs a `widget` base; derive it from the API origin if unset. */
+function widgetUrl(api) {
+    return process.env.GRANTCASH_WIDGET_URL || api.replace(/\/api\/?$/, "/widget");
+}
+export function buildCtx(cmd) {
+    const opts = cmd.optsWithGlobals();
+    const credsPath = resolveCredsPath(opts.credsFile);
+    const creds = loadCredentials(credsPath);
+    const urls = baseUrls();
+    const client = new PerfolioClient({
+        urls: { api: urls.api, fiat: urls.fiat, app: urls.app, widget: widgetUrl(urls.api) },
+        token: creds.money?.token,
+        refreshToken: creds.money?.refreshToken,
+        // Persist rotated tokens into the `money` slot so a silent refresh survives
+        // across invocations without disturbing the agent credential.
+        onRefresh: (token, refreshToken, expiresAt) => saveCredentials({ ...creds, money: { ...(creds.money ?? {}), token, refreshToken, expiresAt } }, credsPath),
+    });
+    return { client, creds, credsPath, json: Boolean(opts.json) };
+}
+export function requireAuth(ctx) {
+    if (!ctx.creds.money?.token) {
+        fail("Not connected. Run `grant login` first.", ctx.json);
+    }
+    return ctx.creds;
+}
+/** Load assets once and build a resolver. */
+export async function resolver(ctx) {
+    const assets = await ctx.client.getAssets();
+    return new AssetResolver(assets);
+}
+/**
+ * Resolve a user-entered CASH amount into a USD decimal string for the backend.
+ * A bare number is interpreted in the user's display currency; an explicit
+ * currency prefix ("$10", "₹50", "100 EUR") always wins. Non-USD amounts are
+ * converted via the live FX rate; refuses (throws) if that rate is unavailable.
+ */
+/**
+ * Force a bare numeric amount to USD by prefixing `$`. An amount the user already
+ * qualified with a currency ($/₹/€/ISO code) is left untouched — an explicit
+ * currency always wins (same rule money-input enforces). So `--usd` + "50" → "$50",
+ * but `--usd` + "₹50" stays ₹50.
+ */
+export function forceUsdAmount(raw) {
+    const s = String(raw).trim();
+    return /^\d[\d,]*(\.\d+)?$/.test(s) ? `$${s}` : s;
+}
+export async function resolveCash(ctx, raw, decimals, opts) {
+    const prefs = await loadDisplayPrefs(ctx);
+    const amount = opts?.usd ? forceUsdAmount(raw) : raw;
+    return resolveCashToUsd(amount, prefs, decimals, async (ccy) => {
+        const fx = await ctx.client.getFiatRate(ccy);
+        return fx.price;
+    });
+}
+/**
+ * Live USD unit price for a spot asset, used to size a cash-target sell:
+ * gold → gold spot; btc/eth → /prices/crypto; stable → 1:1. Throws if the
+ * price can't be resolved (caller refuses to guess a quantity).
+ */
+export async function assetUsdPrice(ctx, asset) {
+    if (asset.class === "stable")
+        return 1;
+    if (asset.class === "gold") {
+        const g = (await ctx.client.getGoldPrice());
+        const p = typeof g?.price === "number" ? g.price : NaN;
+        if (!(p > 0))
+            throw new Error("Could not get the live gold price to size this sale.");
+        return p;
+    }
+    if (asset.class === "btc" || asset.class === "eth") {
+        const wanted = asset.class === "btc" ? "BTC" : "ETH";
+        const arr = (await ctx.client.getCryptoPrices());
+        const found = Array.isArray(arr) ? arr.find((e) => e?.currency === wanted) : undefined;
+        const p = typeof found?.price === "number" ? found.price : NaN;
+        if (!(p > 0))
+            throw new Error(`Could not get the live ${asset.friendly} price to size this sale.`);
+        return p;
+    }
+    throw new Error(`Don't know how to price "${asset.friendly}" for a cash-target sale.`);
+}
+/**
+ * Resolve a cash-denominated SELL/CONVERT target ("sell ₹100 of gold") into a
+ * quantity of the asset to sell. Refuses (throws) if either the FX rate or the
+ * asset price is unavailable — never guesses a money quantity.
+ */
+export async function resolveCashTargetQty(ctx, asset, cashRaw) {
+    const [prefs, unitPrice] = await Promise.all([loadDisplayPrefs(ctx), assetUsdPrice(ctx, asset)]);
+    return resolveCashTargetToAssetQty(cashRaw, prefs, asset.decimals, async (ccy) => {
+        const fx = await ctx.client.getFiatRate(ccy);
+        return fx.price;
+    }, unitPrice);
+}
+/**
+ * Resolve the user's money-display preferences (currency, USD-vs-local, gold
+ * unit, experience mode) plus the live FX rate. Any failure falls back to safe
+ * USD defaults rather than breaking a read command.
+ */
+export async function loadDisplayPrefs(ctx) {
+    try {
+        const user = await ctx.client.getUser();
+        const currency = typeof user?.currency === "string" && user.currency.trim()
+            ? user.currency.trim().toUpperCase()
+            : "USD";
+        let rate = 1;
+        if (currency !== "USD") {
+            try {
+                const fx = await ctx.client.getFiatRate(currency);
+                if (fx && typeof fx.price === "number" && fx.price > 0)
+                    rate = fx.price;
+            }
+            catch {
+                /* FX unavailable → render USD */
+            }
+        }
+        return resolveDisplayPrefs(user, rate);
+    }
+    catch {
+        return DEFAULT_PREFS;
+    }
+}
+export function out(ctx, human, data) {
+    if (ctx.json)
+        console.log(JSON.stringify(data, null, 2));
+    else
+        console.log(human);
+}
+export function fail(msg, json) {
+    if (json)
+        console.error(JSON.stringify({ success: false, error: msg }));
+    else
+        console.error(pc.red(`✖ ${msg}`));
+    process.exit(1);
+}
+/**
+ * Report the outcome of a write. With `wait` (the default), poll the tx to a
+ * terminal state and report success/failure honestly — never "submitted". A
+ * failed tx exits non-zero; a timeout is reported as still-pending.
+ */
+export async function reportTx(ctx, res, wait, label) {
+    const txHash = res?.txHash;
+    const tail = txHash ? ` (tx ${txHash})` : "";
+    if (!wait) {
+        out(ctx, `Submitted: ${label}${tail}.\nNot yet confirmed — check with \`grant tx status${txHash ? ` ${txHash}` : ""}\`.`, { submitted: true, confirmed: false, status: res?.status ?? "submitted", txHash });
+        return;
+    }
+    const r = await waitForTx(ctx.client, txHash);
+    if (r.status === "success") {
+        out(ctx, `✓ ${label} confirmed${tail}.`, { success: true, confirmed: true, status: "success", txHash });
+        return;
+    }
+    if (r.status === "failed") {
+        fail(`${label} failed on-chain${tail}.`, ctx.json);
+    }
+    out(ctx, `${label}: still pending after waiting${tail}. Re-check with \`grant tx status${txHash ? ` ${txHash}` : ""}\`.`, { submitted: true, confirmed: false, status: r.status, txHash });
+}
+/**
+ * Browser-sign hand-off for user-signed operations (withdrawal, gift, HL agent
+ * approval). The CLI prepared a self-describing sign task; here we hand it to
+ * the relay, open the browser for the user to sign + execute, then (for on-chain
+ * ops) confirm the resulting tx. The agent never holds a key — the user's Privy
+ * wallet signs.
+ */
+export async function runSignFlow(ctx, opts) {
+    const start = await ctx.client.signStart(opts.task);
+    openBrowser(start.approveUrl);
+    if (ctx.json) {
+        out(ctx, "", { status: "awaiting_browser", approveUrl: start.approveUrl });
+    }
+    else {
+        console.log(`\nApprove this ${opts.label} in your browser (sign with your wallet):\n\n  ${start.approveUrl}\n\nWaiting for you to approve…`);
+    }
+    const r = await waitForSign(baseUrls().api, start.sid, start.pollInterval, start.expiresIn * 1000);
+    if (r.status !== "complete") {
+        fail(r.status === "denied" ? `${opts.label} was declined in the browser.` : `${opts.label} timed out. Try again.`, ctx.json);
+        return false;
+    }
+    if (opts.confirmTx === false) {
+        out(ctx, `✓ ${opts.label} approved.`, { success: true, ...r.result });
+        return true;
+    }
+    const tail = r.result.txHash ? ` (tx ${r.result.txHash})` : "";
+    if (!ctx.json)
+        console.log(`\nSigned ✓${tail}. Confirming on-chain…`);
+    await reportTx(ctx, { txHash: r.result.txHash, status: r.result.status }, true, opts.label);
+    return true;
+}