cubelife 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { brand, status, dot, label, heading, dim } from './ui/index.js';
+export { logo, sectionHeader, version } from './ui/index.js';
+export { panel } from './ui/index.js';
+export { table } from './ui/index.js';
+export { renderSprite, textFallback } from './ui/index.js';
+export { readGlobalConfig, writeGlobalConfig, readAgents, writeAgents, readProjectConfig, writeProjectConfig, hasAuth, isTokenExpired, } from './lib/index.js';
+export type { GlobalConfig, AuthConfig, AgentEntry, AgentsStore, ProjectConfig, } from './lib/index.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { brand, status, dot, label, heading, dim } from './ui/index.js';
+export { logo, sectionHeader, version } from './ui/index.js';
+export { panel } from './ui/index.js';
+export { table } from './ui/index.js';
+export { renderSprite, textFallback } from './ui/index.js';
+export { readGlobalConfig, writeGlobalConfig, readAgents, writeAgents, readProjectConfig, writeProjectConfig, hasAuth, isTokenExpired, } from './lib/index.js';

package/dist/lib/api.d.ts

@@ -0,0 +1,162 @@
+export declare class ApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export type Tier = 'free' | 'standard' | 'pro';
+export interface BillingUser {
+    tier: Tier;
+    sparks: number;
+    dormancyState: string;
+    starterPackClaimed?: boolean;
+    locale?: string;
+}
+export interface UsageDay {
+    date: string;
+    eventsProcessed: number;
+    messagesSent: number;
+    sparksUsed: number;
+    apiCalls: number;
+}
+export interface BillingHistoryItem {
+    id: string;
+    type: 'subscription' | 'spark_topup' | 'starter_pack' | 'cosmetic';
+    product: 'world' | 'life';
+    amount: number;
+    currency: string;
+    sparks: number | null;
+    status: 'success' | 'failed';
+    paystackReference: string;
+    createdAt: string;
+}
+export interface SubscribeRequest {
+    plan: string;
+    email: string;
+    callbackUrl: string;
+}
+export interface SubscribeResponse {
+    authorisationUrl: string;
+    reference: string;
+    accessCode: string;
+}
+export interface VerifyResponse {
+    verified: boolean;
+    plan: string;
+}
+export interface ProjectSummary {
+    id: string;
+    name: string;
+    product: string;
+    ownerId: string;
+    createdAt: string;
+}
+export interface ProjectListResponse {
+    projects: ProjectSummary[];
+}
+export interface ProjectResponse {
+    id: string;
+    name: string;
+    product: string;
+}
+export interface AgentResponse {
+    id: string;
+    name: string;
+    form: 'human' | 'creature';
+    character?: Record<string, unknown>;
+    creature?: {
+        type: string;
+        color: string;
+        name?: string;
+    };
+    isPublic: boolean;
+    createdAt: string;
+}
+export type AgentSummary = AgentResponse;
+export interface AgentListResponse {
+    agents: AgentSummary[];
+}
+export interface CreateAgentBody {
+    name: string;
+    form?: 'human' | 'creature';
+    creature?: {
+        type: string;
+        color?: string;
+        name?: string;
+    };
+}
+export interface UpdateAgentBody {
+    name?: string;
+    isPublic?: boolean;
+    form?: 'human' | 'creature';
+    creature?: {
+        type: string;
+        color?: string;
+        name?: string;
+    };
+}
+export interface CreateAgentResponse {
+    id: string;
+    name: string;
+    apiKey: string;
+    roomId: string;
+}
+export interface RegenerateKeyResponse {
+    apiKey: string;
+}
+export interface ReportOptions {
+    detail?: string;
+    progress?: number;
+    sentiment?: 'positive' | 'negative' | 'neutral';
+}
+export interface AgentState {
+    state: string;
+    detail?: string;
+    progress?: number;
+    sentiment?: string;
+    updatedAt?: number;
+}
+export interface TierLimits {
+    agents: number;
+    calls: number;
+    label: string;
+    priceZarCents: number;
+    embedInstances: number;
+    customBranding: boolean;
+    analyticsHistory: number;
+    webhooks: boolean;
+}
+export declare const TIER_LIMITS: Record<Tier, TierLimits>;
+export declare function resolveTier(raw: string | undefined): Tier;
+export declare class AdminClient {
+    private readonly baseUrl;
+    private token;
+    constructor(token: string, baseUrl?: string);
+    private get headers();
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+    updateToken(token: string): void;
+    getBillingUser(): Promise<BillingUser>;
+    getBillingUsage(days?: number): Promise<UsageDay[]>;
+    getBillingHistory(limit?: number): Promise<BillingHistoryItem[]>;
+    subscribe(opts: SubscribeRequest): Promise<SubscribeResponse>;
+    verifyPayment(reference: string): Promise<VerifyResponse>;
+    listProjects(): Promise<ProjectListResponse>;
+    createProject(name: string): Promise<ProjectResponse>;
+    deleteProject(id: string): Promise<void>;
+    listAgents(projectId: string): Promise<AgentListResponse>;
+    getAgent(projectId: string, agentId: string): Promise<AgentResponse>;
+    createAgent(projectId: string, body: CreateAgentBody): Promise<CreateAgentResponse>;
+    updateAgent(projectId: string, agentId: string, body: UpdateAgentBody): Promise<AgentResponse>;
+    deleteAgent(projectId: string, agentId: string): Promise<void>;
+    regenerateKey(projectId: string, agentId: string): Promise<RegenerateKeyResponse>;
+}
+export declare class AgentClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(apiKey: string, baseUrl?: string);
+    private get headers();
+    report(state: string, options?: ReportOptions): Promise<{
+        rateLimited: boolean;
+    }>;
+    getState(): Promise<AgentState>;
+}
+export declare function createAdminClient(): Promise<AdminClient>;
+export declare function createAgentClient(agentIdOverride?: string): Promise<AgentClient | null>;

