cubelife 0.2.0 → 0.3.0

package/dist/commands/agents.js

@@ -6,7 +6,7 @@ import { table } from '../ui/table.js';
 import { panel } from '../ui/panel.js';
 import { CREATURE_TYPES, ID_DISPLAY_LENGTH } from '../lib/constants.js';
 import { isCancel } from '../ui/helpers.js';
-import { rootOpts, requireProject, handleCommandError, } from '../lib/command-helpers.js';
+import { rootOpts, requireProject, handleCommandError, formatTimestamp, } from '../lib/command-helpers.js';
 import * as agentService from '../lib/services/agent-service.js';
 function maskKey(key) {
     if (key.length <= 12)
@@ -51,7 +51,7 @@ export function registerAgentCommands(program) {
                 id: a.id.slice(0, ID_DISPLAY_LENGTH),
                 form: formatForm(a),
                 visibility: a.isPublic ? 'public' : 'private',
-                created: new Date(a.createdAt).toLocaleDateString(),
+                created: formatTimestamp(a.createdAt),
             }));
             console.log(table([
                 { label: '', key: 'linked', width: 2 },

package/dist/commands/billing.js

@@ -5,7 +5,7 @@ import { brand, label } from '../ui/theme.js';
 import { panel } from '../ui/panel.js';
 import { table } from '../ui/table.js';
 import { isCancel } from '../ui/helpers.js';
-import { rootOpts, handleCommandError } from '../lib/command-helpers.js';
+import { rootOpts, handleCommandError, formatTimestamp } from '../lib/command-helpers.js';
 import { openBrowser } from '../lib/browser.js';
 import { pollVerification } from '../lib/poll.js';
 const LIFE_CALLBACK_URL = 'https://life.cubeworld.co.za/';
@@ -53,16 +53,19 @@ export function registerBillingCommands(program) {
                     tier,
                     price: formatPrice(tier),
                     apiCalls: { today: todayUsage, limit: limits.calls },
-                    sparks: billingUser.sparks,
-                    dormancyState: billingUser.dormancyState,
+                    burstSparks: billingUser.burstSparks ?? 0,
+                    gems: billingUser.gems ?? 0,
+                    sleeping: billingUser.sleeping ?? false,
                 }));
                 return;
             }
+            const status = billingUser.sleeping ? brand.warning('sleeping') : 'active';
             const lines = [
                 `${label('Plan')}${limits.label} (${formatPrice(tier)})`,
                 `${label('API Calls')}${usageWarning(todayUsage, limits.calls)}`,
-                `${label('Sparks')}${billingUser.sparks.toLocaleString()}`,
-                `${label('Status')}${billingUser.dormancyState ?? 'active'}`,
+                `${label('Burst Sparks')}${(billingUser.burstSparks ?? 0).toLocaleString()}`,
+                `${label('Gems')}${(billingUser.gems ?? 0).toLocaleString()}`,
+                `${label('Status')}${status}`,
             ];
             console.log(panel(lines, { title: 'Billing Overview', width: 56 }));
             p.log.message(brand.muted(`Run ${brand.accent('cubelife billing usage')} for 7-day history`));
