cubelife 0.2.0

package/dist/commands/auth.js

@@ -0,0 +1,233 @@
+import * as p from '@clack/prompts';
+import { register, login, logout, currentUser, requireAuth, } from '../lib/auth.js';
+import { AdminClient } from '../lib/api.js';
+import { brand, label } from '../ui/theme.js';
+import { panel } from '../ui/panel.js';
+import { isCancel } from '../ui/helpers.js';
+import { rootOpts } from '../lib/command-helpers.js';
+import { fetchAccountSummary, fetchLinkedInfo } from '../lib/services/account-service.js';
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+export function registerAuthCommands(program) {
+    program
+        .command('register')
+        .description('Create a new CubeLife account')
+        .option('--email <email>', 'Email address (non-interactive)')
+        .option('--password <password>', 'Password (non-interactive)')
+        .action(async function (opts) {
+        const { yes } = rootOpts(this);
+        const nonInteractive = !!(opts.email && opts.password);
+        let email;
+        let pw;
+        if (nonInteractive) {
+            email = opts.email;
+            pw = opts.password;
+        }
+        else {
+            p.intro(brand.primary('Create your CubeLife account'));
+            const emailResult = await p.text({
+                message: 'Email address',
+                placeholder: 'you@example.com',
+                validate: (v) => {
+                    if (!EMAIL_RE.test(v))
+                        return 'Please enter a valid email address.';
+                },
+            });
+            if (isCancel(emailResult)) {
+                p.cancel('Registration cancelled.');
+                process.exit(0);
+            }
+            email = emailResult;
+            const pwResult = await p.password({
+                message: 'Password (min 6 characters)',
+                validate: (v) => {
+                    if (v.length < 6)
+                        return 'Password must be at least 6 characters.';
+                },
+            });
+            if (isCancel(pwResult)) {
+                p.cancel('Registration cancelled.');
+                process.exit(0);
+            }
+            pw = pwResult;
+            if (!yes) {
+                const confirmResult = await p.password({
+                    message: 'Confirm password',
+                    validate: (v) => {
+                        if (v !== pw)
+                            return 'Passwords do not match.';
+                    },
+                });
+                if (isCancel(confirmResult)) {
+                    p.cancel('Registration cancelled.');
+                    process.exit(0);
+                }
+            }
+        }
+        const spin = p.spinner();
+        spin.start('Creating account');
+        try {
+            const auth = await register(email, pw);
+            spin.stop('Account created');
+            p.log.success(`Registered as ${brand.primary(auth.email)}`);
+            p.outro(`Run ${brand.accent('cubelife tutorial')} to get started.`);
+        }
+        catch (err) {
+            spin.stop('Registration failed');
+            p.log.error(err.message);
+            process.exit(1);
+        }
+    });
+    program
+        .command('login')
+        .description('Log in to your CubeLife account')
+        .option('--email <email>', 'Email address (non-interactive)')
+        .option('--password <password>', 'Password (non-interactive)')
+        .action(async function (opts) {
+        const nonInteractive = !!(opts.email && opts.password);
+        let email;
+        let pw;
+        if (nonInteractive) {
+            email = opts.email;
+            pw = opts.password;
+        }
+        else {
+            p.intro(brand.primary('Log in to CubeLife'));
+            const emailResult = await p.text({
+                message: 'Email address',
+                placeholder: 'you@example.com',
+                validate: (v) => {
+                    if (!EMAIL_RE.test(v))
+                        return 'Please enter a valid email address.';
+                },
+            });
+            if (isCancel(emailResult)) {
+                p.cancel('Login cancelled.');
+                process.exit(0);
+            }
+            email = emailResult;
+            const pwResult = await p.password({
+                message: 'Password',
+            });
+            if (isCancel(pwResult)) {
+                p.cancel('Login cancelled.');
+                process.exit(0);
+            }
+            pw = pwResult;
+        }
+        const spin = p.spinner();
+        spin.start('Logging in');
+        try {
+            const auth = await login(email, pw);
+            spin.stop('Logged in');
+            p.log.success(`Logged in as ${brand.primary(auth.email)}`);
+        }
+        catch (err) {
+            spin.stop('Login failed');
+            p.log.error(err.message);
+            if (!nonInteractive) {
+                const retry = await p.confirm({ message: 'Try again?' });
+                if (!isCancel(retry) && retry) {
+                    await program.commands
+                        .find((c) => c.name() === 'login')
+                        ?.parseAsync([], { from: 'user' });
+                    return;
+                }
+            }
+            process.exit(1);
+        }
+    });
+    program
+        .command('logout')
+        .description('Log out and clear stored credentials')
+        .action(async function () {
+        const { yes } = rootOpts(this);
+        const user = await currentUser();
+        if (!user) {
+            p.log.warn('Not logged in.');
+            return;
+        }
+        if (!yes) {
+            const confirmed = await p.confirm({
+                message: `Log out of ${brand.primary(user.email)}?`,
+            });
+            if (isCancel(confirmed) || !confirmed) {
+                p.cancel('Cancelled.');
+                return;
+            }
+        }
+        await logout();
+        p.log.success('Logged out.');
+    });
+    program
+        .command('whoami')
+        .description('Show current account, tier, and linked agent')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        const user = await currentUser();
+        if (!user) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'not_logged_in' }));
+            }
+            else {
+                p.log.warn(`Not logged in. Run ${brand.accent('cubelife login')}`);
+            }
+            return;
+        }
+        let tierLabel = 'unavailable';
+        let usageText = 'unavailable';
+        let sparksText = 'unavailable';
+        let usageToday = 0;
+        let usageLimit = 0;
+        let sparks = 0;
+        let tier = 'free';
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const summary = await fetchAccountSummary(client);
+            tier = summary.tier;
+            usageToday = summary.usageToday;
+            usageLimit = summary.usageLimit;
+            sparks = summary.sparks;
+            const ratio = usageLimit > 0 ? usageToday / usageLimit : 0;
+            const countStr = usageToday.toLocaleString();
+            const limitStr = usageLimit.toLocaleString();
+            const usageRaw = `${countStr} / ${limitStr} today`;
+            usageText = ratio > 0.8 ? brand.warning(usageRaw) : usageRaw;
+            sparksText = sparks.toLocaleString();
+            tierLabel = `${summary.tierLabel} (${summary.agentLimit} agents, ${limitStr} calls/day)`;
+        }
+        catch {
+            tierLabel = 'unavailable';
+            usageText = 'unavailable';
+            sparksText = 'unavailable';
+        }
+        const linked = await fetchLinkedInfo();
+        const projectText = linked.projectId ?? 'none';
+        const agentText = linked.agentId ?? 'none';
+        const integrationText = linked.tools.length > 0
+            ? linked.tools.map((t) => t.name).join(', ')
+            : 'none detected';
+        if (json) {
+            console.log(JSON.stringify({
+                email: user.email,
+                tier,
+                usage: { today: usageToday, limit: usageLimit },
+                sparks,
+                project: linked.projectId,
+                agent: linked.agentId,
+                integrations: linked.tools.map((t) => t.id),
+            }));
+            return;
+        }
+        const lines = [
+            `${label('Email')}${brand.primary(user.email)}`,
+            `${label('Tier')}${tierLabel}`,
+            `${label('Usage')}${usageText}`,
+            `${label('Sparks')}${sparksText}`,
+            `${label('Project')}${projectText}`,
+            `${label('Agent')}${agentText}`,
+            `${label('Integrations')}${integrationText}`,
+        ];
+        console.log(panel(lines, { title: 'Account', width: 56 }));
+    });
+}

