@getbags/cash 0.2.0

package/dist/deposits-visible.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mirror of app `WALLET_DEPOSITS_VISIBLE` (SHIP-PRD T7).
+ * Default OFF — no env required. CLI has no NEXT_PUBLIC_ inlining.
+ * ponytail: separate from Next client flag; set WALLET_DEPOSITS_VISIBLE=1 for local CLI ads.
+ */
+export declare function walletDepositsVisible(): boolean;

package/dist/deposits-visible.js

@@ -0,0 +1,11 @@
+/**
+ * Mirror of app `WALLET_DEPOSITS_VISIBLE` (SHIP-PRD T7).
+ * Default OFF — no env required. CLI has no NEXT_PUBLIC_ inlining.
+ * ponytail: separate from Next client flag; set WALLET_DEPOSITS_VISIBLE=1 for local CLI ads.
+ */
+export function walletDepositsVisible() {
+    const value = process.env.WALLET_DEPOSITS_VISIBLE ?? process.env.NEXT_PUBLIC_WALLET_DEPOSITS_VISIBLE;
+    if (value === undefined || value === '')
+        return false;
+    return value === '1' || value.toLowerCase() === 'true';
+}

package/dist/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const ERROR_REMEDIES: Record<string, string>;
+export declare function formatApiError(code: string, message: string): string;

package/dist/errors.js

