@exreve/exk 1.0.44 → 1.0.46

package/dist/appHandlers.js

@@ -0,0 +1,142 @@
+/**
+ * App Control Handlers Module
+ *
+ * Handles app:start, app:stop, app:restart, app:status, app:logs.
+ */
+import { getProjectConfig } from './projectAnalyzer.js';
+import { startApp, stopApp, restartApp, getAppStatuses, getAppLogs } from './appManager.js';
+export function registerAppHandlers(socket, foreground) {
+    socket.on('app:start', async (data, callback) => {
+        try {
+            const { projectId, projectPath, appName } = data;
+            const config = await getProjectConfig(projectPath);
+            if (!config) {
+                callback?.({ success: false, error: 'Project config not found' });
+                return;
+            }
+            const app = config.apps.find(a => a.name === appName);
+            if (!app) {
+                callback?.({ success: false, error: `App "${appName}" not found in project config` });
+                return;
+            }
+            const result = await startApp(projectPath, projectId, app);
+            if (result.success) {
+                if (foreground)
+                    console.log(`✓ Started app: ${appName} (PID: ${result.pid})`);
+                socket.emit('app:started', {
+                    projectId,
+                    appName,
+                    processId: result.processId,
+                    pid: result.pid,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error starting app: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:stop', async (data, callback) => {
+        try {
+            const { projectId, appName } = data;
+            const config = await getProjectConfig(data.projectPath);
+            const app = config?.apps.find(a => a.name === appName);
+            const result = await stopApp(projectId, appName, app);
+            if (result.success) {
+                if (foreground)
+                    console.log(`✓ Stopped app: ${appName}`);
+                socket.emit('app:stopped', {
+                    projectId,
+                    appName,
+                    appControlId: data.appControlId,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error stopping app: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:restart', async (data, callback) => {
+        try {
+            const { projectId, projectPath, appName } = data;
+            const config = await getProjectConfig(projectPath);
+            if (!config) {
+                callback?.({ success: false, error: 'Project config not found' });
+                return;
+            }
+            const app = config.apps.find(a => a.name === appName);
+            if (!app) {
+                callback?.({ success: false, error: `App "${appName}" not found in project config` });
+                return;
+            }
+            const result = await restartApp(projectPath, projectId, app);
+            if (result.success) {
+                if (foreground)
+                    console.log(`✓ Restarted app: ${appName} (PID: ${result.pid})`);
+                socket.emit('app:restarted', {
+                    projectId,
+                    appName,
+                    processId: result.processId,
+                    pid: result.pid,
+                    appControlId: data.appControlId,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error restarting app: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:status', async (data, callback) => {
+        try {
+            const { projectId, projectPath, appName } = data;
+            const config = await getProjectConfig(projectPath);
+            if (!config) {
+                callback?.({ success: false, error: 'Project config not found' });
+                return;
+            }
+            const appsToCheck = appName
+                ? config.apps.filter(a => a.name === appName)
+                : config.apps;
+            const statuses = getAppStatuses(projectId, appsToCheck);
+            if (data.appControlId) {
+                socket.emit('app:control:response', {
+                    appControlId: data.appControlId,
+                    success: true,
+                    apps: statuses,
+                });
+            }
+            callback?.({ success: true, apps: statuses });
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error getting app status: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:logs', async (data, callback) => {
+        try {
+            const { projectId, appName } = data;
+            const result = await getAppLogs(projectId, appName, 100);
+            if (data.appControlId) {
+                socket.emit('app:control:response', {
+                    appControlId: data.appControlId,
+                    ...result,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error getting app logs: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+}

package/dist/appManager.js

@@ -46,16 +46,16 @@ export async function startApp(projectPath, projectId, app) {
         const logFile = getLogFilePath(projectId, app.name);
         // Create runner based on app type
         const runner = createRunner(app, projectPath, projectId, {
-            onOutput: async (output) => {
+            onOutput: async (_output) => {
                 // Logs are handled by the runner itself
             },
-            onError: (error) => {
+            onError: (_error) => {
                 // Errors are logged by runner
             },
-            onExit: (code) => {
+            onExit: (_code) => {
                 removeAppFromRunning(projectId, app.name);
             },
-            onStats: (stats) => {
+            onStats: (_stats) => {
                 // Stats updates can be used for monitoring
             },
         });
@@ -90,7 +90,7 @@ export async function startApp(projectPath, projectId, app) {
 /**
  * Stop an app using wrapper runner
  */
-export async function stopApp(projectId, appName, app) {
+export async function stopApp(projectId, appName, _app) {
     try {
         const running = getRunningApp(projectId, appName);
         if (!running) {

package/dist/appRunner.js

@@ -140,7 +140,7 @@ export class StaticFrontendRunner extends BaseRunner {
             // Create a mock process for compatibility
             this.process = {
                 pid: process.pid,
-                kill: (signal) => {
+                kill: (_signal) => {
                     this.stop();
                 },
             };
@@ -291,7 +291,7 @@ export class BackendRunner extends BaseRunner {
                         ? path.join(this.projectPath, this.app.directory)
                         : this.projectPath;
                     const { shell: stopShell, args: stopArgs } = shellSpawnOpts(this.app.stopCommand);
-                    const stopProcess = spawn(stopShell, stopArgs, {
+                    spawn(stopShell, stopArgs, {
                         cwd: workingDir,
                         stdio: 'ignore',
                     });

package/dist/benchmark-startup.js

@@ -0,0 +1,347 @@
+/**
+ * Benchmark: cold query() vs warm startup() + query()
+ *
+ * Measures time-to-first-token for:
+ *   1. Cold query() (current behavior - spawns subprocess each time)
+ *   2. Warm startup() -> query() (pre-warmed subprocess)
+ *
+ * Usage: cd cli && npx tsx benchmark-startup.ts
+ */
+import { query, startup } from '@anthropic-ai/claude-agent-sdk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import { createRequire } from 'module';
+// Resolve Claude Code executable (mirrors agentSession.ts logic)
+function resolveClaudeExe() {
+    // Try glibc native binary first (most Linux distros)
+    for (const pkg of [
+        '@anthropic-ai/claude-agent-sdk-linux-x64',
+        '@anthropic-ai/claude-agent-sdk-linux-x64-musl',
+    ]) {
+        try {
+            const req = createRequire(import.meta.url);
+            const nativePkgPath = req.resolve(`${pkg}/package.json`);
+            const nativePath = path.join(path.dirname(nativePkgPath), 'claude');
+            if (fs.existsSync(nativePath)) {
+                // Test if it's actually executable
+                try {
+                    execSync(`${nativePath} --version`, { stdio: 'pipe', timeout: 5000 });
+                    return nativePath;
+                }
+                catch {
+                    // Binary can't execute (e.g. musl on glibc), skip
+                }
+            }
+        }
+        catch { }
+    }
+    // Fallback: cli.js (Node.js-based)
+    try {
+        const req = createRequire(import.meta.url);
+        const pkgPath = req.resolve('@anthropic-ai/claude-agent-sdk/package.json');
+        const cliPath = path.join(path.dirname(pkgPath), 'cli.js');
+        if (fs.existsSync(cliPath))
+            return cliPath;
+    }
+    catch { }
+    return undefined;
+}
+const CLAUDE_EXE = resolveClaudeExe();
+// ── Config ──────────────────────────────────────────────────────────
+const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
+function loadConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(AI_CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+const YELLOW = '\x1b[33m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+function hr() {
+    console.log(`${'─'.repeat(60)}`);
+}
+async function measureColdQuery(apiKey, baseUrl, model, env, settingsEnv, label) {
+    const queryStart = Date.now();
+    let firstTokenMs = 0;
+    let initMs = 0;
+    let totalMs = 0;
+    try {
+        const q = query({
+            prompt: 'Say exactly: "Hello, I am ready." Nothing else.',
+            options: {
+                apiKey,
+                model,
+                cwd: '/tmp',
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                maxTurns: 1,
+                env,
+                settings: { env: settingsEnv },
+                ...(CLAUDE_EXE ? { pathToClaudeCodeExecutable: CLAUDE_EXE } : {}),
+            },
+        });
+        for await (const event of q) {
+            const now = Date.now();
+            if (event.type === 'system' && event.subtype === 'init') {
+                initMs = now - queryStart;
+            }
+            if (event.type === 'assistant') {
+                if (firstTokenMs === 0) {
+                    firstTokenMs = now - queryStart;
+                }
+            }
+            if (event.type === 'result') {
+                totalMs = now - queryStart;
+            }
+        }
+    }
+    catch (err) {
+        return {
+            firstTokenMs: firstTokenMs || -1,
+            totalMs: Date.now() - queryStart,
+            startupMs: initMs || -1,
+            error: err.message,
+        };
+    }
+    console.log(`  ${label}: init=${initMs}ms, first_token=${firstTokenMs}ms, total=${totalMs}ms`);
+    return { firstTokenMs, totalMs, startupMs: initMs };
+}
+async function measureWarmQuery(apiKey, baseUrl, model, env, settingsEnv, label) {
+    // Phase 1: Pre-warm
+    const prewarmStart = Date.now();
+    let warmQuery;
+    try {
+        warmQuery = await startup({
+            options: {
+                apiKey,
+                model,
+                cwd: '/tmp',
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                maxTurns: 1,
+                env,
+                settings: { env: settingsEnv },
+                ...(CLAUDE_EXE ? { pathToClaudeCodeExecutable: CLAUDE_EXE } : {}),
+            },
+        });
+    }
+    catch (err) {
+        return {
+            prewarmMs: Date.now() - prewarmStart,
+            firstTokenMs: -1,
+            totalMs: Date.now() - prewarmStart,
+            error: `startup() failed: ${err.message}`,
+        };
+    }
+    const prewarmMs = Date.now() - prewarmStart;
+    console.log(`  ${label} prewarm: ${prewarmMs}ms`);
+    // Phase 2: Query on warm subprocess
+    const queryStart = Date.now();
+    let firstTokenMs = 0;
+    let totalMs = 0;
+    try {
+        const q = warmQuery.query('Say exactly: "Hello, I am ready." Nothing else.');
+        for await (const event of q) {
+            const now = Date.now();
+            if (event.type === 'assistant') {
+                if (firstTokenMs === 0) {
+                    firstTokenMs = now - queryStart;
+                }
+            }
+            if (event.type === 'result') {
+                totalMs = now - queryStart;
+            }
+        }
+    }
+    catch (err) {
+        return {
+            prewarmMs,
+            firstTokenMs: firstTokenMs || -1,
+            totalMs: Date.now() - queryStart,
+            error: `warm query() failed: ${err.message}`,
+        };
+    }
+    console.log(`  ${label} query: first_token=${firstTokenMs}ms, total=${totalMs}ms`);
+    return { prewarmMs, firstTokenMs, totalMs };
+}
+// ── Main ────────────────────────────────────────────────────────────
+async function main() {
+    console.log(`\n${BOLD}╔══════════════════════════════════════════════════════════╗${RESET}`);
+    console.log(`${BOLD}║  startup() Benchmark: Cold vs Warm Time-to-First-Token  ║${RESET}`);
+    console.log(`${BOLD}╚══════════════════════════════════════════════════════════╝${RESET}\n`);
+    const config = loadConfig();
+    const minimaxKey = config.minimaxApiKey || process.env.MINIMAX_API_KEY || '';
+    if (!minimaxKey) {
+        console.log(`${RED}ERROR: No MiniMax API key found. Set minimaxApiKey in ai-config.json${RESET}`);
+        process.exit(1);
+    }
+    const MINIMAX_BASE_URL = 'https://api.minimax.io/anthropic';
+    const MINIMAX_MODEL = 'MiniMax-M2.7-highspeed';
+    const env = {
+        ...process.env,
+        ANTHROPIC_API_KEY: minimaxKey,
+        ANTHROPIC_BASE_URL: MINIMAX_BASE_URL,
+        ANTHROPIC_MODEL: MINIMAX_MODEL,
+        ANTHROPIC_DEFAULT_SONNET_MODEL: MINIMAX_MODEL,
+        ANTHROPIC_DEFAULT_OPUS_MODEL: MINIMAX_MODEL,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: MINIMAX_MODEL,
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+    };
+    const settingsEnv = {
+        ANTHROPIC_API_KEY: minimaxKey,
+        ANTHROPIC_BASE_URL: MINIMAX_BASE_URL,
+        ANTHROPIC_MODEL: MINIMAX_MODEL,
+        ANTHROPIC_DEFAULT_SONNET_MODEL: MINIMAX_MODEL,
+        ANTHROPIC_DEFAULT_OPUS_MODEL: MINIMAX_MODEL,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: MINIMAX_MODEL,
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+    };
+    console.log(`${CYAN}Provider:${RESET} MiniMax`);
+    console.log(`${CYAN}Model:${RESET}    ${MINIMAX_MODEL}`);
+    console.log(`${CYAN}Base URL:${RESET} ${MINIMAX_BASE_URL}`);
+    console.log(`${CYAN}Key:${RESET}      ${minimaxKey.slice(0, 8)}...`);
+    console.log(`${CYAN}Exe:${RESET}      ${CLAUDE_EXE || '(not found)'}\n`);
+    if (!CLAUDE_EXE) {
+        console.log(`${RED}ERROR: Could not resolve Claude Code executable${RESET}`);
+        process.exit(1);
+    }
+    // ============== TEST 1: Cold Query ==============
+    console.log(`${BOLD}TEST 1: Cold query() — current behavior${RESET}`);
+    hr();
+    const coldResults = [];
+    for (let i = 0; i < 3; i++) {
+        const result = await measureColdQuery(minimaxKey, MINIMAX_BASE_URL, MINIMAX_MODEL, env, settingsEnv, `  Run ${i + 1}`);
+        coldResults.push(result);
+        if (result.error) {
+            console.log(`  ${RED}Error: ${result.error}${RESET}`);
+        }
+    }
+    // ============== TEST 2: Warm startup() + query() ==============
+    console.log(`\n${BOLD}TEST 2: Warm startup() → query() — pre-warmed subprocess${RESET}`);
+    hr();
+    const warmResults = [];
+    for (let i = 0; i < 3; i++) {
+        const result = await measureWarmQuery(minimaxKey, MINIMAX_BASE_URL, MINIMAX_MODEL, env, settingsEnv, `  Run ${i + 1}`);
+        warmResults.push(result);
+        if (result.error) {
+            console.log(`  ${RED}Error: ${result.error}${RESET}`);
+        }
+    }
+    // ============== Summary ==============
+    console.log(`\n${BOLD}══════════════════════════════════════════════════════════${RESET}`);
+    console.log(`${BOLD}  SUMMARY${RESET}`);
+    console.log(`${BOLD}══════════════════════════════════════════════════════════${RESET}\n`);
+    const validCold = coldResults.filter(r => !r.error && r.firstTokenMs > 0);
+    const validWarm = warmResults.filter(r => !r.error && r.firstTokenMs > 0);
+    if (validCold.length > 0) {
+        const avgColdFirst = Math.round(validCold.reduce((s, r) => s + r.firstTokenMs, 0) / validCold.length);
+        const avgColdTotal = Math.round(validCold.reduce((s, r) => s + r.totalMs, 0) / validCold.length);
+        const avgColdInit = Math.round(validCold.reduce((s, r) => s + r.startupMs, 0) / validCold.length);
+        console.log(`  ${YELLOW}Cold query() (avg of ${validCold.length}):${RESET}`);
+        console.log(`    Init/subprocess spawn:  ${avgColdInit}ms`);
+        console.log(`    Time to first token:    ${avgColdFirst}ms`);
+        console.log(`    Total query time:       ${avgColdTotal}ms`);
+    }
+    else {
+        console.log(`  ${RED}Cold query: ALL RUNS FAILED${RESET}`);
+        coldResults.forEach((r, i) => r.error && console.log(`    Run ${i + 1}: ${r.error}`));
+    }
+    console.log();
+    if (validWarm.length > 0) {
+        const avgWarmPrem = Math.round(validWarm.reduce((s, r) => s + r.prewarmMs, 0) / validWarm.length);
+        const avgWarmFirst = Math.round(validWarm.reduce((s, r) => s + r.firstTokenMs, 0) / validWarm.length);
+        const avgWarmTotal = Math.round(validWarm.reduce((s, r) => s + r.totalMs, 0) / validWarm.length);
+        console.log(`  ${GREEN}Warm startup() → query() (avg of ${validWarm.length}):${RESET}`);
+        console.log(`    Prewarm (startup()):    ${avgWarmPrem}ms`);
+        console.log(`    Time to first token:    ${avgWarmFirst}ms`);
+        console.log(`    Total query time:       ${avgWarmTotal}ms`);
+    }
+    else {
+        console.log(`  ${RED}Warm query: ALL RUNS FAILED${RESET}`);
+        warmResults.forEach((r, i) => r.error && console.log(`    Run ${i + 1}: ${r.error}`));
+    }
+    console.log();
+    if (validCold.length > 0 && validWarm.length > 0) {
+        const avgColdFirst = Math.round(validCold.reduce((s, r) => s + r.firstTokenMs, 0) / validCold.length);
+        const avgWarmFirst = Math.round(validWarm.reduce((s, r) => s + r.firstTokenMs, 0) / validWarm.length);
+        const speedup = avgColdFirst > 0 ? (avgColdFirst / avgWarmFirst).toFixed(1) : 'N/A';
+        const saved = avgColdFirst - avgWarmFirst;
+        console.log(`  ${BOLD}Speedup (first token):${RESET} ${speedup}x faster with startup()`);
+        console.log(`  ${BOLD}Time saved:${RESET}          ${saved > 0 ? saved : 0}ms per query`);
+        console.log();
+        if (parseFloat(speedup) >= 5) {
+            console.log(`  ${GREEN}${BOLD}✓ Significant improvement! startup() is highly beneficial here.${RESET}`);
+        }
+        else if (parseFloat(speedup) >= 2) {
+            console.log(`  ${YELLOW}! Moderate improvement. startup() helps but not 20x as advertised.${RESET}`);
+        }
+        else {
+            console.log(`  ${RED}✗ Minimal improvement. startup() overhead may not be worth it here.${RESET}`);
+        }
+    }
+    console.log(`\n${BOLD}══════════════════════════════════════════════════════════${RESET}\n`);
+    // ============== Bonus: Can we reuse startup()? ==============
+    console.log(`${BOLD}TEST 3: Can one WarmQuery be reused for multiple queries?${RESET}`);
+    hr();
+    try {
+        const warmHandle = await startup({
+            options: {
+                apiKey: minimaxKey,
+                model: MINIMAX_MODEL,
+                cwd: '/tmp',
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                maxTurns: 1,
+                env,
+                settings: { env: settingsEnv },
+                ...(CLAUDE_EXE ? { pathToClaudeCodeExecutable: CLAUDE_EXE } : {}),
+            },
+        });
+        console.log('  startup() succeeded, attempting first query()...');
+        const q1Start = Date.now();
+        let q1FirstToken = 0;
+        const q1 = warmHandle.query('Say "one"');
+        for await (const event of q1) {
+            if (event.type === 'assistant' && q1FirstToken === 0) {
+                q1FirstToken = Date.now() - q1Start;
+            }
+            if (event.type === 'result') {
+                console.log(`  Query 1: first_token=${q1FirstToken}ms, total=${Date.now() - q1Start}ms`);
+            }
+        }
+        console.log('  Attempting second query() on same WarmQuery...');
+        try {
+            const q2 = warmHandle.query('Say "two"');
+            for await (const _event of q2) {
+                // drain
+            }
+            console.log(`  ${GREEN}Second query succeeded — WarmQuery CAN be reused!${RESET}`);
+        }
+        catch (reuseErr) {
+            console.log(`  ${RED}Second query FAILED: ${reuseErr.message}${RESET}`);
+            console.log(`  ${YELLOW}→ WarmQuery is single-use, must call startup() again for each query.${RESET}`);
+        }
+        try {
+            warmHandle.close();
+        }
+        catch { }
+    }
+    catch (err) {
+        console.log(`  ${RED}startup() failed: ${err.message}${RESET}`);
+    }
+    console.log();
+    process.exit(0);
+}
+main().catch((err) => {
+    console.error('Unhandled error:', err);
+    process.exit(1);
+});