package/dist/commands/billing.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerBillingCommands(program: Command): void;

package/dist/commands/billing.js

@@ -0,0 +1,362 @@
+import * as p from '@clack/prompts';
+import { AdminClient, TIER_LIMITS, resolveTier, } from '../lib/api.js';
+import { requireAuth } from '../lib/auth.js';
+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 { openBrowser } from '../lib/browser.js';
+import { pollVerification } from '../lib/poll.js';
+const LIFE_CALLBACK_URL = 'https://life.cubeworld.co.za/';
+const TIER_ORDER = ['free', 'standard', 'pro'];
+function formatCents(cents) {
+    return `R${(cents / 100).toFixed(2)}`;
+}
+function formatPrice(tier) {
+    const limits = TIER_LIMITS[tier];
+    return limits.priceZarCents === 0 ? 'Free' : `${formatCents(limits.priceZarCents)}/mo`;
+}
+function usageWarning(today, limit) {
+    const countStr = today.toLocaleString();
+    const limitStr = limit.toLocaleString();
+    const raw = `${countStr} / ${limitStr} today`;
+    const ratio = limit > 0 ? today / limit : 0;
+    return ratio > 0.8 ? brand.warning(raw) : raw;
+}
+export function registerBillingCommands(program) {
+    const billing = program
+        .command('billing')
+        .description('View and manage your billing, usage, and plan');
+    billing
+        .command('overview', { isDefault: true })
+        .description('Show billing overview')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Loading billing info');
+            const [billingUser, usage] = await Promise.all([
+                client.getBillingUser(),
+                client.getBillingUsage(1),
+            ]);
+            if (!json)
+                spin.stop('Billing loaded');
+            const tier = resolveTier(billingUser.tier);
+            const limits = TIER_LIMITS[tier];
+            const todayUsage = usage.length > 0 ? usage[0].apiCalls : 0;
+            if (json) {
+                console.log(JSON.stringify({
+                    tier,
+                    price: formatPrice(tier),
+                    apiCalls: { today: todayUsage, limit: limits.calls },
+                    sparks: billingUser.sparks,
+                    dormancyState: billingUser.dormancyState,
+                }));
+                return;
+            }
+            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'}`,
+            ];
+            console.log(panel(lines, { title: 'Billing Overview', width: 56 }));
+            p.log.message(brand.muted(`Run ${brand.accent('cubelife billing usage')} for 7-day history`));
+            p.log.message(brand.muted(`Run ${brand.accent('cubelife billing plans')} to compare plans`));
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    billing
+        .command('usage')
+        .description('Show usage over time')
+        .option('--days <n>', 'Number of days (1-30)', '7')
+        .action(async function (opts) {
+        const { json } = rootOpts(this);
+        const days = parseInt(opts.days, 10);
+        if (isNaN(days) || days < 1 || days > 30) {
+            if (json)
+                console.log(JSON.stringify({ error: 'days_must_be_1_to_30' }));
+            else
+                p.log.error('Days must be between 1 and 30.');
+            process.exit(1);
+        }
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Fetching usage');
+            const [billingUser, usage] = await Promise.all([
+                client.getBillingUser(),
+                client.getBillingUsage(days),
+            ]);
+            if (!json)
+                spin.stop('Usage loaded');
+            if (json) {
+                console.log(JSON.stringify({ usage }));
+                return;
+            }
+            if (usage.length === 0) {
+                p.log.info('No usage data available.');
+                return;
+            }
+            const rows = usage.map((day) => ({
+                date: day.date,
+                apiCalls: day.apiCalls.toLocaleString(),
+                events: day.eventsProcessed.toLocaleString(),
+                messages: day.messagesSent.toLocaleString(),
+                sparks: day.sparksUsed.toLocaleString(),
+            }));
+            console.log(table([
+                { label: 'Date', key: 'date', width: 12 },
+                { label: 'API Calls', key: 'apiCalls', width: 11 },
+                { label: 'Events', key: 'events', width: 8 },
+                { label: 'Messages', key: 'messages', width: 10 },
+                { label: 'Sparks', key: 'sparks', width: 8 },
+            ], rows));
+            const tier = resolveTier(billingUser.tier);
+            const limits = TIER_LIMITS[tier];
+            p.log.message(brand.muted(`Limit: ${limits.calls.toLocaleString()} API calls/day (${limits.label})`));
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    billing
+        .command('history')
+        .description('Show billing transaction history')
+        .option('--limit <n>', 'Number of transactions', '10')
+        .action(async function (opts) {
+        const { json } = rootOpts(this);
+        const limit = parseInt(opts.limit, 10);
+        if (isNaN(limit) || limit < 1 || limit > 100) {
+            if (json)
+                console.log(JSON.stringify({ error: 'limit_must_be_1_to_100' }));
+            else
+                p.log.error('Limit must be between 1 and 100.');
+            process.exit(1);
+        }
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Fetching history');
+            const history = await client.getBillingHistory(limit);
+            if (!json)
+                spin.stop('History loaded');
+            if (json) {
+                console.log(JSON.stringify({ history }));
+                return;
+            }
+            if (history.length === 0) {
+                p.log.info('No billing history.');
+                return;
+            }
+            const rows = history.map((item) => ({
+                date: new Date(item.createdAt).toLocaleDateString(),
+                type: item.type.replace(/_/g, ' '),
+                amount: formatCents(item.amount),
+                status: item.status,
+            }));
+            console.log(table([
+                { label: 'Date', key: 'date', width: 12 },
+                { label: 'Type', key: 'type', width: 14 },
+                { label: 'Amount', key: 'amount', width: 10 },
+                { label: 'Status', key: 'status', width: 8 },
+            ], rows));
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+    billing
+        .command('plans')
+        .description('Compare available plans')
+        .action(async function () {
+        const { json } = rootOpts(this);
+        let currentTier = 'free';
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            currentTier = resolveTier(billingUser.tier);
+        }
+        catch {
+            // show plans even if not logged in
+        }
+        if (json) {
+            const plans = TIER_ORDER.map((t) => ({
+                tier: t,
+                current: t === currentTier,
+                ...TIER_LIMITS[t],
+            }));
+            console.log(JSON.stringify({ plans, currentTier }));
+            return;
+        }
+        const header = '              ' + TIER_ORDER.map((t) => {
+            const lbl = TIER_LIMITS[t].label.padEnd(14);
+            return t === currentTier ? brand.primary(lbl) : lbl;
+        }).join('');
+        const rows = [
+            featureRow('Price', (t) => formatPrice(t), currentTier),
+            featureRow('Agents', (t) => `${TIER_LIMITS[t].agents}`, currentTier),
+            featureRow('API Calls', (t) => `${TIER_LIMITS[t].calls.toLocaleString()}/day`, currentTier),
+            featureRow('Embeds', (t) => TIER_LIMITS[t].embedInstances === -1 ? 'Unlimited' : `${TIER_LIMITS[t].embedInstances}`, currentTier),
+            featureRow('Analytics', (t) => TIER_LIMITS[t].analyticsHistory === 0 ? '--' : `${TIER_LIMITS[t].analyticsHistory} days`, currentTier),
+            featureRow('Branding', (t) => TIER_LIMITS[t].customBranding ? 'Custom' : '--', currentTier),
+            featureRow('Webhooks', (t) => TIER_LIMITS[t].webhooks ? 'Yes' : '--', currentTier),
+        ];
+        console.log('\n' + header);
+        console.log(brand.muted('  ' + '─'.repeat(54)));
+        rows.forEach((r) => console.log(r));
+        console.log('');
+        p.log.message(`Current plan: ${brand.primary(TIER_LIMITS[currentTier].label)}`);
+        const tierIdx = TIER_ORDER.indexOf(currentTier);
+        if (tierIdx < TIER_ORDER.length - 1) {
+            const next = TIER_ORDER[tierIdx + 1];
+            p.log.message(brand.muted(`Run ${brand.accent(`cubelife billing upgrade ${next}`)} to upgrade`));
+        }
+    });
+    billing
+        .command('upgrade <plan>')
+        .description('Upgrade your plan')
+        .action(async function (plan) {
+        const { json, yes } = rootOpts(this);
+        if (!TIER_ORDER.includes(plan)) {
+            if (json)
+                console.log(JSON.stringify({ error: 'invalid_plan', valid: ['standard', 'pro'] }));
+            else
+                p.log.error(`Invalid plan. Valid options: ${brand.accent('standard')}, ${brand.accent('pro')}`);
+            process.exit(1);
+        }
+        if (plan === 'free') {
+            if (json)
+                console.log(JSON.stringify({ error: 'cannot_upgrade_to_free' }));
+            else
+                p.log.error('Cannot upgrade to the free plan. To downgrade, visit the dashboard.');
+            process.exit(1);
+        }
+        const targetTier = plan;
+        try {
+            const session = await requireAuth();
+            const client = new AdminClient(session.token);
+            const billingUser = await client.getBillingUser();
+            const currentTier = resolveTier(billingUser.tier);
+            if (currentTier === targetTier) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'already_on_plan' }));
+                else
+                    p.log.warn(`Already on the ${TIER_LIMITS[currentTier].label} plan.`);
+                process.exit(1);
+            }
+            const currentIdx = TIER_ORDER.indexOf(currentTier);
+            const targetIdx = TIER_ORDER.indexOf(targetTier);
+            if (targetIdx < currentIdx) {
+                if (json)
+                    console.log(JSON.stringify({ error: 'downgrade_not_supported' }));
+                else
+                    p.log.error('Downgrades are not available through the CLI. Visit the dashboard to change your plan.');
+                process.exit(1);
+            }
+            if (!json && !yes) {
+                const lines = [
+                    `${label('Current plan')}${TIER_LIMITS[currentTier].label}`,
+                    `${label('New plan')}${TIER_LIMITS[targetTier].label} (${formatPrice(targetTier)})`,
+                ];
+                console.log(panel(lines, { title: `Upgrade to ${TIER_LIMITS[targetTier].label}`, width: 44 }));
+                const confirmed = await p.confirm({
+                    message: `Confirm upgrade to ${TIER_LIMITS[targetTier].label}?`,
+                });
+                if (isCancel(confirmed) || !confirmed) {
+                    p.cancel('Cancelled.');
+                    return;
+                }
+            }
+            const spin = p.spinner();
+            if (!json)
+                spin.start('Initiating checkout');
+            const result = await client.subscribe({
+                plan: targetTier,
+                email: session.email,
+                callbackUrl: LIFE_CALLBACK_URL,
+            });
+            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 in your browser 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);
+            }
+            catch (pollErr) {
+                if (!json)
+                    pollSpin.stop('Failed');
+                throw pollErr;
+            }
+            if (pollResult.status === 'success') {
+                if (!json) {
+                    pollSpin.stop('Payment confirmed');
+                    p.log.success(`Plan upgraded to ${brand.primary(TIER_LIMITS[targetTier].label)}`);
+                }
+                else {
+                    console.log(JSON.stringify({ verified: true, plan: targetTier }));
+                }
+            }
+            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}`));
+                    p.log.message(brand.muted(`Run ${brand.accent('cubelife billing')} to check your current plan.`));
+                }
+                else {
+                    console.log(JSON.stringify({ error: 'timeout', reference: result.reference }));
+                }
+            }
+            else {
+                if (!json) {
+                    pollSpin.stop('Payment not completed');
+                    p.log.error(`Payment ${pollResult.status}. Run ${brand.accent(`cubelife billing upgrade ${targetTier}`)} to try again.`);
+                }
+                else {
+                    console.log(JSON.stringify({ error: pollResult.status }));
+                }
+            }
+        }
+        catch (err) {
+            handleCommandError({ error: err, json });
+        }
+    });
+}
+function featureRow(featureLabel, getValue, currentTier) {
+    const lbl = brand.label(('  ' + featureLabel).padEnd(14));
+    const values = TIER_ORDER.map((t) => {
+        const val = getValue(t).padEnd(14);
+        return t === currentTier ? brand.primary(val) : val;
+    }).join('');
+    return lbl + values;
+}

package/dist/commands/creature.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCreatureCommands(program: Command): void;