@cubelife/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivy Innovation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# @cubelife/sdk
+
+Node.js SDK for CubeLife. Give your AI agent a living pixel-art character.
+
+## Install
+
+```bash
+npm install @cubelife/sdk
+```
+
+## Quick Start
+
+```typescript
+import { CubeLifeClient } from '@cubelife/sdk';
+
+const client = new CubeLifeClient({ apiKey: 'your-agent-api-key' });
+
+// Report what your agent is doing
+await client.report('coding', { detail: 'Building the login page', sentiment: 'positive' });
+
+// Update progress
+await client.report('coding', { detail: 'Building the login page', progress: 0.5 });
+
+// Mark complete
+await client.report('complete', { detail: 'Login page shipped' });
+```
+
+## API
+
+### `CubeLifeClient`
+
+Agent-facing client using API key authentication.
+
+```typescript
+const client = new CubeLifeClient({ apiKey: 'your-key' });
+```
+
+**Methods:**
+
+- `report(state, options?)` - Report agent state (`coding`, `reading`, `researching`, `designing`, `testing`, `reviewing`, `thinking`, `writing`, `error`, `complete`, `waiting`, `awaiting_input`)
+- `getState()` - Get current agent state
+- `navigate(destination)` - Move agent to a different room
+- `customise(options)` - Update character appearance (outfit, skin tone, accessories)
+- `setCreature(type)` - Switch agent to a creature form
+
+### `CubeLifeAdmin`
+
+Management client using bearer token authentication.
+
+```typescript
+const admin = new CubeLifeAdmin();
+await admin.login('email', 'password');
+```
+
+**Methods:**
+
+- `login(email, password)` / `register(email, password)` - Authenticate
+- `createProject(name)` / `listProjects()` / `deleteProject(id)` - Project management
+- `createAgent(projectId, name)` / `listAgents(projectId)` / `deleteAgent(projectId, agentId)` - Agent management
+
+## Work States
+
+| State | Description |
+|-------|-------------|
+| `coding` | Writing or editing code |
+| `reading` | Reading documentation or code |
+| `researching` | Investigating solutions |
+| `designing` | Designing architecture or UI |
+| `testing` | Running or writing tests |
+| `reviewing` | Reviewing code or PRs |
+| `thinking` | Processing or reasoning |
+| `writing` | Writing docs or content |
+| `error` | Something went wrong |
+| `complete` | Task finished |
+| `waiting` | Waiting for external input |
+| `awaiting_input` | Waiting for user input |
+
+## Licence
+
+MIT

package/dist/admin.d.ts

