cubelife 0.2.0

package/dist/lib/integration.js

@@ -0,0 +1,337 @@
+import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { API_BASE_URL } from './constants.js';
+const HOOKS_DIR = join(homedir(), '.cubelife', 'hooks');
+const API_URL = `${API_BASE_URL}/api/v1/state`;
+export async function readJsonConfig(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = await readFile(path, 'utf-8');
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return {};
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeJsonConfig(path, config) {
+    const dir = resolve(path, '..');
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeFile(path, JSON.stringify(config, null, 2) + '\n');
+}
+function resolveCliCommand() {
+    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        const binPath = execSync(`${whichCmd} cubelife`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim().split('\n')[0];
+        if (binPath)
+            return { command: binPath, args: ['mcp'] };
+    }
+    catch { /* not on PATH */ }
+    const scriptPath = resolve(process.argv[1]);
+    const isNpxCache = scriptPath.includes('.npm/_npx') || scriptPath.includes('npx');
+    if (isNpxCache) {
+        try {
+            const npxPath = execSync(`${whichCmd} npx`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim().split('\n')[0];
+            if (npxPath)
+                return { command: npxPath, args: ['cubelife', 'mcp'] };
+        }
+        catch { /* npx not found either */ }
+    }
+    return { command: process.execPath, args: [scriptPath, 'mcp'] };
+}
+export function buildMcpEntryWithAgent(agentId) {
+    const { command, args } = resolveCliCommand();
+    return { command, args, env: { CUBELIFE_AGENT_ID: agentId } };
+}
+export function mergeMcpServerEntry(existing, serverKey, entry) {
+    const servers = (existing[serverKey] ?? {});
+    const replaced = !!servers['cubelife'];
+    return {
+        config: {
+            ...existing,
+            [serverKey]: { ...servers, cubelife: entry },
+        },
+        replaced,
+    };
+}
+export async function readYamlConfig(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = await readFile(path, 'utf-8');
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return {};
+        return (parseYaml(trimmed) ?? {});
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeYamlConfig(path, config) {
+    const dir = resolve(path, '..');
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeFile(path, stringifyYaml(config, { lineWidth: 0 }));
+}
+export function mergeContinueMcpServer(existing, entry) {
+    const servers = (existing['mcpServers'] ?? []);
+    const idx = servers.findIndex((s) => s.name === 'cubelife');
+    const replaced = idx >= 0;
+    const filtered = replaced ? servers.filter((_, i) => i !== idx) : [...servers];
+    filtered.push(entry);
+    return {
+        config: { ...existing, mcpServers: filtered },
+        replaced,
+    };
+}
+export function buildContinueMcpEntry(agentId) {
+    const { command, args } = resolveCliCommand();
+    return { name: 'cubelife', command, args, env: { CUBELIFE_AGENT_ID: agentId } };
+}
+export async function hasStaleContinueEntry(configPath) {
+    const config = await readYamlConfig(configPath);
+    const servers = (config['mcpServers'] ?? []);
+    return servers.some((s) => s.name === 'cubelife');
+}
+export async function removeContinueEntry(configPath) {
+    const config = await readYamlConfig(configPath);
+    const servers = (config['mcpServers'] ?? []);
+    const filtered = servers.filter((s) => s.name !== 'cubelife');
+    await writeYamlConfig(configPath, { ...config, mcpServers: filtered });
+}
+export async function hasStaleMcpEntry(configPath, serverKey = 'mcpServers') {
+    const config = await readJsonConfig(configPath);
+    const servers = config[serverKey];
+    return !!servers?.['cubelife'];
+}
+export async function removeMcpEntry(configPath, serverKey = 'mcpServers') {
+    const config = await readJsonConfig(configPath);
+    const servers = config[serverKey];
+    if (servers?.['cubelife']) {
+        delete servers['cubelife'];
+        await writeJsonConfig(configPath, config);
+    }
+}
+export function hookScriptPath() {
+    if (process.platform === 'win32') {
+        return join(HOOKS_DIR, 'cubelife-hook.ps1');
+    }
+    return join(HOOKS_DIR, 'cubelife-hook.sh');
+}
+export function generateHookScript() {
+    if (process.platform === 'win32') {
+        return generatePowerShellScript();
+    }
+    return generateBashScript();
+}
+function generateBashScript() {
+    const lines = [
+        '#!/usr/bin/env bash',
+        '# Auto-generated by cubelife setup claude-code. Do not edit manually.',
+        "# Re-run 'cubelife setup claude-code' to regenerate.",
+        'STATE="${1:-idle}"',
+        'DETAIL="${2:-}"',
+        'CONFIG=".cubelife/config.json"',
+        'AGENTS="$HOME/.cubelife/agents.json"',
+        '[[ ! -f "${CONFIG}" || ! -f "${AGENTS}" ]] && exit 0',
+        "AGENT_ID=$(jq -r '.agentId' \"${CONFIG}\" 2>/dev/null)",
+        'API_KEY=$(jq -r ".agents[\\"${AGENT_ID}\\"].key" "${AGENTS}" 2>/dev/null)',
+        '[[ -z "${API_KEY}" || "${API_KEY}" == "null" ]] && exit 0',
+        'BODY="{\\"state\\":\\"${STATE}\\"}"',
+        '[[ -n "${DETAIL}" ]] && BODY="{\\"state\\":\\"${STATE}\\",\\"detail\\":\\"${DETAIL}\\"}"',
+        `curl -s --max-time 3 -X POST "${API_URL}" \\`,
+        '  -H "Content-Type: application/json" -H "X-Agent-Key: ${API_KEY}" -d "${BODY}" >/dev/null 2>&1',
+    ];
+    return lines.join('\n') + '\n';
+}
+function generatePowerShellScript() {
+    const lines = [
+        '# Auto-generated by cubelife setup claude-code. Do not edit manually.',
+        "# Re-run 'cubelife setup claude-code' to regenerate.",
+        'param([string]$State = "idle", [string]$Detail = "")',
+        '$config = Get-Content "$env:USERPROFILE\\.cubelife\\agents.json" | ConvertFrom-Json',
+        '$projConfig = Get-Content ".cubelife\\config.json" | ConvertFrom-Json',
+        '$key = $config.agents.($projConfig.agentId).key',
+        'if (-not $key) { exit 0 }',
+        '$body = @{ state = $State }',
+        'if ($Detail) { $body.detail = $Detail }',
+        `try { Invoke-RestMethod -Uri "${API_URL}" -Method POST -Headers @{ "Content-Type" = "application/json"; "X-Agent-Key" = $key } -Body ($body | ConvertTo-Json) -TimeoutSec 3 | Out-Null } catch {}`,
+    ];
+    return lines.join('\n') + '\n';
+}
+export async function writeHookScript() {
+    const path = hookScriptPath();
+    if (!existsSync(HOOKS_DIR)) {
+        await mkdir(HOOKS_DIR, { recursive: true });
+    }
+    await writeFile(path, generateHookScript(), 'utf-8');
+    if (process.platform !== 'win32') {
+        await chmod(path, 0o755);
+    }
+    return path;
+}
+export function buildMcpEntry() {
+    const { command, args } = resolveCliCommand();
+    return { command, args };
+}
+function hookCmd(state, detail) {
+    const isWin = process.platform === 'win32';
+    const prefix = isWin
+        ? 'powershell -File ~/.cubelife/hooks/cubelife-hook.ps1'
+        : 'bash ~/.cubelife/hooks/cubelife-hook.sh';
+    return detail ? `${prefix} ${state} '${detail}'` : `${prefix} ${state}`;
+}
+export function buildHookEntries() {
+    return {
+        PreToolUse: [
+            { matcher: 'Read', hooks: [{ type: 'command', command: hookCmd('reading', 'Reading file'), async: true }] },
+            { matcher: 'Glob|Grep', hooks: [{ type: 'command', command: hookCmd('researching', 'Searching codebase'), async: true }] },
+            { matcher: 'Edit|Write|NotebookEdit', hooks: [{ type: 'command', command: hookCmd('coding', 'Writing code'), async: true }] },
+            { matcher: 'Bash', hooks: [{ type: 'command', command: hookCmd('coding', 'Running command'), async: true }] },
+            { matcher: 'Task', hooks: [{ type: 'command', command: hookCmd('thinking', 'Planning next step'), async: true }] },
+            { matcher: 'WebFetch|WebSearch', hooks: [{ type: 'command', command: hookCmd('researching', 'Searching the web'), async: true }] },
+        ],
+        PermissionRequest: [
+            { hooks: [{ type: 'command', command: hookCmd('awaiting_input', 'Waiting for approval'), async: true }] },
+        ],
+        Stop: [
+            { hooks: [{ type: 'command', command: hookCmd('idle'), async: true }] },
+        ],
+    };
+}
+function isCubelifeHook(entry) {
+    return entry.hooks?.some((h) => h.command?.includes('cubelife-hook')) ?? false;
+}
+export function hasMcpServer(settings) {
+    return !!settings.mcpServers?.['cubelife'];
+}
+export function isClaudeMcpRegistered() {
+    try {
+        const output = execSync('claude mcp list 2>/dev/null', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
+        return output.includes('cubelife');
+    }
+    catch {
+        return false;
+    }
+}
+export function registerClaudeMcp(scope = 'user') {
+    const { command, args } = resolveCliCommand();
+    const replaced = isClaudeMcpRegistered();
+    if (replaced) {
+        try {
+            execSync('claude mcp remove cubelife', { stdio: 'ignore' });
+        }
+        catch { /* ignore */ }
+    }
+    const cmdArgs = ['claude', 'mcp', 'add', '--scope', scope, 'cubelife', '--', command, ...args];
+    execSync(cmdArgs.join(' '), { stdio: 'ignore' });
+    return { replaced };
+}
+export function isCodexMcpRegistered() {
+    const configPath = join(homedir(), '.codex', 'config.toml');
+    if (!existsSync(configPath))
+        return false;
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        return content.includes('[mcp_servers.cubelife]');
+    }
+    catch {
+        return false;
+    }
+}
+export function registerCodexMcp(agentId) {
+    const { command, args } = resolveCliCommand();
+    const replaced = isCodexMcpRegistered();
+    if (replaced) {
+        try {
+            execSync('codex mcp remove cubelife', { stdio: 'ignore' });
+        }
+        catch { /* ignore */ }
+    }
+    const cmdArgs = ['codex', 'mcp', 'add'];
+    if (agentId)
+        cmdArgs.push('--env', `CUBELIFE_AGENT_ID=${agentId}`);
+    cmdArgs.push('cubelife', '--', command, ...args);
+    execSync(cmdArgs.join(' '), { stdio: 'ignore' });
+    return { replaced };
+}
+export function hasHookIntegration(settings) {
+    return Object.values(settings.hooks ?? {}).some((entries) => entries.some(isCubelifeHook));
+}
+export function mergeSettings(existing, mode) {
+    const conflicts = [];
+    const result = { ...existing };
+    if (mode === 'mcp' || mode === 'both') {
+        if (!result.mcpServers)
+            result.mcpServers = {};
+        if (result.mcpServers['cubelife']) {
+            conflicts.push('Existing cubelife MCP entry updated');
+        }
+        result.mcpServers = { ...result.mcpServers, cubelife: buildMcpEntry() };
+    }
+    if (mode === 'hooks' || mode === 'both') {
+        if (!result.hooks)
+            result.hooks = {};
+        const hookDefs = buildHookEntries();
+        const merged = { ...result.hooks };
+        for (const [event, entries] of Object.entries(hookDefs)) {
+            const existingEntries = merged[event] ?? [];
+            const hadCubelife = existingEntries.some(isCubelifeHook);
+            if (hadCubelife) {
+                conflicts.push(`Existing cubelife hooks in ${event} updated`);
+            }
+            const filtered = existingEntries.filter((e) => !isCubelifeHook(e));
+            merged[event] = [...filtered, ...entries];
+        }
+        result.hooks = merged;
+    }
+    return { settings: result, conflicts };
+}
+export function resolveProjectRoot() {
+    try {
+        return execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+export async function readClaudeSettings(cwd) {
+    const path = resolve(cwd, '.claude', 'settings.json');
+    if (!existsSync(path))
+        return {};
+    try {
+        const raw = await readFile(path, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export async function writeClaudeSettings(cwd, settings) {
+    const dir = resolve(cwd, '.claude');
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeFile(resolve(dir, 'settings.json'), JSON.stringify(settings, null, 2) + '\n');
+}
+export function detectLegacySetup(cwd) {
+    const found = [];
+    const candidates = ['cubelife-agents.json', '.cubelife-agents.json', 'cubelife-hook.sh'];
+    for (const name of candidates) {
+        if (existsSync(join(cwd, name))) {
+            found.push(name);
+        }
+    }
+    return found;
+}

package/dist/lib/poll.d.ts

@@ -0,0 +1,11 @@
+import { type AdminClient, type VerifyResponse } from './api.js';
+export type PollStatus = 'success' | 'failed' | 'abandoned' | 'timeout';
+export interface PollResult {
+    status: PollStatus;
+    data?: VerifyResponse;
+}
+export interface PollOptions {
+    interval?: number;
+    timeout?: number;
+}
+export declare function pollVerification(client: AdminClient, reference: string, opts?: PollOptions): Promise<PollResult>;

package/dist/lib/poll.js

@@ -0,0 +1,31 @@
+import { ApiError } from './api.js';
+const TERMINAL_STATUSES = new Set(['failed', 'abandoned']);
+const RETRYABLE_HTTP_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+export async function pollVerification(client, reference, opts = {}) {
+    const interval = opts.interval ?? 5_000;
+    const timeout = opts.timeout ?? 300_000;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        try {
+            const data = await client.verifyPayment(reference);
+            return { status: 'success', data };
+        }
+        catch (err) {
+            if (err instanceof ApiError) {
+                // 400: backend returns "Transaction not successful status: <paystack_status>"
+                if (err.status === 400) {
+                    const statusMatch = err.message.match(/status[:\s]*(\w+)/i);
+                    const paystackStatus = statusMatch?.[1]?.toLowerCase();
+                    if (paystackStatus && TERMINAL_STATUSES.has(paystackStatus)) {
+                        return { status: paystackStatus };
+                    }
+                }
+                else if (!RETRYABLE_HTTP_STATUSES.has(err.status)) {
+                    throw err;
+                }
+            }
+        }
+        await new Promise((r) => setTimeout(r, interval));
+    }
+    return { status: 'timeout' };
+}

package/dist/lib/resolve.d.ts

@@ -0,0 +1 @@
+export declare function resolveProjectId(flagValue?: string): Promise<string | null>;

package/dist/lib/resolve.js

@@ -0,0 +1,10 @@
+import { readProjectConfig, readGlobalConfig } from './config.js';
+export async function resolveProjectId(flagValue) {
+    if (flagValue)
+        return flagValue;
+    const project = await readProjectConfig();
+    if (project?.projectId)
+        return project.projectId;
+    const global = await readGlobalConfig();
+    return global.defaults?.projectId ?? null;
+}

package/dist/lib/services/account-service.d.ts

@@ -0,0 +1,17 @@
+import type { AdminClient, Tier } from '../api.js';
+import { type DetectedTool } from '../detect.js';
+export interface AccountSummary {
+    tier: Tier;
+    tierLabel: string;
+    agentLimit: number;
+    usageToday: number;
+    usageLimit: number;
+    sparks: number;
+}
+export declare function fetchAccountSummary(client: AdminClient): Promise<AccountSummary>;
+export interface WhoamiInfo {
+    projectId: string | null;
+    agentId: string | null;
+    tools: DetectedTool[];
+}
+export declare function fetchLinkedInfo(): Promise<WhoamiInfo>;

package/dist/lib/services/account-service.js

@@ -0,0 +1,30 @@
+import { TIER_LIMITS, resolveTier } from '../api.js';
+import { readProjectConfig } from '../config.js';
+import { detectInstalledTools } from '../detect.js';
+export async function fetchAccountSummary(client) {
+    const billing = await client.getBillingUser();
+    const tier = resolveTier(billing.tier);
+    const limits = TIER_LIMITS[tier];
+    let usageToday = 0;
+    const usage = await client.getBillingUsage(1);
+    if (usage.length > 0) {
+        usageToday = usage[0].apiCalls;
+    }
+    return {
+        tier,
+        tierLabel: limits.label,
+        agentLimit: limits.agents,
+        usageToday,
+        usageLimit: limits.calls,
+        sparks: billing.sparks,
+    };
+}
+export async function fetchLinkedInfo() {
+    const config = await readProjectConfig();
+    const tools = detectInstalledTools();
+    return {
+        projectId: config?.projectId ?? null,
+        agentId: config?.agentId ?? null,
+        tools,
+    };
+}

package/dist/lib/services/agent-service.d.ts

@@ -0,0 +1,17 @@
+import type { AdminClient, AgentSummary, AgentResponse, CreateAgentBody, CreateAgentResponse, UpdateAgentBody } from '../api.js';
+import { type AgentsStore } from '../config.js';
+export interface AgentListResult {
+    agents: AgentSummary[];
+    linkedAgentId?: string;
+}
+export declare function listAgents(client: AdminClient, projectId: string): Promise<AgentListResult>;
+export declare function createAgent(client: AdminClient, projectId: string, body: CreateAgentBody): Promise<CreateAgentResponse>;
+export declare function linkAgent(projectId: string, agentId: string): Promise<void>;
+export declare function getAgent(client: AdminClient, projectId: string, agentId: string): Promise<AgentResponse>;
+export declare function updateAgent(client: AdminClient, projectId: string, agentId: string, updates: UpdateAgentBody): Promise<AgentResponse>;
+export interface DeleteAgentResult {
+    wasLinked: boolean;
+}
+export declare function deleteAgent(client: AdminClient, projectId: string, agentId: string): Promise<DeleteAgentResult>;
+export declare function regenerateKey(client: AdminClient, projectId: string, agentId: string): Promise<string>;
+export declare function getStoredKey(agentId: string, store: AgentsStore): string | null;

package/dist/lib/services/agent-service.js

@@ -0,0 +1,62 @@
+import { readAgents, writeAgents, readProjectConfig, writeProjectConfig, } from '../config.js';
+export async function listAgents(client, projectId) {
+    const { agents } = await client.listAgents(projectId);
+    const config = await readProjectConfig();
+    return { agents, linkedAgentId: config?.agentId };
+}
+export async function createAgent(client, projectId, body) {
+    const result = await client.createAgent(projectId, body);
+    const store = await readAgents();
+    store.agents[result.id] = {
+        key: result.apiKey,
+        name: result.name,
+        project: projectId,
+    };
+    await writeAgents(store);
+    return result;
+}
+export async function linkAgent(projectId, agentId) {
+    await writeProjectConfig({ projectId, agentId });
+}
+export async function getAgent(client, projectId, agentId) {
+    return client.getAgent(projectId, agentId);
+}
+export async function updateAgent(client, projectId, agentId, updates) {
+    const result = await client.updateAgent(projectId, agentId, updates);
+    if (updates.name) {
+        const store = await readAgents();
+        if (store.agents[agentId]) {
+            store.agents[agentId].name = updates.name;
+            await writeAgents(store);
+        }
+    }
+    return result;
+}
+export async function deleteAgent(client, projectId, agentId) {
+    await client.deleteAgent(projectId, agentId);
+    const store = await readAgents();
+    if (store.agents[agentId]) {
+        delete store.agents[agentId];
+        await writeAgents(store);
+    }
+    const config = await readProjectConfig();
+    const wasLinked = config?.agentId === agentId;
+    if (wasLinked && config) {
+        await writeProjectConfig({ ...config, agentId: '' });
+    }
+    return { wasLinked };
+}
+export async function regenerateKey(client, projectId, agentId) {
+    const result = await client.regenerateKey(projectId, agentId);
+    const store = await readAgents();
+    store.agents[agentId] = {
+        ...store.agents[agentId],
+        key: result.apiKey,
+        project: projectId,
+    };
+    await writeAgents(store);
+    return result.apiKey;
+}
+export function getStoredKey(agentId, store) {
+    return store.agents[agentId]?.key ?? null;
+}

package/dist/lib/services/creature-service.d.ts

@@ -0,0 +1,12 @@
+import type { AdminClient } from '../api.js';
+export declare class AgentNotCreatureError extends Error {
+    constructor();
+}
+export interface CreatureUpdateResult {
+    type: string;
+    color: string;
+    name?: string;
+}
+export declare function setCreatureType(client: AdminClient, projectId: string, agentId: string, type: string): Promise<CreatureUpdateResult>;
+export declare function setCreatureColour(client: AdminClient, projectId: string, agentId: string, colour: string): Promise<CreatureUpdateResult>;
+export declare function setCreatureName(client: AdminClient, projectId: string, agentId: string, name: string): Promise<CreatureUpdateResult>;

package/dist/lib/services/creature-service.js

@@ -0,0 +1,35 @@
+import { CREATURE_DEFAULT_COLORS } from '../constants.js';
+export class AgentNotCreatureError extends Error {
+    constructor() {
+        super('Agent is not in creature form');
+        this.name = 'AgentNotCreatureError';
+    }
+}
+export async function setCreatureType(client, projectId, agentId, type) {
+    const colour = CREATURE_DEFAULT_COLORS[type];
+    await client.updateAgent(projectId, agentId, {
+        form: 'creature',
+        creature: { type, color: colour },
+    });
+    return { type, color: colour };
+}
+export async function setCreatureColour(client, projectId, agentId, colour) {
+    const agent = await client.getAgent(projectId, agentId);
+    if (agent.form !== 'creature') {
+        throw new AgentNotCreatureError();
+    }
+    await client.updateAgent(projectId, agentId, {
+        creature: { type: agent.creature.type, color: colour },
+    });
+    return { type: agent.creature.type, color: colour };
+}
+export async function setCreatureName(client, projectId, agentId, name) {
+    const agent = await client.getAgent(projectId, agentId);
+    if (agent.form !== 'creature') {
+        throw new AgentNotCreatureError();
+    }
+    await client.updateAgent(projectId, agentId, {
+        creature: { type: agent.creature.type, color: agent.creature.color, name },
+    });
+    return { type: agent.creature.type, color: agent.creature.color, name };
+}

package/dist/lib/services/project-service.d.ts

@@ -0,0 +1,9 @@
+import type { AdminClient, ProjectSummary, ProjectResponse } from '../api.js';
+export interface ProjectListResult {
+    projects: ProjectSummary[];
+    linkedProjectId?: string;
+}
+export declare function listProjects(client: AdminClient): Promise<ProjectListResult>;
+export declare function createProject(client: AdminClient, name: string): Promise<ProjectResponse>;
+export declare function setDefaultProject(projectId: string): Promise<void>;
+export declare function deleteProject(client: AdminClient, id: string): Promise<void>;

package/dist/lib/services/project-service.js

@@ -0,0 +1,22 @@
+import { readProjectConfig, readGlobalConfig, writeGlobalConfig, } from '../config.js';
+export async function listProjects(client) {
+    const { projects } = await client.listProjects();
+    const config = await readProjectConfig();
+    return { projects, linkedProjectId: config?.projectId };
+}
+export async function createProject(client, name) {
+    return client.createProject(name);
+}
+export async function setDefaultProject(projectId) {
+    const config = await readGlobalConfig();
+    config.defaults = { ...config.defaults, projectId };
+    await writeGlobalConfig(config);
+}
+export async function deleteProject(client, id) {
+    await client.deleteProject(id);
+    const config = await readGlobalConfig();
+    if (config.defaults?.projectId === id) {
+        config.defaults.projectId = undefined;
+        await writeGlobalConfig(config);
+    }
+}

package/dist/lib/tutorial.d.ts

@@ -0,0 +1,12 @@
+export declare function detectProgress(): Promise<number>;
+export declare function stepAccount(): Promise<void>;
+export declare function stepProject(): Promise<string>;
+export declare function stepAgent(projectId: string): Promise<{
+    agentId: string;
+    form: 'human' | 'creature';
+    apiKey: string;
+}>;
+export declare function stepAppearance(projectId: string, agentId: string, form: 'human' | 'creature'): Promise<void>;
+export declare function stepIntegration(): Promise<void>;
+export declare function stepVerify(apiKey: string): Promise<void>;
+export declare function runTutorial(): Promise<void>;