cubelife 0.2.0

package/dist/lib/doctor.js

@@ -0,0 +1,321 @@
+import { existsSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { currentUser, refreshToken } from './auth.js';
+import { readProjectConfig, readAgents, resolveAgentKey } from './config.js';
+import { createAdminClient, AgentClient, TIER_LIMITS } from './api.js';
+import { detectInstalledTools } from './detect.js';
+import { readClaudeSettings, hasMcpServer, hasHookIntegration, hookScriptPath, resolveProjectRoot, isClaudeMcpRegistered } from './integration.js';
+import { API_BASE_URL, API_TIMEOUT_MS, ID_DISPLAY_LENGTH } from './constants.js';
+export async function checkAuth(autoFix) {
+    const user = await currentUser();
+    if (!user) {
+        return {
+            name: 'Auth',
+            status: 'fail',
+            message: 'Not logged in',
+            fix: 'Run cubelife login to authenticate.',
+        };
+    }
+    const expired = Date.now() >= (user.expiresAt ?? 0);
+    if (expired && autoFix) {
+        try {
+            await refreshToken();
+            return { name: 'Auth', status: 'pass', message: `Token refreshed for ${user.email}` };
+        }
+        catch {
+            return {
+                name: 'Auth',
+                status: 'fail',
+                message: 'Token expired and refresh failed',
+                fix: 'Run cubelife login to re-authenticate.',
+            };
+        }
+    }
+    if (expired) {
+        return {
+            name: 'Auth',
+            status: 'warn',
+            message: 'Token expired',
+            fix: 'Run cubelife doctor --fix to refresh, or cubelife login to re-authenticate.',
+        };
+    }
+    return { name: 'Auth', status: 'pass', message: `Logged in as ${user.email}` };
+}
+export async function checkTier(adminClient) {
+    try {
+        const client = adminClient ?? await createAdminClient();
+        const billing = await client.getBillingUser();
+        const tier = billing.tier;
+        const limits = TIER_LIMITS[tier];
+        const usage = await client.getBillingUsage(1);
+        const today = usage[0];
+        if (today) {
+            const pct = limits.calls > 0 ? (today.eventsProcessed / limits.calls) * 100 : 0;
+            if (pct > 80) {
+                return {
+                    name: 'Tier',
+                    status: 'warn',
+                    message: `${limits.label} tier, ${Math.round(pct)}% of daily limit used (${today.eventsProcessed}/${limits.calls})`,
+                };
+            }
+            return {
+                name: 'Tier',
+                status: 'pass',
+                message: `${limits.label} tier, ${today.eventsProcessed}/${limits.calls} calls today`,
+            };
+        }
+        return { name: 'Tier', status: 'pass', message: `${limits.label} tier` };
+    }
+    catch (err) {
+        return {
+            name: 'Tier',
+            status: 'warn',
+            message: `Could not fetch billing info: ${err.message}`,
+        };
+    }
+}
+export async function checkProject(adminClient) {
+    const config = await readProjectConfig();
+    if (!config?.projectId) {
+        return {
+            name: 'Project',
+            status: 'fail',
+            message: 'No project linked',
+            fix: 'Run cubelife init or cubelife tutorial to link a project.',
+        };
+    }
+    try {
+        const client = adminClient ?? await createAdminClient();
+        const { projects } = await client.listProjects();
+        const found = projects.find((p) => p.id === config.projectId);
+        if (!found) {
+            return {
+                name: 'Project',
+                status: 'fail',
+                message: `Project ${config.projectId.slice(0, ID_DISPLAY_LENGTH)} not found on server`,
+                fix: 'Run cubelife init to link a different project.',
+            };
+        }
+        return { name: 'Project', status: 'pass', message: `${found.name} (${config.projectId.slice(0, ID_DISPLAY_LENGTH)})` };
+    }
+    catch (err) {
+        return {
+            name: 'Project',
+            status: 'warn',
+            message: `Project config present but could not verify: ${err.message}`,
+        };
+    }
+}
+export async function checkAgent(adminClient) {
+    const config = await readProjectConfig();
+    if (!config?.projectId || !config?.agentId) {
+        return {
+            name: 'Agent',
+            status: 'fail',
+            message: 'No agent linked',
+            fix: 'Run cubelife init or cubelife tutorial to create an agent.',
+        };
+    }
+    try {
+        const client = adminClient ?? await createAdminClient();
+        const agent = await client.getAgent(config.projectId, config.agentId);
+        return {
+            name: 'Agent',
+            status: 'pass',
+            message: `${agent.name} (${agent.form})`,
+        };
+    }
+    catch {
+        return {
+            name: 'Agent',
+            status: 'fail',
+            message: 'Agent ID in config but not found on server',
+            fix: 'Run cubelife init to link a different agent.',
+        };
+    }
+}
+export async function checkApiKey() {
+    const config = await readProjectConfig();
+    if (!config?.agentId) {
+        return {
+            name: 'API Key',
+            status: 'fail',
+            message: 'No agent linked',
+            fix: 'Run cubelife init or cubelife tutorial first.',
+        };
+    }
+    const store = await readAgents();
+    const key = resolveAgentKey(config.agentId, store);
+    if (!key) {
+        return {
+            name: 'API Key',
+            status: 'fail',
+            message: 'No API key found for linked agent',
+            fix: 'Run cubelife agents key <id> --regenerate to get a new key.',
+        };
+    }
+    try {
+        const client = new AgentClient(key);
+        await client.getState();
+        return { name: 'API Key', status: 'pass', message: 'Valid (state read succeeded)' };
+    }
+    catch {
+        return {
+            name: 'API Key',
+            status: 'warn',
+            message: 'Key present but state read failed (may be a network issue)',
+        };
+    }
+}
+export async function checkIntegration() {
+    const tools = detectInstalledTools();
+    if (tools.length === 0) {
+        return {
+            name: 'Integration',
+            status: 'warn',
+            message: 'No AI tools detected',
+            fix: 'Run cubelife setup <tool> after installing an AI coding tool.',
+        };
+    }
+    const root = resolveProjectRoot();
+    const issues = [];
+    const configured = [];
+    const claudeCode = tools.find((t) => t.id === 'claude-code');
+    if (claudeCode) {
+        const settings = await readClaudeSettings(root);
+        const globalSettings = await readClaudeSettings(homedir());
+        const hasMcp = isClaudeMcpRegistered() || hasMcpServer(settings) || hasMcpServer(globalSettings);
+        const hasHooks = hasHookIntegration(settings) || hasHookIntegration(globalSettings);
+        if (hasMcp && hasHooks) {
+            configured.push('Claude Code (MCP + Hooks)');
+        }
+        else if (hasMcp) {
+            configured.push('Claude Code (MCP only)');
+            issues.push('Claude Code hooks not configured (hooks-only mode available)');
+        }
+        else if (hasHooks) {
+            configured.push('Claude Code (Hooks only)');
+            issues.push('Claude Code MCP not configured');
+        }
+        else {
+            issues.push('Claude Code detected but not configured');
+        }
+    }
+    const others = tools.filter((t) => t.id !== 'claude-code');
+    for (const t of others) {
+        issues.push(`${t.name} detected but not yet configured`);
+    }
+    if (configured.length === 0) {
+        return {
+            name: 'Integration',
+            status: 'fail',
+            message: `No tools configured. ${issues.join('. ')}`,
+            fix: 'Run cubelife setup claude-code to configure.',
+        };
+    }
+    if (issues.length > 0) {
+        return {
+            name: 'Integration',
+            status: 'warn',
+            message: `${configured.join(', ')}. ${issues.join('. ')}`,
+        };
+    }
+    return { name: 'Integration', status: 'pass', message: configured.join(', ') };
+}
+export async function checkHookScript() {
+    const path = hookScriptPath();
+    if (!existsSync(path)) {
+        return {
+            name: 'Hook Script',
+            status: 'warn',
+            message: 'Hook script not found',
+            fix: 'Run cubelife setup claude-code to generate it.',
+        };
+    }
+    if (process.platform !== 'win32') {
+        try {
+            const s = await stat(path);
+            const isExecutable = !!(s.mode & 0o111);
+            if (!isExecutable) {
+                return {
+                    name: 'Hook Script',
+                    status: 'warn',
+                    message: 'Hook script exists but is not executable',
+                    fix: `Run chmod +x ${path} or cubelife setup claude-code to fix.`,
+                };
+            }
+        }
+        catch {
+            return { name: 'Hook Script', status: 'warn', message: 'Could not check hook script permissions' };
+        }
+    }
+    return { name: 'Hook Script', status: 'pass', message: path };
+}
+export async function checkConnectivity() {
+    const start = Date.now();
+    try {
+        const res = await fetch(`${API_BASE_URL}/api/v1/state`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(API_TIMEOUT_MS),
+        });
+        const latency = Date.now() - start;
+        if (res.status < 500) {
+            return { name: 'Connectivity', status: 'pass', message: `API reachable (${latency}ms)` };
+        }
+        return { name: 'Connectivity', status: 'warn', message: `API responded with ${res.status} (${latency}ms)` };
+    }
+    catch {
+        return {
+            name: 'Connectivity',
+            status: 'fail',
+            message: 'Cannot reach API',
+            fix: 'Check your internet connection.',
+        };
+    }
+}
+export async function checkStateReport() {
+    const config = await readProjectConfig();
+    if (!config?.agentId) {
+        return { name: 'State Report', status: 'fail', message: 'No agent linked' };
+    }
+    const store = await readAgents();
+    const key = resolveAgentKey(config.agentId, store);
+    if (!key) {
+        return { name: 'State Report', status: 'fail', message: 'No API key available' };
+    }
+    try {
+        const client = new AgentClient(key);
+        await client.report('idle');
+        return { name: 'State Report', status: 'pass', message: 'Test report delivered' };
+    }
+    catch (err) {
+        return {
+            name: 'State Report',
+            status: 'fail',
+            message: `Report failed: ${err.message}`,
+        };
+    }
+}
+export async function runAllChecks(autoFix) {
+    const results = [];
+    results.push(await checkAuth(autoFix));
+    let adminClient;
+    if (results[results.length - 1].status !== 'fail') {
+        try {
+            adminClient = await createAdminClient();
+        }
+        catch { /* checked individually below */ }
+        results.push(await checkTier(adminClient));
+    }
+    results.push(await checkProject(adminClient));
+    results.push(await checkAgent(adminClient));
+    results.push(await checkApiKey());
+    results.push(await checkIntegration());
+    results.push(await checkHookScript());
+    results.push(await checkConnectivity());
+    if (results.find((r) => r.name === 'API Key')?.status === 'pass') {
+        results.push(await checkStateReport());
+    }
+    return results;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,11 @@
+export { readGlobalConfig, writeGlobalConfig, readAgents, writeAgents, readProjectConfig, writeProjectConfig, resolveAgentKey, hasAuth, isTokenExpired, globalDir, globalConfigPath, agentsPath, projectConfigPath, projectDirPath, } from './config.js';
+export type { GlobalConfig, AuthConfig, AgentEntry, AgentsStore, ProjectConfig, } from './config.js';
+export { register, login, logout, refreshToken, getValidToken, currentUser, requireAuth, } from './auth.js';
+export type { AuthSession } from './auth.js';
+export { AdminClient, AgentClient, createAdminClient, createAgentClient, TIER_LIMITS, } from './api.js';
+export type { BillingUser, UsageDay, Tier } from './api.js';
+export { detectTools, detectInstalledTools } from './detect.js';
+export type { DetectedTool } from './detect.js';
+export { rootOpts, getErrorMessage, handleCommandError, requireProject, requireLinkedAgent, } from './command-helpers.js';
+export type { RootOpts, CommandErrorOptions, ResolvedProject, ResolvedAgent } from './command-helpers.js';
+export { API_BASE_URL, ID_DISPLAY_LENGTH, LABEL_WIDTH, DEFAULT_PANEL_WIDTH, API_TIMEOUT_MS, } from './constants.js';

package/dist/lib/index.js

@@ -0,0 +1,6 @@
+export { readGlobalConfig, writeGlobalConfig, readAgents, writeAgents, readProjectConfig, writeProjectConfig, resolveAgentKey, hasAuth, isTokenExpired, globalDir, globalConfigPath, agentsPath, projectConfigPath, projectDirPath, } from './config.js';
+export { register, login, logout, refreshToken, getValidToken, currentUser, requireAuth, } from './auth.js';
+export { AdminClient, AgentClient, createAdminClient, createAgentClient, TIER_LIMITS, } from './api.js';
+export { detectTools, detectInstalledTools } from './detect.js';
+export { rootOpts, getErrorMessage, handleCommandError, requireProject, requireLinkedAgent, } from './command-helpers.js';
+export { API_BASE_URL, ID_DISPLAY_LENGTH, LABEL_WIDTH, DEFAULT_PANEL_WIDTH, API_TIMEOUT_MS, } from './constants.js';

package/dist/lib/integration.d.ts

@@ -0,0 +1,66 @@
+export type IntegrationMode = 'mcp' | 'hooks' | 'both';
+export declare function readJsonConfig(path: string): Promise<Record<string, unknown>>;
+export declare function writeJsonConfig(path: string, config: Record<string, unknown>): Promise<void>;
+export declare function buildMcpEntryWithAgent(agentId: string): McpServerEntry;
+export declare function mergeMcpServerEntry(existing: Record<string, unknown>, serverKey: string, entry: McpServerEntry): {
+    config: Record<string, unknown>;
+    replaced: boolean;
+};
+export interface ContinueMcpServer {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export declare function readYamlConfig(path: string): Promise<Record<string, unknown>>;
+export declare function writeYamlConfig(path: string, config: Record<string, unknown>): Promise<void>;
+export declare function mergeContinueMcpServer(existing: Record<string, unknown>, entry: ContinueMcpServer): {
+    config: Record<string, unknown>;
+    replaced: boolean;
+};
+export declare function buildContinueMcpEntry(agentId: string): ContinueMcpServer;
+export declare function hasStaleContinueEntry(configPath: string): Promise<boolean>;
+export declare function removeContinueEntry(configPath: string): Promise<void>;
+export declare function hasStaleMcpEntry(configPath: string, serverKey?: string): Promise<boolean>;
+export declare function removeMcpEntry(configPath: string, serverKey?: string): Promise<void>;
+export interface HookDef {
+    matcher?: string;
+    hooks: {
+        type: string;
+        command: string;
+        async: boolean;
+    }[];
+}
+export interface McpServerEntry {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface ClaudeSettings {
+    mcpServers?: Record<string, McpServerEntry>;
+    hooks?: Record<string, HookDef[]>;
+    [key: string]: unknown;
+}
+export declare function hookScriptPath(): string;
+export declare function generateHookScript(): string;
+export declare function writeHookScript(): Promise<string>;
+export declare function buildMcpEntry(): McpServerEntry;
+export declare function buildHookEntries(): Record<string, HookDef[]>;
+export declare function hasMcpServer(settings: ClaudeSettings): boolean;
+export declare function isClaudeMcpRegistered(): boolean;
+export declare function registerClaudeMcp(scope?: 'user' | 'project' | 'local'): {
+    replaced: boolean;
+};
+export declare function isCodexMcpRegistered(): boolean;
+export declare function registerCodexMcp(agentId?: string): {
+    replaced: boolean;
+};
+export declare function hasHookIntegration(settings: ClaudeSettings): boolean;
+export declare function mergeSettings(existing: ClaudeSettings, mode: IntegrationMode): {
+    settings: ClaudeSettings;
+    conflicts: string[];
+};
+export declare function resolveProjectRoot(): string;
+export declare function readClaudeSettings(cwd: string): Promise<ClaudeSettings>;
+export declare function writeClaudeSettings(cwd: string, settings: ClaudeSettings): Promise<void>;
+export declare function detectLegacySetup(cwd: string): string[];