@@ -0,0 +1,183 @@
+interface CubeLifeAdminOptions {
+    baseUrl?: string;
+}
+interface AuthTokens {
+    idToken: string;
+    refreshToken: string;
+    userId: string;
+    email: string;
+    expiresIn: number;
+}
+interface Project {
+    id: string;
+    name: string;
+    product: 'life' | 'world';
+    ownerId: string;
+    createdAt: unknown;
+}
+interface Character {
+    seed: number;
+    skinTone: string;
+    outfit: string;
+    outfitColor: string;
+    accessories: string[];
+}
+interface CreatureTraits {
+    type: string;
+    color: string;
+    name?: string;
+}
+interface Agent {
+    id: string;
+    name: string;
+    form?: 'human' | 'creature';
+    character: Character;
+    creature?: CreatureTraits;
+    createdAt: unknown;
+    apiKey?: string;
+    personality?: Personality | null;
+}
+interface Personality {
+    emotions: Record<string, number>;
+    traits: string[];
+    interests: string[];
+    ambition?: string | null;
+    aptitudes?: Record<string, number>;
+    quirks?: string[];
+    opinions?: Record<string, string>;
+}
+interface Room {
+    id: string;
+    type: string;
+    name: string;
+    theme: string;
+    ownerId: string | null;
+    layout: unknown;
+    decoration: Record<string, unknown>;
+    presentAgents: string[];
+    maxOccupancy: number;
+    createdAt: unknown;
+}
+interface ChestItem {
+    id: string;
+    catalogueId: string;
+    name: string;
+    sprite: string;
+}
+interface Possession {
+    id: string;
+    name: string;
+    sprite: string;
+    equipped: boolean;
+}
+interface Neighbourhood {
+    id: string;
+    typeId: string;
+    name: string;
+    index: number;
+    roomCount: number;
+    capacity: number;
+}
+interface WorldRoom {
+    id: string;
+    sourceProjectId: string;
+    sourceRoomId: string;
+    neighbourhoodId: string;
+    streetNumber: number;
+    visibility: string;
+    guestList?: string[];
+    membershipCost: number | null;
+    roomName: string | null;
+    roomType: string | null;
+    createdAt: unknown;
+}
+export declare class CubeLifeAdmin {
+    static readonly VERSION = "0.1.0";
+    private readonly baseUrl;
+    private idToken;
+    constructor(opts?: CubeLifeAdminOptions);
+    private get headers();
+    private request;
+    register(email: string, password: string): Promise<AuthTokens>;
+    login(email: string, password: string): Promise<AuthTokens>;
+    setToken(idToken: string): void;
+    createProject(name: string): Promise<Project>;
+    listProjects(): Promise<Project[]>;
+    getProject(projectId: string): Promise<Project>;
+    updateProject(projectId: string, name: string): Promise<Project>;
+    deleteProject(projectId: string): Promise<void>;
+    createAgent(projectId: string, name: string, character?: Partial<Character>, personality?: Personality, opts?: {
+        form?: 'human' | 'creature';
+        creature?: CreatureTraits;
+    }): Promise<Agent>;
+    listAgents(projectId: string): Promise<Agent[]>;
+    getAgent(projectId: string, agentId: string): Promise<Agent>;
+    updateAgent(projectId: string, agentId: string, updates: {
+        name?: string;
+        character?: Partial<Character>;
+        form?: 'human' | 'creature';
+        creature?: Partial<CreatureTraits>;
+    }): Promise<Agent>;
+    deleteAgent(projectId: string, agentId: string): Promise<void>;
+    regenerateKey(projectId: string, agentId: string): Promise<{
+        apiKey: string;
+    }>;
+    getPersonality(projectId: string, agentId: string): Promise<Personality>;
+    setPersonality(projectId: string, agentId: string, personality: Personality): Promise<Personality>;
+    updatePersonality(projectId: string, agentId: string, updates: Partial<Personality>): Promise<Personality>;
+    createRoom(projectId: string, opts: {
+        name: string;
+        type?: string;
+        theme?: string;
+    }): Promise<Room>;
+    listRooms(projectId: string): Promise<Room[]>;
+    getRoom(projectId: string, roomId: string): Promise<Room>;
+    updateRoom(projectId: string, roomId: string, updates: {
+        name?: string;
+        decoration?: Record<string, unknown>;
+        backgroundLayers?: {
+            wall: {
+                texture: string;
+                tint: string;
+            };
+            floor: {
+                texture: string;
+                tint: string;
+            };
+            furniture: string[];
+        } | null;
+    }): Promise<Room>;
+    deleteRoom(projectId: string, roomId: string): Promise<void>;
+    addToChest(projectId: string, roomId: string, item: {
+        catalogueId: string;
+        name: string;
+        sprite: string;
+    }): Promise<ChestItem>;
+    listChest(projectId: string, roomId: string): Promise<ChestItem[]>;
+    removeFromChest(projectId: string, roomId: string, itemId: string): Promise<void>;
+    listPossessions(projectId: string, agentId: string): Promise<Possession[]>;
+    givePossession(projectId: string, agentId: string, item: {
+        name: string;
+        category: string;
+        sprite: string;
+        catalogueId?: string;
+    }): Promise<Possession>;
+    removePossession(projectId: string, agentId: string, itemId: string): Promise<void>;
+    listNeighbourhoods(): Promise<Neighbourhood[]>;
+    getNeighbourhood(neighbourhoodId: string): Promise<Neighbourhood>;
+    listWorldRooms(neighbourhoodId: string): Promise<WorldRoom[]>;
+    getWorldRoom(worldRoomId: string): Promise<WorldRoom>;
+    /** World-product only. Returns 403 for life projects. */
+    updateWorldRoom(worldRoomId: string, updates: {
+        visibility?: string;
+        guestList?: string[];
+        membershipCost?: number | null;
+    }): Promise<WorldRoom>;
+    /** World-product only. Returns 403 for life projects. */
+    registerWorldRoom(projectId: string, roomId: string, typeId?: string, roomName?: string, roomType?: string): Promise<{
+        worldRoomId: string;
+        neighbourhoodId: string;
+        streetNumber: number;
+    }>;
+}
+export type { CubeLifeAdminOptions, AuthTokens, Project, Agent, Character, CreatureTraits, Personality, Room, ChestItem, Possession, Neighbourhood, WorldRoom, };