@@ -160,7 +163,7 @@ export function registerBillingCommands(program) {
                 return;
             }
             const rows = history.map((item) => ({
-                date: new Date(item.createdAt).toLocaleDateString(),
+                date: formatTimestamp(item.createdAt),
                 type: item.type.replace(/_/g, ' '),
                 amount: formatCents(item.amount),
                 status: item.status,
@@ -351,7 +354,371 @@ export function registerBillingCommands(program) {
             handleCommandError({ error: err, json });
         }
     });
+    // --- Spark Packs ---
+    const sparks = billing.command('sparks').description('Buy Spark packs');
+    sparks
+        .command('list', { isDefault: true })
+        .description('List available Spark packs')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        if (json) {
+            console.log(JSON.stringify({ packs: SPARK_PACKS }));
+            return;
+        }
+        console.log(table([
+            { label: 'Pack', key: 'label', width: 10 },
+            { label: 'Sparks', key: 'sparks', width: 10 },
+            { label: 'Price', key: 'price', width: 10 },
+        ], SPARK_PACKS.map((pk) => ({ label: pk.label, sparks: pk.sparks.toLocaleString(), price: formatCents(pk.priceZarCents) }))));
+    });
+    sparks
+        .command('buy <pack>')
+        .description('Buy a Spark pack (ember|flame|blaze|inferno)')
+        .action(async function (packId) {
+        const { json, yes } = rootOpts(this);
+        const pack = SPARK_PACKS.find((pk) => pk.id === packId);
+        if (!pack) {
+            if (json)
+                console.log(JSON.stringify({ error: 'invalid_pack', valid: SPARK_PACKS.map((pk) => pk.id) }));
+            else
+                p.log.error(`Invalid pack. Valid options: ${SPARK_PACKS.map((pk) => brand.accent(pk.id)).join(', ')}`);
+            process.exit(1);
+        }
+        try {
+            await doPurchase({
+                json, yes,
+                title: `Buy ${pack.label} Spark Pack`,
+                description: `${pack.sparks} Sparks for ${formatCents(pack.priceZarCents)}`,
+                initiate: (client, email) => client.initiateTopUp({ packId: pack.id, email, callbackUrl: `${LIFE_CALLBACK_URL}?cb=billing&type=spark_topup` }),
+                verify: (client, ref) => client.verifyTopUp(ref),
+                successMsg: `${pack.sparks} Sparks added to your account`,
+            });
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Gem Packs ---
+    const gems = billing.command('gems').description('Buy Gem packs');
+    gems
+        .command('list', { isDefault: true })
+        .description('List available Gem packs')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        if (json) {
+            console.log(JSON.stringify({ packs: GEM_PACKS }));
+            return;
+        }
+        console.log(table([
+            { label: 'Pack', key: 'label', width: 10 },
+            { label: 'Gems', key: 'gems', width: 10 },
+            { label: 'Price', key: 'price', width: 10 },
+        ], GEM_PACKS.map((pk) => ({ label: pk.label, gems: pk.gems.toLocaleString(), price: formatCents(pk.priceZarCents) }))));
+    });
+    gems
+        .command('buy <pack>')
+        .description('Buy a Gem pack (shard|crystal|cluster|vein)')
+        .action(async function (packId) {
+        const { json, yes } = rootOpts(this);
+        const pack = GEM_PACKS.find((pk) => pk.id === packId);
+        if (!pack) {
+            if (json)
+                console.log(JSON.stringify({ error: 'invalid_pack', valid: GEM_PACKS.map((pk) => pk.id) }));
+            else
+                p.log.error(`Invalid pack. Valid options: ${GEM_PACKS.map((pk) => brand.accent(pk.id)).join(', ')}`);
+            process.exit(1);
+        }
+        try {
+            await doPurchase({
+                json, yes,
+                title: `Buy ${pack.label} Gem Pack`,
+                description: `${pack.gems} Gems for ${formatCents(pack.priceZarCents)}`,
+                initiate: (client, email) => client.initiateGemTopUp({ packId: pack.id, email, callbackUrl: `${LIFE_CALLBACK_URL}?cb=billing&type=gem_topup` }),
+                verify: (client, ref) => client.verifyGemTopUp(ref),
+                successMsg: `${pack.gems} Gems added to your account`,
+            });
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Vault ---
+    billing
+        .command('vault')
+        .description('Convert Burst Sparks to Gems (3:1 ratio)')
+        .option('--amount <n>', 'Number of sparks to convert')
+        .action(async function (opts) {
+        const { json, yes } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            const tier = resolveTier(billingUser.tier);
+            if (tier === 'free') {
+                if (json)
+                    console.log(JSON.stringify({ error: 'free_tier' }));
+                else
+                    p.log.error('Vaulting is available on Standard and Pro plans.');
+                process.exit(1);
+            }
+            const burstSparks = billingUser.burstSparks ?? 0;
+            if (burstSparks < 3) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'insufficient_sparks', burstSparks }));
+                else
+                    p.log.error(`Not enough Burst Sparks to vault (need at least 3, have ${burstSparks}).`);
+                process.exit(1);
+            }
+            const amount = opts.amount ? parseInt(opts.amount, 10) : undefined;
+            if (amount !== undefined && (isNaN(amount) || amount < 3 || amount > burstSparks)) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'invalid_amount' }));
+                else
+                    p.log.error(`Amount must be between 3 and ${burstSparks}.`);
+                process.exit(1);
+            }
+            const raw = amount ?? burstSparks;
+            const sparksToConvert = Math.floor(raw / 3) * 3;
+            const gemsToGain = sparksToConvert / 3;
+            if (sparksToConvert === 0) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'insufficient_sparks', burstSparks }));
+                else
+                    p.log.error(`Not enough Burst Sparks to vault (need at least 3, have ${burstSparks}).`);
+                process.exit(1);
+            }
+            if (!json && !yes) {
+                const lines = [
+                    `${label('Convert')}${sparksToConvert} Burst Sparks`,
+                    `${label('Receive')}${gemsToGain} Gems`,
+                    `${label('Remaining')}${burstSparks - sparksToConvert} Burst Sparks`,
+                ];
+                console.log(panel(lines, { title: 'Vault Conversion', width: 44 }));
+                const confirmed = await p.confirm({ message: 'Confirm vault conversion?' });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+            }
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Converting sparks to gems');
+            const result = await client.vaultSparks(sparksToConvert);
+            if (!json) {
+                spin.stop('Conversion complete');
+                p.log.success(`${result.gemsAdded} Gems added. Balance: ${result.gemsBalance} Gems, ${result.burstSparksRemaining} Burst Sparks remaining.`);
+            }
+            else {
+                console.log(JSON.stringify(result));
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Cancel ---
+    billing
+        .command('cancel')
+        .description('Cancel your subscription')
+        .action(async function () {
+        const { json, yes } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            const tier = resolveTier(billingUser.tier);
+            if (tier === 'free') {
+                if (json)
+                    console.log(JSON.stringify({ error: 'already_free' }));
+                else
+                    p.log.warn('Already on the Free plan.');
+                process.exit(1);
+            }
+            if (!json && !yes) {
+                const lines = [
+                    `${label('Current plan')}${TIER_LIMITS[tier].label} (${formatPrice(tier)})`,
+                    `${label('After cancel')}Free`,
+                ];
+                console.log(panel(lines, { title: 'Cancel Subscription', width: 44 }));
+                const confirmed = await p.confirm({ message: 'Are you sure you want to cancel?' });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Kept current plan.');
+                    return;
+                }
+            }
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Cancelling subscription');
+            await client.cancelSubscription();
+            if (!json) {
+                spin.stop('Subscription cancelled');
+                p.log.success('Your plan has been changed to Free.');
+            }
+            else {
+                console.log(JSON.stringify({ cancelled: true }));
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Downgrade Preview ---
+    billing
+        .command('downgrade-preview')
+        .description('Preview the impact of downgrading your plan')
+        .option('--target <tier>', 'Target tier (free or standard)', 'free')
+        .action(async function (opts) {
+        const { json } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Loading preview');
+            const preview = await client.getDowngradePreview(opts.target);
+            if (!json)
+                spin.stop('Preview loaded');
+            if (json) {
+                console.log(JSON.stringify(preview));
+                return;
+            }
+            const lines = [
+                `${label('Current')}${preview.currentTier}`,
+                `${label('Target')}${preview.targetTier}`,
+            ];
+            if (preview.impacts?.length) {
+                lines.push('');
+                for (const impact of preview.impacts) {
+                    const warn = impact.current > impact.limit;
+                    const line = `${impact.label}: ${impact.current} → limit ${impact.limit}`;
+                    lines.push(`  ${warn ? brand.warning(line) : line}`);
+                }
+            }
+            if (preview.lostFeatures?.length) {
+                lines.push('');
+                lines.push(brand.warning(`Features lost: ${preview.lostFeatures.join(', ')}`));
+            }
+            console.log(panel(lines, { title: 'Downgrade Preview', width: 52 }));
+            p.log.message(brand.muted(`Run ${brand.accent('cubelife billing cancel')} to proceed.`));
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    // --- Starter Pack ---
+    billing
+        .command('starter-pack')
+        .description('Buy the Starter Pack (one-time, R40)')
+        .action(async function () {
+        const { json, yes } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            if (billingUser.starterPackClaimed) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'already_claimed' }));
+                else
+                    p.log.warn('Starter Pack already claimed.');
+                process.exit(1);
+            }
+            await doPurchase({
+                json, yes, session,
+                title: 'Buy Starter Pack',
+                description: '30 Gems + exclusive item for R40.00',
+                initiate: (client2, email) => client2.initiateStarterPack({ email, callbackUrl: `${LIFE_CALLBACK_URL}?cb=billing&type=starter_pack` }),
+                verify: (client2, ref) => client2.verifyStarterPack(ref),
+                successMsg: 'Starter Pack claimed! 30 Gems and exclusive item added.',
+            });
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+}
+async function doPurchase(opts) {
+    const { json, yes, title, description, initiate, verify, successMsg } = opts;
+    const session = opts.session ?? await requireAuth();
+    const client = new AdminClient(session.token);
+    if (!json && !yes) {
+        console.log(panel([description], { title, width: 44 }));
+        const confirmed = await p.confirm({ message: 'Proceed to checkout?' });
+        if (isCancel(confirmed) || !confirmed) {
+            p.cancel('Cancelled.');
+            return;
+        }
+    }
+    const spin = p.spinner();
+    if (!json)
+        spin.start('Initiating checkout');
+    const result = await initiate(client, session.email);
+    if (!json)
+        spin.stop('Checkout ready');
+    if (json) {
+        console.log(JSON.stringify({ authorisationUrl: result.authorisationUrl, reference: result.reference }));
+    }
+    if (!json) {
+        const opened = await openBrowser(result.authorisationUrl);
+        if (opened)
+            p.log.info('Opening PayStack checkout in your browser...');
+        else
+            p.log.info('Open this URL to complete checkout:');
+        p.log.message(brand.accent(result.authorisationUrl));
+    }
+    const pollSpin = p.spinner();
+    if (!json)
+        pollSpin.start('Waiting for payment...');
+    let pollResult;
+    try {
+        pollResult = await pollVerification(client, result.reference, {
+            verify: (c, ref) => verify(c, ref),
+        });
+    }
+    catch (pollErr) {
+        if (!json)
+            pollSpin.stop('Failed');
+        throw pollErr;
+    }
+    if (pollResult.status === 'success') {
+        if (!json) {
+            pollSpin.stop('Payment confirmed');
+            p.log.success(successMsg);
+        }
+        else
+            console.log(JSON.stringify({ verified: true }));
+    }
+    else if (pollResult.status === 'timeout') {
+        if (!json) {
+            pollSpin.stop('Timed out');
+            p.log.warn('Payment verification timed out. The payment may still complete.');
+            p.log.message(brand.muted(`Reference: ${result.reference}`));
+        }
+        else {
+            console.log(JSON.stringify({ error: 'timeout', reference: result.reference }));
+        }
+    }
+    else {
+        if (!json) {
+            pollSpin.stop('Payment not completed');
+            p.log.error(`Payment ${pollResult.status}.`);
+        }
+        else
+            console.log(JSON.stringify({ error: pollResult.status }));
+    }
 }
+// --- Pack data ---
+const SPARK_PACKS = [
+    { id: 'ember', sparks: 50, priceZarCents: 4_000, label: 'Ember' },
+    { id: 'flame', sparks: 150, priceZarCents: 10_000, label: 'Flame' },
+    { id: 'blaze', sparks: 500, priceZarCents: 30_000, label: 'Blaze' },
+    { id: 'inferno', sparks: 1_500, priceZarCents: 80_000, label: 'Inferno' },
+];
+const GEM_PACKS = [
+    { id: 'shard', gems: 50, priceZarCents: 3_000, label: 'Shard' },
+    { id: 'crystal', gems: 200, priceZarCents: 10_000, label: 'Crystal' },
+    { id: 'cluster', gems: 600, priceZarCents: 25_000, label: 'Cluster' },
+    { id: 'vein', gems: 1_500, priceZarCents: 50_000, label: 'Vein' },
+];
 function featureRow(featureLabel, getValue, currentTier) {
     const lbl = brand.label(('  ' + featureLabel).padEnd(14));
     const values = TIER_ORDER.map((t) => {

package/dist/commands/projects.js

@@ -4,7 +4,7 @@ import { ID_DISPLAY_LENGTH } from '../lib/constants.js';
 import { brand, dot } from '../ui/theme.js';
 import { table } from '../ui/table.js';
 import { isCancel } from '../ui/helpers.js';
-import { rootOpts, handleCommandError, } from '../lib/command-helpers.js';
+import { rootOpts, handleCommandError, formatTimestamp, } from '../lib/command-helpers.js';
 import * as projectService from '../lib/services/project-service.js';
 export function registerProjectCommands(program) {
     const projects = program
@@ -35,7 +35,7 @@ export function registerProjectCommands(program) {
                 id: proj.id.slice(0, ID_DISPLAY_LENGTH),
                 name: proj.name,
                 product: proj.product,
-                created: new Date(proj.createdAt).toLocaleDateString(),
+                created: formatTimestamp(proj.createdAt),
             }));
             console.log(table([
                 { label: '', key: 'linked', width: 2 },

package/dist/lib/api.d.ts

@@ -6,6 +6,9 @@ export type Tier = 'free' | 'standard' | 'pro';
 export interface BillingUser {
     tier: Tier;
     sparks: number;
+    burstSparks?: number;
+    gems?: number;
+    sleeping?: boolean;
     dormancyState: string;
     starterPackClaimed?: boolean;
     locale?: string;
@@ -19,14 +22,36 @@ export interface UsageDay {
 }
 export interface BillingHistoryItem {
     id: string;
-    type: 'subscription' | 'spark_topup' | 'starter_pack' | 'cosmetic';
+    type: 'subscription' | 'subscription_ended' | 'spark_topup' | 'gem_topup' | 'starter_pack' | 'cosmetic';
     product: 'world' | 'life';
     amount: number;
     currency: string;
     sparks: number | null;
+    gems: number | null;
     status: 'success' | 'failed';
     paystackReference: string;
-    createdAt: string;
+    createdAt: unknown;
+}
+export interface VaultResponse {
+    gemsAdded: number;
+    gemsBalance: number;
+    burstSparksRemaining: number;
+}
+export interface DowngradePreview {
+    currentTier: string;
+    targetTier: string;
+    impacts: Array<{
+        key: string;
+        label: string;
+        current: number;
+        limit: number;
+    }>;
+    lostFeatures: string[];
+}
+export interface TopUpRequest {
+    packId: string;
+    email: string;
+    callbackUrl: string;
 }
 export interface SubscribeRequest {
     plan: string;
@@ -138,6 +163,17 @@ export declare class AdminClient {
     getBillingHistory(limit?: number): Promise<BillingHistoryItem[]>;
     subscribe(opts: SubscribeRequest): Promise<SubscribeResponse>;
     verifyPayment(reference: string): Promise<VerifyResponse>;
+    initiateTopUp(opts: TopUpRequest): Promise<SubscribeResponse>;
+    verifyTopUp(reference: string): Promise<VerifyResponse>;
+    initiateGemTopUp(opts: TopUpRequest): Promise<SubscribeResponse>;
+    verifyGemTopUp(reference: string): Promise<VerifyResponse>;
+    initiateStarterPack(opts: Omit<TopUpRequest, 'packId'>): Promise<SubscribeResponse>;
+    verifyStarterPack(reference: string): Promise<VerifyResponse>;
+    vaultSparks(amount?: number): Promise<VaultResponse>;
+    cancelSubscription(): Promise<{
+        cancelled: boolean;
+    }>;
+    getDowngradePreview(targetTier: string): Promise<DowngradePreview>;
     listProjects(): Promise<ProjectListResponse>;
     createProject(name: string): Promise<ProjectResponse>;
     deleteProject(id: string): Promise<void>;

package/dist/lib/api.js

@@ -75,6 +75,33 @@ export class AdminClient {
     async verifyPayment(reference) {
         return this.request('POST', '/v1/billing/verify', { reference });
     }
+    async initiateTopUp(opts) {
+        return this.request('POST', '/v1/billing/topup', opts);
+    }
+    async verifyTopUp(reference) {
+        return this.request('POST', '/v1/billing/topup/verify', { reference });
+    }
+    async initiateGemTopUp(opts) {
+        return this.request('POST', '/v1/billing/gem-topup', opts);
+    }
+    async verifyGemTopUp(reference) {
+        return this.request('POST', '/v1/billing/gem-topup/verify', { reference });
+    }
+    async initiateStarterPack(opts) {
+        return this.request('POST', '/v1/billing/starter-pack', opts);
+    }
+    async verifyStarterPack(reference) {
+        return this.request('POST', '/v1/billing/starter-pack/verify', { reference });
+    }
+    async vaultSparks(amount) {
+        return this.request('POST', '/v1/billing/vault', amount ? { amount } : {});
+    }
+    async cancelSubscription() {
+        return this.request('POST', '/v1/billing/cancel');
+    }
+    async getDowngradePreview(targetTier) {
+        return this.request('GET', `/v1/billing/downgrade-preview?targetTier=${encodeURIComponent(targetTier)}`);
+    }
     async listProjects() {
         return this.request('GET', '/v1/projects');
     }

package/dist/lib/command-helpers.d.ts

@@ -15,6 +15,7 @@ export interface CommandErrorOptions {
     exitCode?: number;
 }
 export declare function handleCommandError(opts: CommandErrorOptions): never;
+export declare function formatTimestamp(ts: unknown): string;
 export interface ResolvedProject {
     projectId: string;
 }

package/dist/lib/command-helpers.js

@@ -24,6 +24,17 @@ export function handleCommandError(opts) {
     }
     process.exit(opts.exitCode ?? 1);
 }
+export function formatTimestamp(ts) {
+    if (!ts)
+        return '--';
+    if (typeof ts === 'number')
+        return new Date(ts).toLocaleDateString();
+    if (typeof ts === 'object' && ts !== null && '_seconds' in ts) {
+        return new Date(ts._seconds * 1000).toLocaleDateString();
+    }
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? '--' : d.toLocaleDateString();
+}
 export async function requireProject(cmd, json) {
     const projectFlag = cmd.parent?.opts().project;
     let projectId;

package/dist/lib/poll.d.ts

@@ -7,5 +7,8 @@ export interface PollResult {
 export interface PollOptions {
     interval?: number;
     timeout?: number;
+    verify?: (client: AdminClient, reference: string) => Promise<{
+        verified: boolean;
+    }>;
 }
 export declare function pollVerification(client: AdminClient, reference: string, opts?: PollOptions): Promise<PollResult>;

package/dist/lib/poll.js

@@ -5,9 +5,10 @@ export async function pollVerification(client, reference, opts = {}) {
     const interval = opts.interval ?? 5_000;
     const timeout = opts.timeout ?? 300_000;
     const deadline = Date.now() + timeout;
+    const verifyFn = opts.verify ?? ((c, ref) => c.verifyPayment(ref));
     while (Date.now() < deadline) {
         try {
-            const data = await client.verifyPayment(reference);
+            const data = await verifyFn(client, reference);
             return { status: 'success', data };
         }
         catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cubelife",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CLI for CubeLife — give your AI agent a living pixel-art companion",
   "type": "module",
   "bin": {