@@ -0,0 +1,24 @@
+import { walletDepositsVisible } from './deposits-visible.js';
+export const ERROR_REMEDIES = {
+    // Deposit advertising gated (SHIP-PRD T7); fund command still works when known.
+    INSUFFICIENT_BALANCE: walletDepositsVisible()
+        ? 'balance too low; run: bags fund  (or redeem another invite code)'
+        : 'balance too low; redeem another invite code',
+    INVITE_INVALID: 'invite code is invalid or already used; ask your host for a new one',
+    INVITE_EXPIRED: 'invite code has expired; ask your host for a new one',
+    URL_BLOCKED: 'URL blocked by SSRF protection; use a public https endpoint',
+    CAP_EXCEEDED: 'daily or per-call spend cap exceeded; wait, lower --max-price-cents, or update policies',
+    WALLET_SUSPENDED: 'wallet suspended; check dashboard settings or contact support',
+    WALLET_FETCH_DISABLED: 'wallet fetch is temporarily disabled; retry later',
+    VALIDATION_FAILED: 'check your arguments (url, method, body JSON, policy fields)',
+    NOT_FOUND: 'API not available yet on this environment; upgrade CLI/server or retry later',
+    RATE_LIMITED: 'rate limited; wait a few seconds and retry',
+    UPSTREAM_ERROR: 'upstream endpoint error; retry or try bags check <url> for a fresh quote',
+    TIMEOUT: 'request timed out; retry once; if it persists, check balance for a stuck reservation',
+    AUTH_MISSING_CREDENTIALS: 'missing or invalid wallet token; run: bags redeem <code>',
+};
+export function formatApiError(code, message) {
+    const remedy = ERROR_REMEDIES[code];
+    const line = `${code}: ${message}`;
+    return remedy ? `${line}\n${remedy}` : line;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { checkEndpoint, createDeposit, createKey, discover, getBalance, getFund, getPolicies, getTransactions, listKeys, redeem, revokeKey, registerOrigin, search, setPolicies, listSessions, closeSessions, walletFetch, CliApiError, } from './api.js';
+import { getBaseUrl, getSkillSetupPrompt, getSkillUrl, requireToken, saveCredentials } from './config.js';
+import { parseArgs, USAGE } from './parse.js';
+function centsToDollars(cents) {
+    return `$${(cents / 100).toFixed(2)}`;
+}
+function fail(message) {
+    console.error(message);
+    process.exit(1);
+}
+function skillSourcePath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return join(here, '..', 'SKILL.md');
+}
+function installSkill() {
+    const cwd = process.cwd();
+    const candidates = [join(cwd, '.cursor', 'skills'), join(cwd, '.claude', 'skills'), join(cwd, '.agents', 'skills')];
+    const parent = candidates.find((dir) => existsSync(dir)) ?? join(cwd, '.agents', 'skills');
+    const destDir = join(parent, 'bags-cash');
+    mkdirSync(destDir, { recursive: true });
+    const dest = join(destDir, 'SKILL.md');
+    const source = skillSourcePath();
+    if (!existsSync(source)) {
+        throw new Error(`bundled SKILL.md not found at ${source}`);
+    }
+    writeFileSync(dest, readFileSync(source, 'utf8'), 'utf8');
+    return dest;
+}
+function printDiscoverTable(endpoints) {
+    if (endpoints.length === 0) {
+        console.log('(no endpoints)');
+        return;
+    }
+    const rows = endpoints.map((ep) => ({
+        url: ep.url,
+        method: ep.method,
+        price: typeof ep.price_usd === 'number' ? `$${ep.price_usd.toFixed(2)}` : String(ep.price_usd),
+        merchant: ep.merchant_name ?? '',
+        source: ep.source ?? 'bags',
+    }));
+    const cols = ['url', 'method', 'price', 'merchant', 'source'];
+    const widths = Object.fromEntries(cols.map((col) => [col, Math.max(col.length, ...rows.map((r) => r[col].length))]));
+    const header = cols.map((col) => col.toUpperCase().padEnd(widths[col])).join('  ');
+    console.log(header);
+    console.log(cols.map((col) => '-'.repeat(widths[col])).join('  '));
+    for (const row of rows) {
+        console.log(cols.map((col) => row[col].padEnd(widths[col])).join('  '));
+    }
+}
+function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function policyPatchFromSets(sets) {
+    const patch = {};
+    for (const [key, value] of Object.entries(sets)) {
+        const camel = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        const num = Number(value);
+        patch[camel] =
+            Number.isFinite(num) && String(num) === value
+                ? num
+                : value === 'true'
+                    ? true
+                    : value === 'false'
+                        ? false
+                        : value;
+    }
+    return patch;
+}
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.command === 'help') {
+        console.log(USAGE);
+        return;
+    }
+    if (parsed.command === 'error') {
+        fail(parsed.message);
+    }
+    try {
+        switch (parsed.command) {
+            case 'redeem': {
+                const result = await redeem(parsed.code);
+                saveCredentials(result.token);
+                console.log(`Redeemed. Balance: ${centsToDollars(result.balance_cents)}`);
+                console.log('Next steps:');
+                console.log('  npx @getbags/cash balance');
+                console.log('  npx @getbags/cash discover');
+                console.log('  npx @getbags/cash check <url>');
+                console.log('  npx @getbags/cash fetch <url>');
+                return;
+            }
+            case 'balance': {
+                const bal = await getBalance(requireToken());
+                console.log(`Balance:      ${centsToDollars(bal.balance_cents)}`);
+                console.log(`Daily spent:  ${centsToDollars(bal.daily_spent_cents)} / ${centsToDollars(bal.daily_cap_cents)}`);
+                console.log(`Per-call cap: ${centsToDollars(bal.per_call_cap_cents)}`);
+                console.log(`Status:       ${bal.status}`);
+                return;
+            }
+            case 'discover': {
+                const result = await discover(requireToken(), parsed.query);
+                if (parsed.format === 'json') {
+                    printJson(result);
+                }
+                else {
+                    printDiscoverTable(result.endpoints);
+                }
+                return;
+            }
+            case 'search': {
+                const result = await search(requireToken(), parsed.query);
+                if (parsed.format === 'json') {
+                    printJson(result);
+                }
+                else {
+                    printDiscoverTable(result.endpoints);
+                }
+                return;
+            }
+            case 'check': {
+                let parsedBody;
+                if (parsed.body !== undefined) {
+                    try {
+                        parsedBody = JSON.parse(parsed.body);
+                    }
+                    catch {
+                        fail('body must be valid JSON');
+                    }
+                }
+                const result = await checkEndpoint(requireToken(), {
+                    url: parsed.url,
+                    method: parsed.method,
+                    body: parsedBody,
+                });
+                if (parsed.format === 'json') {
+                    printJson(result);
+                    return;
+                }
+                console.log(`URL:      ${result.url}`);
+                console.log(`Method:   ${result.method}`);
+                console.log(`Status:   ${result.http_status}`);
+                console.log(`Payment:  ${result.requires_payment ? 'required' : 'not required'}`);
+                if (result.price_usd != null) {
+                    console.log(`Price:    $${Number(result.price_usd).toFixed(4)} (${result.price_cents}¢)`);
+                }
+                if (result.input_schema) {
+                    console.log('Input schema:');
+                    printJson(result.input_schema);
+                }
+                if (result.output_schema) {
+                    console.log('Output schema:');
+                    printJson(result.output_schema);
+                }
+                if (result.accepts?.length) {
+                    console.log('Accepts:');
+                    printJson(result.accepts);
+                }
+                return;
+            }
+            case 'fetch': {
+                let parsedBody;
+                if (parsed.body !== undefined) {
+                    try {
+                        parsedBody = JSON.parse(parsed.body);
+                    }
+                    catch {
+                        fail('body must be valid JSON');
+                    }
+                }
+                const result = await walletFetch(requireToken(), {
+                    url: parsed.url,
+                    method: parsed.method,
+                    body: parsedBody,
+                    max_price_cents: parsed.maxPriceCents,
+                    payment_protocol: parsed.paymentProtocol,
+                });
+                if (result.payment?.paid) {
+                    console.error(`payment: ${centsToDollars(result.payment.amount_cents)} | tx ${result.payment.tx_hash} | ${result.payment.network}`);
+                }
+                else if (result.payment) {
+                    console.error(`payment: not charged | tx ${result.payment.tx_hash || 'n/a'} | ${result.payment.network || 'n/a'}`);
+                }
+                if (typeof result.response === 'string') {
+                    process.stdout.write(result.response);
+                    if (!result.response.endsWith('\n'))
+                        process.stdout.write('\n');
+                }
+                else {
+                    process.stdout.write(`${JSON.stringify(result.response, null, 2)}\n`);
+                }
+                return;
+            }
+            case 'fund': {
+                const base = getBaseUrl();
+                const fallbackUrl = `${base}/wallet/onboard`;
+                try {
+                    if (parsed.create) {
+                        const created = await createDeposit(requireToken(), { network: parsed.network });
+                        console.log(`Deposit address (${created.network ?? parsed.network ?? 'base'}): ${created.deposit_address}`);
+                        console.log(`Status: ${created.status ?? 'pending'}`);
+                        if (created.deposit_id)
+                            console.log(`Deposit id: ${created.deposit_id}`);
+                        console.log('Send USDC to this address; balance updates after confirmation.');
+                        return;
+                    }
+                    const fund = await getFund(requireToken());
+                    if (parsed.open) {
+                        const openUrl = fund.deposit_url || fund.onramp_url || fallbackUrl;
+                        console.log(`Open: ${openUrl}`);
+                        // ponytail: no cross-platform opener dep — print URL; agent/human opens it.
+                    }
+                    if (fund.instructions)
+                        console.log(fund.instructions);
+                    if (fund.deposit_url)
+                        console.log(`Deposit URL: ${fund.deposit_url}`);
+                    if (fund.onramp_url)
+                        console.log(`On-ramp URL: ${fund.onramp_url}`);
+                    else if (fund.onramp_error)
+                        console.log(`On-ramp unavailable: ${fund.onramp_error}`);
+                    if (fund.addresses?.length) {
+                        console.log('Deposit addresses:');
+                        for (const a of fund.addresses) {
+                            console.log(`  ${a.network}: ${a.address}${a.asset ? ` (${a.asset})` : ''}`);
+                        }
+                    }
+                    else if (!parsed.open) {
+                        console.log('No addresses yet. Create one: bags fund --create [--network base]');
+                        console.log(`Or open: ${fallbackUrl}`);
+                    }
+                }
+                catch (err) {
+                    if (err instanceof CliApiError && (err.code === 'NOT_FOUND' || err.httpStatus === 404)) {
+                        console.log('Funding API not live yet on this environment.');
+                        console.log(`Dashboard / onboard: ${fallbackUrl}`);
+                        console.log('Or redeem a promo invite: npx @getbags/cash redeem <code>');
+                        return;
+                    }
+                    throw err;
+                }
+                return;
+            }
+            case 'transactions': {
+                try {
+                    const result = await getTransactions(requireToken(), {
+                        limit: parsed.limit,
+                        cursor: parsed.cursor,
+                    });
+                    if (parsed.format === 'json') {
+                        printJson(result);
+                    }
+                    else if (result.transactions.length === 0) {
+                        console.log('(no transactions)');
+                    }
+                    else {
+                        printJson(result.transactions);
+                        if (result.next_cursor)
+                            console.log(`next_cursor: ${result.next_cursor}`);
+                    }
+                }
+                catch (err) {
+                    if (err instanceof CliApiError && (err.code === 'NOT_FOUND' || err.httpStatus === 404)) {
+                        fail('transactions API not available yet on this environment');
+                    }
+                    throw err;
+                }
+                return;
+            }
+            case 'policies': {
+                try {
+                    if (parsed.action === 'get') {
+                        const policies = await getPolicies(requireToken());
+                        printJson(policies);
+                    }
+                    else {
+                        const updated = await setPolicies(requireToken(), policyPatchFromSets(parsed.sets));
+                        printJson(updated);
+                    }
+                }
+                catch (err) {
+                    if (err instanceof CliApiError && (err.code === 'NOT_FOUND' || err.httpStatus === 404)) {
+                        if (parsed.action === 'get') {
+                            // Fallback: surface caps from balance until policies route ships.
+                            const bal = await getBalance(requireToken());
+                            printJson({
+                                per_call_cap_cents: bal.per_call_cap_cents,
+                                daily_cap_cents: bal.daily_cap_cents,
+                                status: bal.status,
+                                note: 'policies API not live; showing balance caps',
+                            });
+                            return;
+                        }
+                        fail('policies API not available yet on this environment');
+                    }
+                    throw err;
+                }
+                return;
+            }
+            case 'keys': {
+                try {
+                    if (parsed.action === 'list') {
+                        const keys = await listKeys(requireToken());
+                        printJson(keys);
+                    }
+                    else if (parsed.action === 'create') {
+                        const created = await createKey(requireToken(), parsed.label);
+                        printJson(created);
+                        if (typeof created.token === 'string') {
+                            console.error('Store this token now; it will not be shown again.');
+                        }
+                    }
+                    else {
+                        const revoked = await revokeKey(requireToken(), parsed.id);
+                        printJson(revoked);
+                    }
+                }
+                catch (err) {
+                    if (err instanceof CliApiError && (err.code === 'NOT_FOUND' || err.httpStatus === 404)) {
+                        fail('keys API not available yet on this environment');
+                    }
+                    throw err;
+                }
+                return;
+            }
+            case 'register': {
+                const result = await registerOrigin(requireToken(), parsed.origin);
+                printJson(result);
+                return;
+            }
+            case 'sessions': {
+                try {
+                    if (parsed.action === 'list') {
+                        const result = await listSessions(requireToken());
+                        if (parsed.format === 'json') {
+                            printJson(result);
+                        }
+                        else if (result.sessions.length === 0) {
+                            console.log('(no open MPP sessions)');
+                        }
+                        else {
+                            for (const s of result.sessions) {
+                                console.log(`${s.id}  ${s.channel_id}  ${s.status}  ` +
+                                    `${centsToDollars(s.cumulative_cents)}/${centsToDollars(s.max_deposit_cents)}  ${s.origin}`);
+                            }
+                        }
+                        return;
+                    }
+                    const result = await closeSessions(requireToken(), {
+                        session_id: parsed.sessionId,
+                        channel_id: parsed.channelId,
+                        all: parsed.all,
+                    });
+                    if (parsed.format === 'json') {
+                        printJson(result);
+                    }
+                    else {
+                        console.log(`Closed ${result.closed.length} session(s)`);
+                        for (const s of result.closed) {
+                            console.log(`  ${s.id}  ${s.channel_id}  ${s.status}`);
+                        }
+                        if (result.errors.length) {
+                            console.error('Errors:');
+                            printJson(result.errors);
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err instanceof CliApiError && (err.code === 'NOT_FOUND' || err.httpStatus === 404)) {
+                        fail('sessions API not available yet on this environment');
+                    }
+                    throw err;
+                }
+                return;
+            }
+            case 'init': {
+                const dest = installSkill();
+                console.log(`Wrote agent skill to ${dest}`);
+                console.log(`Hosted skill: ${getSkillUrl()}`);
+                console.log(`Agent prompt: ${getSkillSetupPrompt()}`);
+                return;
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof CliApiError) {
+            fail(err.message);
+        }
+        fail(err instanceof Error ? err.message : String(err));
+    }
+}
+main();

package/dist/parse.d.ts

@@ -0,0 +1,70 @@
+export type PaymentProtocol = 'x402' | 'mpp' | 'auto';
+export type ParsedArgs = {
+    command: 'help';
+} | {
+    command: 'redeem';
+    code: string;
+} | {
+    command: 'balance';
+} | {
+    command: 'discover';
+    format: 'json' | 'pretty';
+    query?: string;
+} | {
+    command: 'fetch';
+    url: string;
+    method: string;
+    body?: string;
+    maxPriceCents?: number;
+    paymentProtocol?: PaymentProtocol;
+} | {
+    command: 'sessions';
+    action: 'list' | 'close';
+    sessionId?: string;
+    channelId?: string;
+    all: boolean;
+    yes: boolean;
+    format: 'json' | 'pretty';
+} | {
+    command: 'init';
+} | {
+    command: 'fund';
+    open: boolean;
+    create: boolean;
+    network?: string;
+} | {
+    command: 'transactions';
+    limit?: number;
+    cursor?: string;
+    format: 'json' | 'pretty';
+} | {
+    command: 'policies';
+    action: 'get' | 'set';
+    format: 'json' | 'pretty';
+    sets: Record<string, string>;
+} | {
+    command: 'keys';
+    action: 'create' | 'list' | 'revoke';
+    label?: string;
+    id?: string;
+    format: 'json' | 'pretty';
+} | {
+    command: 'check';
+    url: string;
+    method: string;
+    body?: string;
+    format: 'json' | 'pretty';
+} | {
+    command: 'search';
+    query: string;
+    format: 'json' | 'pretty';
+} | {
+    command: 'register';
+    origin: string;
+} | {
+    command: 'error';
+    message: string;
+};
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Help text; recomputed so WALLET_DEPOSITS_VISIBLE is respected at process start. */
+export declare const USAGE: string;