package/dist/admin.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CubeLifeAdmin = void 0;
+const version_1 = require("./version");
+const client_1 = require("./client");
+const DEFAULT_BASE_URL = 'https://cubelife-2dd2e.web.app';
+class CubeLifeAdmin {
+    static VERSION = version_1.SDK_VERSION;
+    baseUrl;
+    idToken = null;
+    constructor(opts) {
+        this.baseUrl = opts?.baseUrl || DEFAULT_BASE_URL;
+    }
+    get headers() {
+        const h = {
+            'Content-Type': 'application/json',
+            'User-Agent': `cubelife-admin-sdk/${CubeLifeAdmin.VERSION}`,
+        };
+        if (this.idToken) {
+            h['Authorization'] = `Bearer ${this.idToken}`;
+        }
+        return h;
+    }
+    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(() => ({}));
+            const message = err.error || 'Unknown error';
+            if (res.status === 429)
+                throw new client_1.RateLimitError(message);
+            throw new client_1.CubeLifeError(res.status, message);
+        }
+        return res.json();
+    }
+    // --- Auth ---
+    async register(email, password) {
+        const result = await this.request('POST', '/v1/auth/register', {
+            email,
+            password,
+        });
+        this.idToken = result.idToken;
+        return result;
+    }
+    async login(email, password) {
+        const result = await this.request('POST', '/v1/auth/login', {
+            email,
+            password,
+        });
+        this.idToken = result.idToken;
+        return result;
+    }
+    setToken(idToken) {
+        this.idToken = idToken;
+    }
+    // --- Projects ---
+    async createProject(name) {
+        return this.request('POST', '/v1/projects', { name });
+    }
+    async listProjects() {
+        const result = await this.request('GET', '/v1/projects');
+        return result.projects;
+    }
+    async getProject(projectId) {
+        return this.request('GET', `/v1/projects/${projectId}`);
+    }
+    async updateProject(projectId, name) {
+        return this.request('PATCH', `/v1/projects/${projectId}`, { name });
+    }
+    async deleteProject(projectId) {
+        await this.request('DELETE', `/v1/projects/${projectId}`);
+    }
+    // --- Agents ---
+    async createAgent(projectId, name, character, personality, opts) {
+        const body = { name };
+        if (character)
+            body.character = character;
+        if (personality)
+            body.personality = personality;
+        if (opts?.form)
+            body.form = opts.form;
+        if (opts?.creature)
+            body.creature = opts.creature;
+        return this.request('POST', `/v1/projects/${projectId}/agents`, body);
+    }
+    async listAgents(projectId) {
+        const result = await this.request('GET', `/v1/projects/${projectId}/agents`);
+        return result.agents;
+    }
+    async getAgent(projectId, agentId) {
+        return this.request('GET', `/v1/projects/${projectId}/agents/${agentId}`);
+    }
+    async updateAgent(projectId, agentId, updates) {
+        return this.request('PATCH', `/v1/projects/${projectId}/agents/${agentId}`, updates);
+    }
+    async deleteAgent(projectId, agentId) {
+        await this.request('DELETE', `/v1/projects/${projectId}/agents/${agentId}`);
+    }
+    async regenerateKey(projectId, agentId) {
+        return this.request('POST', `/v1/projects/${projectId}/agents/${agentId}/regenerate-key`);
+    }
+    // --- Personality ---
+    async getPersonality(projectId, agentId) {
+        return this.request('GET', `/v1/projects/${projectId}/agents/${agentId}/personality`);
+    }
+    async setPersonality(projectId, agentId, personality) {
+        return this.request('PUT', `/v1/projects/${projectId}/agents/${agentId}/personality`, personality);
+    }
+    async updatePersonality(projectId, agentId, updates) {
+        return this.request('PATCH', `/v1/projects/${projectId}/agents/${agentId}/personality`, updates);
+    }
+    // --- Rooms ---
+    async createRoom(projectId, opts) {
+        return this.request('POST', `/manage/v1/projects/${projectId}/rooms`, opts);
+    }
+    async listRooms(projectId) {
+        const result = await this.request('GET', `/manage/v1/projects/${projectId}/rooms`);
+        return result.rooms;
+    }
+    async getRoom(projectId, roomId) {
+        return this.request('GET', `/manage/v1/projects/${projectId}/rooms/${roomId}`);
+    }
+    async updateRoom(projectId, roomId, updates) {
+        return this.request('PATCH', `/manage/v1/projects/${projectId}/rooms/${roomId}`, updates);
+    }
+    async deleteRoom(projectId, roomId) {
+        await this.request('DELETE', `/manage/v1/projects/${projectId}/rooms/${roomId}`);
+    }
+    // --- Room Chest ---
+    async addToChest(projectId, roomId, item) {
+        return this.request('POST', `/manage/v1/projects/${projectId}/rooms/${roomId}/chest`, item);
+    }
+    async listChest(projectId, roomId) {
+        const result = await this.request('GET', `/manage/v1/projects/${projectId}/rooms/${roomId}/chest`);
+        return result.items;
+    }
+    async removeFromChest(projectId, roomId, itemId) {
+        await this.request('DELETE', `/manage/v1/projects/${projectId}/rooms/${roomId}/chest/${itemId}`);
+    }
+    // --- Possessions ---
+    async listPossessions(projectId, agentId) {
+        const result = await this.request('GET', `/manage/v1/projects/${projectId}/agents/${agentId}/possessions`);
+        return result.possessions;
+    }
+    async givePossession(projectId, agentId, item) {
+        return this.request('POST', `/manage/v1/projects/${projectId}/agents/${agentId}/possessions`, item);
+    }
+    async removePossession(projectId, agentId, itemId) {
+        await this.request('DELETE', `/manage/v1/projects/${projectId}/agents/${agentId}/possessions/${itemId}`);
+    }
+    // --- World Map (world-product only — returns 403 for life projects) ---
+    async listNeighbourhoods() {
+        const result = await this.request('GET', '/v1/world/neighbourhoods');
+        return result.neighbourhoods;
+    }
+    async getNeighbourhood(neighbourhoodId) {
+        return this.request('GET', `/v1/world/neighbourhoods/${neighbourhoodId}`);
+    }
+    async listWorldRooms(neighbourhoodId) {
+        const result = await this.request('GET', `/v1/world/neighbourhoods/${neighbourhoodId}/rooms`);
+        return result.rooms;
+    }
+    async getWorldRoom(worldRoomId) {
+        return this.request('GET', `/v1/world/rooms/${worldRoomId}`);
+    }
+    /** World-product only. Returns 403 for life projects. */
+    async updateWorldRoom(worldRoomId, updates) {
+        return this.request('PATCH', `/v1/world/rooms/${worldRoomId}`, updates);
+    }
+    /** World-product only. Returns 403 for life projects. */
+    async registerWorldRoom(projectId, roomId, typeId, roomName, roomType) {
+        return this.request('POST', '/v1/world/rooms/register', { projectId, roomId, typeId, roomName, roomType });
+    }
+}
+exports.CubeLifeAdmin = CubeLifeAdmin;