package/dist/lib/api.js

@@ -0,0 +1,160 @@
+import { getValidToken } from './auth.js';
+import { readAgents, readProjectConfig, resolveAgentKey } from './config.js';
+import { API_BASE_URL } from './constants.js';
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+export const TIER_LIMITS = {
+    free: {
+        agents: 2, calls: 1_000, label: 'Free', priceZarCents: 0,
+        embedInstances: 1, customBranding: false, analyticsHistory: 0, webhooks: false,
+    },
+    standard: {
+        agents: 10, calls: 10_000, label: 'Standard', priceZarCents: 20_000,
+        embedInstances: 5, customBranding: true, analyticsHistory: 7, webhooks: false,
+    },
+    pro: {
+        agents: 50, calls: 100_000, label: 'Pro', priceZarCents: 40_000,
+        embedInstances: -1, customBranding: true, analyticsHistory: 90, webhooks: true,
+    },
+};
+function isTier(value) {
+    return value in TIER_LIMITS;
+}
+export function resolveTier(raw) {
+    const tier = raw ?? 'free';
+    return isTier(tier) ? tier : 'free';
+}
+export class AdminClient {
+    baseUrl;
+    token;
+    constructor(token, baseUrl) {
+        this.baseUrl = baseUrl ?? API_BASE_URL;
+        this.token = token;
+    }
+    get headers() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.token}`,
+        };
+    }
+    async request(method, path, body) {
+        const res = await fetch(`${this.baseUrl}/api${path}`, {
+            method,
+            headers: this.headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new ApiError(res.status, err.error ?? 'Unknown error');
+        }
+        return res.json();
+    }
+    updateToken(token) {
+        this.token = token;
+    }
+    async getBillingUser() {
+        return this.request('GET', '/v1/billing/user');
+    }
+    async getBillingUsage(days = 7) {
+        const res = await this.request('GET', `/v1/billing/usage?days=${days}`);
+        return res.usage;
+    }
+    async getBillingHistory(limit = 10) {
+        const res = await this.request('GET', `/v1/billing/history?limit=${limit}`);
+        return res.history;
+    }
+    async subscribe(opts) {
+        return this.request('POST', '/v1/billing/subscribe', opts);
+    }
+    async verifyPayment(reference) {
+        return this.request('POST', '/v1/billing/verify', { reference });
+    }
+    async listProjects() {
+        return this.request('GET', '/v1/projects');
+    }
+    async createProject(name) {
+        return this.request('POST', '/v1/projects', { name, product: 'life' });
+    }
+    async deleteProject(id) {
+        await this.request('DELETE', `/v1/projects/${encodeURIComponent(id)}`);
+    }
+    async listAgents(projectId) {
+        return this.request('GET', `/v1/projects/${encodeURIComponent(projectId)}/agents`);
+    }
+    async getAgent(projectId, agentId) {
+        return this.request('GET', `/v1/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(agentId)}`);
+    }
+    async createAgent(projectId, body) {
+        return this.request('POST', `/v1/projects/${encodeURIComponent(projectId)}/agents`, body);
+    }
+    async updateAgent(projectId, agentId, body) {
+        return this.request('PATCH', `/v1/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(agentId)}`, body);
+    }
+    async deleteAgent(projectId, agentId) {
+        await this.request('DELETE', `/v1/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(agentId)}`);
+    }
+    async regenerateKey(projectId, agentId) {
+        return this.request('POST', `/v1/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(agentId)}/regenerate-key`);
+    }
+}
+export class AgentClient {
+    baseUrl;
+    apiKey;
+    constructor(apiKey, baseUrl) {
+        this.baseUrl = baseUrl ?? API_BASE_URL;
+        this.apiKey = apiKey;
+    }
+    get headers() {
+        return {
+            'Content-Type': 'application/json',
+            'X-Agent-Key': this.apiKey,
+        };
+    }
+    async report(state, options) {
+        const body = { state, ...options };
+        const res = await fetch(`${this.baseUrl}/api/v1/state`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        if (res.status === 429)
+            return { rateLimited: true };
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new ApiError(res.status, err.error ?? 'Unknown error');
+        }
+        return { rateLimited: false };
+    }
+    async getState() {
+        const res = await fetch(`${this.baseUrl}/api/v1/state`, {
+            method: 'GET',
+            headers: this.headers,
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new ApiError(res.status, err.error ?? 'Unknown error');
+        }
+        return res.json();
+    }
+}
+export async function createAdminClient() {
+    const token = await getValidToken();
+    return new AdminClient(token);
+}
+export async function createAgentClient(agentIdOverride) {
+    const agentId = agentIdOverride
+        ?? process.env['CUBELIFE_AGENT_ID']
+        ?? (await readProjectConfig())?.agentId;
+    if (!agentId)
+        return null;
+    const apiKey = process.env['CUBELIFE_API_KEY'] ?? resolveAgentKey(agentId, await readAgents());
+    if (!apiKey)
+        return null;
+    return new AgentClient(apiKey);
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,12 @@
+import { type AuthConfig } from './config.js';
+export declare function register(email: string, password: string): Promise<AuthConfig>;
+export declare function login(email: string, password: string): Promise<AuthConfig>;
+export declare function refreshToken(): Promise<AuthConfig>;
+export declare function getValidToken(): Promise<string>;
+export declare function logout(): Promise<void>;
+export declare function currentUser(): Promise<AuthConfig | null>;
+export interface AuthSession {
+    token: string;
+    email: string;
+}
+export declare function requireAuth(): Promise<AuthSession>;

package/dist/lib/auth.js

@@ -0,0 +1,113 @@
+import { readGlobalConfig, writeGlobalConfig, } from './config.js';
+const FIREBASE_API_KEY = 'AIzaSyDDn2cxnO3moce6wgXvVyRdGHjDDHGtx3g';
+const AUTH_BASE = 'https://identitytoolkit.googleapis.com/v1/accounts';
+async function firebaseAuth(endpoint, email, password) {
+    const url = `${AUTH_BASE}:${endpoint}?key=${FIREBASE_API_KEY}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password, returnSecureToken: true }),
+    });
+    if (!res.ok) {
+        const body = (await res.json());
+        const msg = body.error?.message ?? 'Authentication failed';
+        throw new Error(friendlyAuthError(msg));
+    }
+    return res.json();
+}
+function friendlyAuthError(code) {
+    const map = {
+        EMAIL_EXISTS: 'An account with this email already exists.',
+        EMAIL_NOT_FOUND: 'No account found with this email.',
+        INVALID_PASSWORD: 'Incorrect password.',
+        INVALID_LOGIN_CREDENTIALS: 'Invalid email or password.',
+        USER_DISABLED: 'This account has been disabled.',
+        TOO_MANY_ATTEMPTS_TRY_LATER: 'Too many attempts. Please try again later.',
+        WEAK_PASSWORD: 'Password must be at least 6 characters.',
+    };
+    return map[code] ?? `Authentication error: ${code}`;
+}
+function toAuthConfig(res) {
+    return {
+        email: res.email,
+        token: res.idToken,
+        refreshToken: res.refreshToken,
+        expiresAt: Date.now() + parseInt(res.expiresIn, 10) * 1000,
+    };
+}
+export async function register(email, password) {
+    const res = await firebaseAuth('signUp', email, password);
+    const auth = toAuthConfig(res);
+    const config = await readGlobalConfig();
+    config.auth = auth;
+    await writeGlobalConfig(config);
+    return auth;
+}
+export async function login(email, password) {
+    const res = await firebaseAuth('signInWithPassword', email, password);
+    const auth = toAuthConfig(res);
+    const config = await readGlobalConfig();
+    config.auth = auth;
+    await writeGlobalConfig(config);
+    return auth;
+}
+export async function refreshToken() {
+    const config = await readGlobalConfig();
+    if (!config.auth?.refreshToken) {
+        throw new Error('Not logged in. Run `cubelife login` first.');
+    }
+    const url = `https://securetoken.googleapis.com/v1/token?key=${FIREBASE_API_KEY}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: config.auth.refreshToken,
+        }).toString(),
+    });
+    if (!res.ok) {
+        throw new Error('Token refresh failed. Run `cubelife login` to re-authenticate.');
+    }
+    const body = (await res.json());
+    const auth = {
+        email: config.auth.email,
+        token: body.id_token,
+        refreshToken: body.refresh_token,
+        expiresAt: Date.now() + parseInt(body.expires_in, 10) * 1000,
+    };
+    config.auth = auth;
+    await writeGlobalConfig(config);
+    return auth;
+}
+export async function getValidToken() {
+    const config = await readGlobalConfig();
+    if (!config.auth?.token) {
+        throw new Error('Not logged in. Run `cubelife login` first.');
+    }
+    if (Date.now() >= (config.auth.expiresAt ?? 0)) {
+        const refreshed = await refreshToken();
+        return refreshed.token;
+    }
+    return config.auth.token;
+}
+export async function logout() {
+    const config = await readGlobalConfig();
+    delete config.auth;
+    await writeGlobalConfig(config);
+}
+export async function currentUser() {
+    const config = await readGlobalConfig();
+    return config.auth ?? null;
+}
+export async function requireAuth() {
+    const config = await readGlobalConfig();
+    if (!config.auth?.token) {
+        throw new Error('Not logged in. Run `cubelife login` first.');
+    }
+    let token = config.auth.token;
+    if (Date.now() >= (config.auth.expiresAt ?? 0)) {
+        const refreshed = await refreshToken();
+        token = refreshed.token;
+    }
+    return { token, email: config.auth.email };
+}

package/dist/lib/browser.d.ts

@@ -0,0 +1 @@
+export declare function openBrowser(url: string): Promise<boolean>;

package/dist/lib/browser.js

@@ -0,0 +1,21 @@
+import { spawn } from 'node:child_process';
+export function openBrowser(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+            return Promise.resolve(false);
+        }
+    }
+    catch {
+        return Promise.resolve(false);
+    }
+    const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'cmd'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: 'ignore' });
+        child.on('error', () => resolve(false));
+        child.on('close', (code) => resolve(code === 0));
+    });
+}

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

@@ -0,0 +1,26 @@
+import type { Command } from 'commander';
+import * as p from '@clack/prompts';
+export interface RootOpts {
+    json?: boolean;
+    yes?: boolean;
+    agent?: string;
+    project?: string;
+}
+export declare function rootOpts(cmd: Command): RootOpts;
+export declare function getErrorMessage(err: unknown): string;
+export interface CommandErrorOptions {
+    error: unknown;
+    json?: boolean;
+    spinner?: ReturnType<typeof p.spinner>;
+    exitCode?: number;
+}
+export declare function handleCommandError(opts: CommandErrorOptions): never;
+export interface ResolvedProject {
+    projectId: string;
+}
+export declare function requireProject(cmd: Command, json?: boolean): Promise<ResolvedProject>;
+export interface ResolvedAgent {
+    projectId: string;
+    agentId: string;
+}
+export declare function requireLinkedAgent(json?: boolean): Promise<ResolvedAgent>;

package/dist/lib/command-helpers.js

@@ -0,0 +1,60 @@
+import * as p from '@clack/prompts';
+import { resolveProjectId } from './resolve.js';
+import { readProjectConfig } from './config.js';
+import { brand } from '../ui/theme.js';
+import { getRootOpts } from '../ui/helpers.js';
+export function rootOpts(cmd) {
+    return getRootOpts(cmd);
+}
+export function getErrorMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+export function handleCommandError(opts) {
+    const msg = getErrorMessage(opts.error);
+    if (opts.spinner && !opts.json) {
+        opts.spinner.stop('Failed');
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ error: msg }));
+    }
+    else {
+        p.log.error(msg);
+    }
+    process.exit(opts.exitCode ?? 1);
+}
+export async function requireProject(cmd, json) {
+    const projectFlag = cmd.parent?.opts().project;
+    let projectId;
+    try {
+        projectId = await resolveProjectId(projectFlag);
+    }
+    catch (err) {
+        handleCommandError({ error: err, json });
+    }
+    if (!projectId) {
+        const msg = `No project linked. Run ${brand.accent('cubelife init')} first.`;
+        if (json) {
+            console.log(JSON.stringify({ error: 'no_project_linked' }));
+        }
+        else {
+            p.log.error(msg);
+        }
+        process.exit(1);
+    }
+    return { projectId };
+}
+export async function requireLinkedAgent(json) {
+    const config = await readProjectConfig();
+    if (!config?.projectId || !config?.agentId) {
+        if (json) {
+            console.log(JSON.stringify({ error: 'no_agent_linked' }));
+        }
+        else {
+            p.log.error(`No agent linked. Run ${brand.accent('cubelife init')} first.`);
+        }
+        process.exit(1);
+    }
+    return { projectId: config.projectId, agentId: config.agentId };
+}

package/dist/lib/compositor.d.ts

@@ -0,0 +1,34 @@
+import { STATE_MANIFEST, CREATURE_MANIFEST } from '../data/sprite-data.js';
+export interface Colour {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface CreatureTraits {
+    type: string;
+    color: string;
+    name?: string;
+}
+export interface HumanTraits {
+    skinTone?: string;
+    outfit?: string;
+    outfitColor?: string;
+    hairStyle?: string;
+    hairColor?: string;
+    accessories?: string[];
+}
+export interface CompositeResult {
+    rgba: Uint8Array;
+    width: number;
+    height: number;
+}
+export declare function hexToColour(hex: string): Colour;
+export declare function applyTint(lumAlpha: Uint8Array, colour: Colour): Uint8Array;
+export declare function alphaBlend(dst: Uint8Array, src: Uint8Array): void;
+export declare function compositeCreature(creature: CreatureTraits, state: string, frameIndex: number): CompositeResult;
+export declare function compositeHuman(traits: HumanTraits, state: string, frameIndex: number): CompositeResult;
+export declare function getFrameCount(form: 'creature' | 'human', creatureType?: string, state?: string): number;
+export declare function getFps(form: 'creature' | 'human', creatureType?: string, state?: string): number;
+export declare function createDissolve(): Uint16Array;
+export declare function applyDissolve(from: Uint8Array, to: Uint8Array, order: Uint16Array, t: number): Uint8Array;
+export { STATE_MANIFEST, CREATURE_MANIFEST };