@ekkos/cli 0.2.0

package/dist/cache/types.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * ekkOS Fast /continue - Local Cache Types
+ *
+ * Defines the data structures for the 3-tier restore chain:
+ * Tier 0: Local JSONL cache (~20ms)
+ * Tier 1: Redis hot cache (~150ms)
+ * Tier 2: Supabase cold store (~500ms)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_RESPONSE_PATTERNS = void 0;
+exports.isValidAssistantResponse = isValidAssistantResponse;
+/**
+ * Known placeholder strings that indicate incomplete/invalid responses
+ * These should NOT be treated as valid assistant_response content
+ */
+exports.INVALID_RESPONSE_PATTERNS = [
+    '[object Object]',
+    'null',
+    'undefined',
+    '...',
+    'Loading...',
+    'Thinking...',
+];
+/**
+ * Check if an assistant_response is valid (complete, not a placeholder)
+ */
+function isValidAssistantResponse(response) {
+    if (!response)
+        return false;
+    const trimmed = response.trim();
+    if (trimmed.length === 0)
+        return false;
+    if (exports.INVALID_RESPONSE_PATTERNS.includes(trimmed))
+        return false;
+    // Also reject very short responses that look like placeholders
+    if (trimmed.length < 5 && !/\w{3,}/.test(trimmed))
+        return false;
+    return true;
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,9 @@
+interface InitOptions {
+    ide?: string;
+    key?: string;
+    force?: boolean;
+    skipHooks?: boolean;
+    skipSkills?: boolean;
+}
+export declare function init(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,478 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const fs_1 = require("fs");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const open_1 = __importDefault(require("open"));
+const platform_1 = require("../utils/platform");
+const mcp_1 = require("../deploy/mcp");
+const settings_1 = require("../deploy/settings");
+const hooks_1 = require("../deploy/hooks");
+const skills_1 = require("../deploy/skills");
+const agents_1 = require("../deploy/agents");
+const plugins_1 = require("../deploy/plugins");
+const instructions_1 = require("../deploy/instructions");
+const templates_1 = require("../utils/templates");
+// ═══════════════════════════════════════════════════════════════════════════
+// DEVICE AUTHENTICATION
+// ═══════════════════════════════════════════════════════════════════════════
+async function requestDeviceCode() {
+    const response = await fetch(`${platform_1.PLATFORM_URL}/api/device-auth/codes`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to request device code: ${response.status}`);
+    }
+    return response.json();
+}
+async function pollForApproval(code, expiresIn) {
+    const pollInterval = 3000; // 3 seconds
+    const maxAttempts = Math.floor((expiresIn * 1000) / pollInterval);
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const response = await fetch(`${platform_1.PLATFORM_URL}/api/device-auth/codes/${code}/status`, { method: 'GET' });
+        if (response.status === 410) {
+            return { status: 'expired' };
+        }
+        if (response.ok) {
+            const data = await response.json();
+            if (data.status !== 'pending') {
+                return data;
+            }
+        }
+        // Wait before next poll
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+    return { status: 'expired' };
+}
+async function generateApiKey(userId, email) {
+    const response = await fetch(`${platform_1.PLATFORM_URL}/api/auth/extension/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ userId, email })
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to generate API key: ${response.status}`);
+    }
+    return response.json();
+}
+async function deviceAuth() {
+    console.log('');
+    console.log(chalk_1.default.cyan('Step 1/3: Authentication'));
+    console.log(chalk_1.default.gray('─'.repeat(40)));
+    console.log('');
+    // Request device code
+    const spinner = (0, ora_1.default)('Requesting device code...').start();
+    let deviceCode;
+    try {
+        deviceCode = await requestDeviceCode();
+        spinner.succeed('Device code received');
+    }
+    catch (error) {
+        spinner.fail('Failed to get device code');
+        throw error;
+    }
+    console.log('');
+    console.log(chalk_1.default.white.bold(`Your code: ${chalk_1.default.cyan.bold(deviceCode.code)}`));
+    console.log('');
+    // Open browser
+    const verificationUrl = deviceCode.verificationUrl || `${platform_1.PLATFORM_URL}/activate`;
+    console.log(chalk_1.default.gray(`Opening browser to: ${verificationUrl}`));
+    try {
+        await (0, open_1.default)(verificationUrl);
+    }
+    catch {
+        console.log(chalk_1.default.yellow('Could not open browser automatically.'));
+        console.log(chalk_1.default.gray(`Please visit: ${verificationUrl}`));
+    }
+    console.log('');
+    // Poll for approval
+    const expiresMinutes = Math.floor(deviceCode.expiresIn / 60);
+    const pollSpinner = (0, ora_1.default)(`Waiting for approval... (expires in ${expiresMinutes} min)`).start();
+    let pollResult;
+    try {
+        pollResult = await pollForApproval(deviceCode.code, deviceCode.expiresIn);
+    }
+    catch (error) {
+        pollSpinner.fail('Authentication failed');
+        throw error;
+    }
+    if (pollResult.status === 'denied') {
+        pollSpinner.fail('Authentication denied');
+        throw new Error('User denied authentication request');
+    }
+    if (pollResult.status === 'expired') {
+        pollSpinner.fail('Authentication expired');
+        throw new Error('Device code expired. Please try again.');
+    }
+    if (pollResult.status !== 'approved' || !pollResult.user_id || !pollResult.user_email) {
+        pollSpinner.fail('Authentication failed');
+        throw new Error('Invalid approval response');
+    }
+    pollSpinner.succeed('Approved');
+    // Generate API key
+    const keySpinner = (0, ora_1.default)('Generating API key...').start();
+    let keyData;
+    try {
+        keyData = await generateApiKey(pollResult.user_id, pollResult.user_email);
+        keySpinner.succeed('API key generated');
+    }
+    catch (error) {
+        keySpinner.fail('Failed to generate API key');
+        throw error;
+    }
+    console.log('');
+    console.log(chalk_1.default.green(`✓ Authenticated as ${chalk_1.default.bold(keyData.email)} (${keyData.tier} tier)`));
+    console.log('');
+    return {
+        apiKey: keyData.apiKey,
+        userId: pollResult.user_id,
+        email: keyData.email,
+        tier: keyData.tier
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// MANUAL API KEY FLOW
+// ═══════════════════════════════════════════════════════════════════════════
+async function manualKeyAuth(providedKey) {
+    console.log('');
+    console.log(chalk_1.default.cyan('Step 1/3: Authentication'));
+    console.log(chalk_1.default.gray('─'.repeat(40)));
+    console.log('');
+    let apiKey = providedKey;
+    if (!apiKey) {
+        console.log(chalk_1.default.yellow('Get your API key from: https://platform.ekkos.dev/dashboard/keys'));
+        console.log('');
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'Enter your ekkOS API key:',
+                mask: '*',
+                validate: (input) => {
+                    if (!input || input.length < 10) {
+                        return 'Please enter a valid API key';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        apiKey = answers.apiKey;
+    }
+    // Verify API key
+    const spinner = (0, ora_1.default)('Verifying API key...').start();
+    try {
+        const response = await fetch(`${platform_1.MCP_API_URL}/api/v1/patterns/query`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ query: 'test', k: 1 })
+        });
+        if (!response.ok) {
+            spinner.fail('Invalid API key');
+            throw new Error('API key verification failed');
+        }
+        spinner.succeed('API key verified');
+    }
+    catch (error) {
+        spinner.fail('Could not verify API key');
+        throw error;
+    }
+    console.log('');
+    console.log(chalk_1.default.green('✓ Authenticated with API key'));
+    console.log('');
+    // For manual keys, we don't have user info
+    return {
+        apiKey: apiKey,
+        userId: 'manual',
+        email: 'manual@ekkos.dev',
+        tier: 'unknown'
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// IDE SETUP
+// ═══════════════════════════════════════════════════════════════════════════
+async function selectIDEs() {
+    console.log(chalk_1.default.cyan('Step 2/3: IDE Setup'));
+    console.log(chalk_1.default.gray('─'.repeat(40)));
+    console.log('');
+    const detected = (0, platform_1.detectInstalledIDEs)();
+    const current = (0, platform_1.detectCurrentIDE)();
+    if (detected.length > 0) {
+        console.log(chalk_1.default.gray(`Detected: ${detected.join(', ')}`));
+        if (current) {
+            console.log(chalk_1.default.gray(`Current: ${current}`));
+        }
+        console.log('');
+    }
+    const ideOptions = [
+        { name: 'Claude Code', value: 'claude', default: detected.includes('claude') || current === 'claude' },
+        { name: 'Cursor', value: 'cursor', default: detected.includes('cursor') || current === 'cursor' },
+        { name: 'Windsurf (Cascade)', value: 'windsurf', default: detected.includes('windsurf') || current === 'windsurf' }
+    ];
+    const selectedIDEs = [];
+    // Ask for each IDE individually
+    for (const ide of ideOptions) {
+        const answer = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'selected',
+            message: `Configure ${ide.name}?`,
+            default: ide.default
+        });
+        if (answer.selected) {
+            selectedIDEs.push(ide.value);
+        }
+    }
+    if (selectedIDEs.length === 0) {
+        console.log(chalk_1.default.yellow('No IDEs selected. Defaulting to Claude Code.'));
+        selectedIDEs.push('claude');
+    }
+    console.log('');
+    return selectedIDEs;
+}
+async function deployForClaude(apiKey, userId, options) {
+    const result = {
+        mcp: false,
+        settings: false,
+        hooks: { count: 0, files: [] },
+        skills: { count: 0, skills: [] },
+        agents: { count: 0, agents: [] },
+        plugins: { count: 0, plugins: [] },
+        instructions: false
+    };
+    // MCP configuration
+    let spinner = (0, ora_1.default)('Deploying MCP server configuration...').start();
+    try {
+        (0, mcp_1.deployClaudeMcp)(apiKey, userId);
+        result.mcp = true;
+        spinner.succeed('MCP server configuration');
+    }
+    catch (error) {
+        spinner.fail('MCP server configuration failed');
+    }
+    // Settings.json (hook registration)
+    spinner = (0, ora_1.default)('Deploying hooks configuration...').start();
+    try {
+        (0, settings_1.deployClaudeSettings)();
+        result.settings = true;
+        spinner.succeed('Hooks configuration');
+    }
+    catch (error) {
+        spinner.fail('Hooks configuration failed');
+    }
+    // Hook scripts
+    if (!options.skipHooks) {
+        spinner = (0, ora_1.default)('Deploying hook scripts...').start();
+        try {
+            result.hooks = (0, hooks_1.deployHooks)(apiKey);
+            spinner.succeed(`Hook scripts (${result.hooks.count} files)`);
+        }
+        catch (error) {
+            spinner.fail('Hook scripts failed');
+        }
+    }
+    // Skills
+    if (!options.skipSkills) {
+        spinner = (0, ora_1.default)('Deploying skills...').start();
+        try {
+            result.skills = (0, skills_1.deploySkills)();
+            spinner.succeed(`Skills (${result.skills.count} folders)`);
+        }
+        catch (error) {
+            spinner.fail('Skills deployment failed');
+        }
+    }
+    // Agents
+    spinner = (0, ora_1.default)('Deploying agents...').start();
+    try {
+        result.agents = (0, agents_1.deployAgents)();
+        spinner.succeed(`Agents (${result.agents.count} files)`);
+    }
+    catch (error) {
+        spinner.fail('Agents deployment failed');
+    }
+    // Plugins
+    spinner = (0, ora_1.default)('Deploying plugins...').start();
+    try {
+        result.plugins = (0, plugins_1.deployPlugins)();
+        spinner.succeed(`Plugins (${result.plugins.count} folders)`);
+    }
+    catch (error) {
+        spinner.fail('Plugins deployment failed');
+    }
+    // CLAUDE.md
+    spinner = (0, ora_1.default)('Deploying global instructions...').start();
+    try {
+        (0, instructions_1.deployInstructions)();
+        result.instructions = true;
+        spinner.succeed('Global instructions (CLAUDE.md)');
+    }
+    catch (error) {
+        spinner.fail('Global instructions failed');
+    }
+    return result;
+}
+async function deployForCursor(apiKey, userId) {
+    const spinner = (0, ora_1.default)('Deploying Cursor MCP configuration...').start();
+    try {
+        (0, mcp_1.deployCursorMcp)(apiKey, userId);
+        spinner.succeed('Cursor MCP configuration');
+        return true;
+    }
+    catch (error) {
+        spinner.fail('Cursor MCP configuration failed');
+        return false;
+    }
+}
+async function deployForWindsurf(apiKey, userId) {
+    const spinner = (0, ora_1.default)('Deploying Windsurf MCP configuration...').start();
+    try {
+        (0, mcp_1.deployWindsurfMcp)(apiKey, userId);
+        spinner.succeed('Windsurf MCP configuration');
+        return true;
+    }
+    catch (error) {
+        spinner.fail('Windsurf MCP configuration failed');
+        return false;
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// MAIN INIT COMMAND
+// ═══════════════════════════════════════════════════════════════════════════
+async function init(options) {
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('╔═══════════════════════════════════════╗'));
+    console.log(chalk_1.default.cyan.bold('║     🧠 ekkOS Memory System Setup      ║'));
+    console.log(chalk_1.default.cyan.bold('╚═══════════════════════════════════════╝'));
+    console.log('');
+    // Check templates exist
+    if (!(0, templates_1.templatesExist)()) {
+        console.log(chalk_1.default.red('Error: Templates not found.'));
+        console.log(chalk_1.default.gray('Please ensure the ekkOS CLI is installed correctly.'));
+        process.exit(1);
+    }
+    // Check for existing config
+    let existingConfig = null;
+    if ((0, fs_1.existsSync)(platform_1.EKKOS_CONFIG)) {
+        try {
+            existingConfig = JSON.parse((0, fs_1.readFileSync)(platform_1.EKKOS_CONFIG, 'utf-8'));
+        }
+        catch { }
+    }
+    // STEP 1: Authentication
+    let auth;
+    if (options.key) {
+        // Manual API key provided
+        auth = await manualKeyAuth(options.key);
+    }
+    else if (existingConfig?.apiKey && !options.force) {
+        // Already authenticated
+        console.log(chalk_1.default.cyan('Step 1/3: Authentication'));
+        console.log(chalk_1.default.gray('─'.repeat(40)));
+        console.log('');
+        console.log(chalk_1.default.green(`✓ Already authenticated as ${chalk_1.default.bold(existingConfig.email || 'unknown')}`));
+        console.log(chalk_1.default.gray('  (use --force to re-authenticate)'));
+        console.log('');
+        auth = {
+            apiKey: existingConfig.apiKey,
+            userId: existingConfig.userId || 'unknown',
+            email: existingConfig.email || 'unknown',
+            tier: existingConfig.tier || 'unknown'
+        };
+    }
+    else {
+        // Device auth flow
+        try {
+            auth = await deviceAuth();
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`\nAuthentication failed: ${error}`));
+            console.log(chalk_1.default.gray('\nTry again or use --key to provide an API key manually.'));
+            process.exit(1);
+        }
+    }
+    // STEP 2: IDE Selection
+    let selectedIDEs;
+    if (options.ide) {
+        if (options.ide === 'all') {
+            selectedIDEs = (0, platform_1.detectInstalledIDEs)();
+            if (selectedIDEs.length === 0) {
+                selectedIDEs = ['claude']; // Default to Claude Code
+            }
+        }
+        else {
+            selectedIDEs = [options.ide];
+        }
+        console.log(chalk_1.default.cyan('Step 2/3: IDE Setup'));
+        console.log(chalk_1.default.gray('─'.repeat(40)));
+        console.log('');
+        console.log(chalk_1.default.gray(`Configuring: ${selectedIDEs.join(', ')}`));
+        console.log('');
+    }
+    else {
+        selectedIDEs = await selectIDEs();
+    }
+    // STEP 3: Deployment
+    console.log(chalk_1.default.cyan('Step 3/3: Deploying'));
+    console.log(chalk_1.default.gray('─'.repeat(40)));
+    console.log('');
+    const installedIDEs = [];
+    for (const ide of selectedIDEs) {
+        if (ide === 'claude') {
+            const result = await deployForClaude(auth.apiKey, auth.userId, options);
+            if (result.mcp || result.hooks.count > 0) {
+                installedIDEs.push('claude');
+            }
+        }
+        else if (ide === 'cursor') {
+            if (await deployForCursor(auth.apiKey, auth.userId)) {
+                installedIDEs.push('cursor');
+            }
+        }
+        else if (ide === 'windsurf') {
+            if (await deployForWindsurf(auth.apiKey, auth.userId)) {
+                installedIDEs.push('windsurf');
+            }
+        }
+    }
+    // Save config
+    if (!(0, fs_1.existsSync)(platform_1.EKKOS_DIR)) {
+        (0, fs_1.mkdirSync)(platform_1.EKKOS_DIR, { recursive: true });
+    }
+    const config = {
+        apiKey: auth.apiKey,
+        userId: auth.userId,
+        email: auth.email,
+        tier: auth.tier,
+        createdAt: new Date().toISOString(),
+        installedIDEs
+    };
+    (0, fs_1.writeFileSync)(platform_1.EKKOS_CONFIG, JSON.stringify(config, null, 2));
+    (0, fs_1.chmodSync)(platform_1.EKKOS_CONFIG, '600'); // Secure permissions
+    // Summary
+    console.log('');
+    console.log(chalk_1.default.gray('═'.repeat(40)));
+    console.log(chalk_1.default.green.bold('✓ Setup complete!'));
+    console.log(chalk_1.default.gray('═'.repeat(40)));
+    console.log('');
+    if (installedIDEs.includes('claude')) {
+        console.log(chalk_1.default.yellow('→ Restart Claude Code to activate ekkOS'));
+    }
+    if (installedIDEs.includes('cursor')) {
+        console.log(chalk_1.default.yellow('→ Restart Cursor to activate ekkOS'));
+    }
+    if (installedIDEs.includes('windsurf')) {
+        console.log(chalk_1.default.yellow('→ Restart Windsurf to activate ekkOS'));
+    }
+    console.log('');
+    console.log(chalk_1.default.gray(`Run ${chalk_1.default.white('ekkos status')} to verify installation`));
+    console.log(chalk_1.default.gray(`View dashboard: ${chalk_1.default.white('https://platform.ekkos.dev/dashboard')}`));
+    console.log('');
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,12 @@
+interface RunOptions {
+    session?: string;
+    verbose?: boolean;
+    bypass?: boolean;
+    slashOpenDelayMs?: number;
+    charDelayMs?: number;
+    postEnterDelayMs?: number;
+    clearWaitMs?: number;
+    debugLogPath?: string;
+}
+export declare function run(options: RunOptions): Promise<void>;
+export {};