package/dist/client.d.ts

@@ -0,0 +1,68 @@
+type WorkState = 'coding' | 'reading' | 'researching' | 'designing' | 'testing' | 'reviewing' | 'thinking' | 'writing' | 'error' | 'complete' | 'waiting' | 'awaiting_input';
+type Sentiment = 'positive' | 'negative' | 'neutral';
+type OutfitStyle = 'default_tee' | 'shirt' | 'lab_coat' | 'hoodie' | 'dress' | 'sweater' | 'overalls';
+type AccessoryStyle = 'none' | 'glasses' | 'headphones' | 'cap' | 'beanie' | 'bandana' | 'scarf' | 'earrings';
+interface ReportOptions {
+    detail?: string;
+    progress?: number;
+    sentiment?: Sentiment;
+}
+interface CharacterOptions {
+    outfit?: OutfitStyle;
+    outfitColor?: string;
+    skinTone?: string;
+    accessories?: AccessoryStyle[];
+}
+interface NavigationResult {
+    ok: boolean;
+    roomId: string;
+    worldRoomId: string;
+    neighbourhoodId: string;
+    distance: number;
+    zone: string;
+}
+interface AgentState {
+    state: WorkState;
+    detail: string | null;
+    progress: number | null;
+    sentiment: Sentiment | null;
+    updatedAt: number | null;
+}
+interface CubeLifeOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+export declare class CubeLifeError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare class RateLimitError extends CubeLifeError {
+    constructor(message?: string);
+}
+export declare class CubeLifeClient {
+    static readonly VERSION = "0.1.0";
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(opts: CubeLifeOptions);
+    getState(): Promise<AgentState>;
+    report(state: WorkState, opts?: ReportOptions): Promise<void>;
+    coding(detail?: string, progress?: number): Promise<void>;
+    reading(detail?: string): Promise<void>;
+    researching(detail?: string): Promise<void>;
+    designing(detail?: string): Promise<void>;
+    testing(detail?: string, progress?: number): Promise<void>;
+    reviewing(detail?: string): Promise<void>;
+    thinking(detail?: string): Promise<void>;
+    writing(detail?: string): Promise<void>;
+    error(detail?: string): Promise<void>;
+    complete(detail?: string): Promise<void>;
+    waiting(detail?: string): Promise<void>;
+    awaitingInput(detail?: string): Promise<void>;
+    moveTo(roomId: string, zone?: string): Promise<void>;
+    /** World-product only. Returns 403 for life projects. */
+    navigateTo(worldRoomId: string, zone?: string): Promise<NavigationResult>;
+    updateCharacter(opts: CharacterOptions): Promise<void>;
+}
+type AgentForm = 'human' | 'creature';
+type HairStyle = 'none' | 'short' | 'long' | 'curly' | 'ponytail' | 'mohawk';
+export type { WorkState, Sentiment, ReportOptions, CubeLifeOptions, CharacterOptions, OutfitStyle, AccessoryStyle, NavigationResult, AgentState, AgentForm, HairStyle };

package/dist/client.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CubeLifeClient = exports.RateLimitError = exports.CubeLifeError = void 0;
+const version_1 = require("./version");
+const DEFAULT_BASE_URL = 'https://cubelife-2dd2e.web.app';
+class CubeLifeError extends Error {
+    status;
+    constructor(status, message) {
+        super(`CubeLife API error ${status}: ${message}`);
+        this.name = 'CubeLifeError';
+        this.status = status;
+    }
+}
+exports.CubeLifeError = CubeLifeError;
+class RateLimitError extends CubeLifeError {
+    constructor(message = 'Rate limit exceeded') {
+        super(429, message);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+function throwApiError(status, errorMessage) {
+    if (status === 429)
+        throw new RateLimitError(errorMessage);
+    throw new CubeLifeError(status, errorMessage);
+}
+class CubeLifeClient {
+    static VERSION = version_1.SDK_VERSION;
+    apiKey;
+    baseUrl;
+    constructor(opts) {
+        this.apiKey = opts.apiKey;
+        this.baseUrl = opts.baseUrl || DEFAULT_BASE_URL;
+    }
+    async getState() {
+        const res = await fetch(`${this.baseUrl}/api/v1/state`, {
+            method: 'GET',
+            headers: {
+                'X-Agent-Key': this.apiKey,
+                'User-Agent': `cubelife-sdk/${CubeLifeClient.VERSION}`,
+            },
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throwApiError(res.status, err.error || 'Unknown error');
+        }
+        return res.json();
+    }
+    async report(state, opts) {
+        const body = { state };
+        if (opts?.detail)
+            body.detail = opts.detail;
+        if (opts?.progress !== undefined)
+            body.progress = opts.progress;
+        if (opts?.sentiment)
+            body.sentiment = opts.sentiment;
+        const res = await fetch(`${this.baseUrl}/api/v1/state`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Agent-Key': this.apiKey,
+                'User-Agent': `cubelife-sdk/${CubeLifeClient.VERSION}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throwApiError(res.status, err.error || 'Unknown error');
+        }
+    }
+    async coding(detail, progress) {
+        return this.report('coding', { detail, progress });
+    }
+    async reading(detail) {
+        return this.report('reading', { detail });
+    }
+    async researching(detail) {
+        return this.report('researching', { detail });
+    }
+    async designing(detail) {
+        return this.report('designing', { detail });
+    }
+    async testing(detail, progress) {
+        return this.report('testing', { detail, progress });
+    }
+    async reviewing(detail) {
+        return this.report('reviewing', { detail });
+    }
+    async thinking(detail) {
+        return this.report('thinking', { detail });
+    }
+    async writing(detail) {
+        return this.report('writing', { detail });
+    }
+    async error(detail) {
+        return this.report('error', { detail, sentiment: 'negative' });
+    }
+    async complete(detail) {
+        return this.report('complete', { detail, sentiment: 'positive' });
+    }
+    async waiting(detail) {
+        return this.report('waiting', { detail });
+    }
+    async awaitingInput(detail) {
+        return this.report('awaiting_input', { detail });
+    }
+    async moveTo(roomId, zone) {
+        const body = { roomId };
+        if (zone)
+            body.zone = zone;
+        const res = await fetch(`${this.baseUrl}/api/v1/location`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Agent-Key': this.apiKey,
+                'User-Agent': `cubelife-sdk/${CubeLifeClient.VERSION}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throwApiError(res.status, err.error || 'Unknown error');
+        }
+    }
+    /** World-product only. Returns 403 for life projects. */
+    async navigateTo(worldRoomId, zone) {
+        const body = { worldRoomId };
+        if (zone)
+            body.zone = zone;
+        const res = await fetch(`${this.baseUrl}/api/v1/navigate`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Agent-Key': this.apiKey,
+                'User-Agent': `cubelife-sdk/${CubeLifeClient.VERSION}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throwApiError(res.status, err.error || 'Unknown error');
+        }
+        return res.json();
+    }
+    async updateCharacter(opts) {
+        const res = await fetch(`${this.baseUrl}/api/v1/character`, {
+            method: 'PATCH',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Agent-Key': this.apiKey,
+                'User-Agent': `cubelife-sdk/${CubeLifeClient.VERSION}`,
+            },
+            body: JSON.stringify(opts),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throwApiError(res.status, err.error || 'Unknown error');
+        }
+    }
+}
+exports.CubeLifeClient = CubeLifeClient;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { CubeLifeClient, CubeLifeError, RateLimitError } from './client';
+export type { WorkState, Sentiment, ReportOptions, CubeLifeOptions, CharacterOptions, OutfitStyle, AccessoryStyle, NavigationResult, AgentState, AgentForm, HairStyle, } from './client';
+export { CubeLifeAdmin } from './admin';
+export type { CubeLifeAdminOptions, AuthTokens, Project, Agent, Character, CreatureTraits, Personality, Room, ChestItem, Possession, Neighbourhood, WorldRoom, } from './admin';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CubeLifeAdmin = exports.RateLimitError = exports.CubeLifeError = exports.CubeLifeClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "CubeLifeClient", { enumerable: true, get: function () { return client_1.CubeLifeClient; } });
+Object.defineProperty(exports, "CubeLifeError", { enumerable: true, get: function () { return client_1.CubeLifeError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return client_1.RateLimitError; } });
+var admin_1 = require("./admin");
+Object.defineProperty(exports, "CubeLifeAdmin", { enumerable: true, get: function () { return admin_1.CubeLifeAdmin; } });

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "0.1.0";

package/dist/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+exports.SDK_VERSION = '0.1.0';

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@cubelife/sdk",
+  "version": "0.1.0",
+  "description": "SDK for CubeLife — give your AI agent a living pixel-art character",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "pixel-art",
+    "character",
+    "visualization"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AndriesJacobus/CubeWorld.git",
+    "directory": "sdk"
+  },
+  "homepage": "https://life.cubeworld.co.za",
+  "bugs": "https://github.com/AndriesJacobus/CubeWorld/issues",
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  }
+}