@exreve/exk 1.0.43 → 1.0.45

package/dist/agentSession.js

@@ -135,6 +135,9 @@ function lookupToolNameFromHistory(messages, toolUseId) {
 // (Do not read ANTHROPIC_* / CLAUDE_MODEL from the host environment — only this file + code default model.)
 const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
 const DEFAULT_AI_MODEL = 'glm-5.1';
+/** TTL cache for ai-config.json reads to avoid hitting disk on every call */
+let _aiConfigCache = null;
+const AI_CONFIG_TTL_MS = 5_000;
 const PROVIDERS = {
     zai: {
         apiKey: process.env.ZHIPU_API_KEY || '',
@@ -149,7 +152,7 @@ const PROVIDERS = {
     openrouter: {
         apiKey: '', // Populated from ai-config.json openrouterApiKey (served by backend)
         baseUrl: 'https://openrouter.ai/api',
-        models: ['gpt-oss-120b:grok'],
+        models: ['gpt-oss-120b:cerebras'],
     },
 };
 /** Resolve which provider to use based on model name or explicit provider ID.
@@ -184,6 +187,10 @@ function resolveProvider(model, providerId) {
     };
 }
 function loadAiConfig() {
+    const now = Date.now();
+    if (_aiConfigCache && (now - _aiConfigCache.ts) < AI_CONFIG_TTL_MS) {
+        return _aiConfigCache.data;
+    }
     try {
         const data = readFileSync(AI_CONFIG_PATH, 'utf-8');
         const config = JSON.parse(data);
@@ -193,10 +200,14 @@ function loadAiConfig() {
         const proxy = typeof config.proxy === 'string' ? config.proxy.trim() : '';
         const minimaxApiKey = typeof config.minimaxApiKey === 'string' ? config.minimaxApiKey.trim() : '';
         const openrouterApiKey = typeof config.openrouterApiKey === 'string' ? config.openrouterApiKey.trim() : '';
-        return { apiKey, baseUrl, model, proxy, minimaxApiKey, openrouterApiKey };
+        const result = { apiKey, baseUrl, model, proxy, minimaxApiKey, openrouterApiKey };
+        _aiConfigCache = { data: result, ts: now };
+        return result;
     }
     catch {
-        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '', openrouterApiKey: '' };
+        const fallback = { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '', openrouterApiKey: '' };
+        _aiConfigCache = { data: fallback, ts: now };
+        return fallback;
     }
 }
 /** Get OpenRouter API key from ai-config.json (served by backend) */

package/dist/app-child.js

@@ -104,9 +104,27 @@ async function fetchAiConfig(authToken) {
         return false;
     }
 }
-function hasAiCredentials() {
+/** TTL cache for ai-config.json reads */
+let _aiCfgCache = null;
+const _AI_CFG_TTL = 5_000;
+function readAiConfigCached() {
+    const now = Date.now();
+    if (_aiCfgCache && (now - _aiCfgCache.ts) < _AI_CFG_TTL)
+        return _aiCfgCache.raw;
     try {
         const raw = fsSync.readFileSync(AI_CONFIG_FILE, 'utf-8');
+        _aiCfgCache = { raw, ts: now };
+        return raw;
+    }
+    catch {
+        return '';
+    }
+}
+function hasAiCredentials() {
+    try {
+        const raw = readAiConfigCached();
+        if (!raw)
+            return false;
         const j = JSON.parse(raw);
         return typeof j.authToken === 'string' && j.authToken.trim().length > 0;
     }

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);
+});

package/dist/index.js

@@ -83,10 +83,28 @@ async function writeProxyConfig(cfg) {
     await fs.mkdir(CONFIG_DIR, { recursive: true });
     await fs.writeFile(PROXY_CONFIG_FILE, JSON.stringify(cfg, null, 2));
 }
+/** TTL cache for ai-config.json reads (shared by getProxyUrl / hasAiCredentials) */
+let _aiCfgCache = null;
+const _AI_CFG_TTL = 5_000;
+function readAiConfigCached() {
+    const now = Date.now();
+    if (_aiCfgCache && (now - _aiCfgCache.ts) < _AI_CFG_TTL)
+        return _aiCfgCache.raw;
+    try {
+        const raw = fsSync.readFileSync(AI_CONFIG_FILE, 'utf-8');
+        _aiCfgCache = { raw, ts: now };
+        return raw;
+    }
+    catch {
+        return '';
+    }
+}
 /** Get the proxy URL from ai-config.json (saved from backend) */
 function getProxyUrl() {
     try {
-        const raw = fsSync.readFileSync(AI_CONFIG_FILE, 'utf-8');
+        const raw = readAiConfigCached();
+        if (!raw)
+            return '';
         const j = JSON.parse(raw);
         return typeof j.proxy === 'string' ? j.proxy.trim() : '';
     }
@@ -97,7 +115,9 @@ function getProxyUrl() {
 /** True if ai-config.json has a model API key (not read from host ANTHROPIC_* env). */
 function hasAiCredentials() {
     try {
-        const raw = fsSync.readFileSync(AI_CONFIG_FILE, 'utf-8');
+        const raw = readAiConfigCached();
+        if (!raw)
+            return false;
         const j = JSON.parse(raw);
         return typeof j.authToken === 'string' && j.authToken.trim().length > 0;
     }

package/dist/moduleMcpServer.js

@@ -190,6 +190,7 @@ function createBrowserQueryTool(config) {
         schema: z.string().optional().describe('JSON schema for structured output, as a JSON string (e.g. \'{"type":"object","properties":{"price":{"type":"number"}}}\')'),
         maxSteps: z.number().optional().describe('Max automation steps, default 20. Use lower values for simple tasks.'),
         country: z.string().optional().describe('2-letter country code for proxy and locale (e.g. "US", "GB", "DE"). Uses direct connection if omitted.'),
+        mobile: z.boolean().optional().describe('If true, use mobile viewport (390x844 — iPhone 14 dimensions) instead of desktop.'),
     }, async (args) => {
         const apiUrl = getApiUrl();
         // Read device ID for CLI auth
@@ -217,6 +218,8 @@ function createBrowserQueryTool(config) {
             }
             if (args.country)
                 body.country = args.country;
+            if (args.mobile)
+                body.mobile = args.mobile;
             if (config.sessionId)
                 body.sessionId = config.sessionId;
             if (config.promptId)

package/dist/projectAnalyzer.js

@@ -185,10 +185,17 @@ CRITICAL INSTRUCTIONS:
             }
         });
         // Wait for Claude to process (give it time to read files and generate response)
-        // Check multiple times as Claude may take a while - wait up to 90 seconds
+        // Use exponential backoff: start at 500ms, double each time, cap at 5s, timeout at 90s
         const configFilePath = path.join(projectPath, CONFIG_FILENAME);
-        for (let i = 0; i < 90; i++) {
-            await new Promise(resolve => setTimeout(resolve, 1000));
+        const POLL_TIMEOUT_MS = 90_000;
+        const POLL_START_MS = 500;
+        const POLL_MAX_MS = 5_000;
+        let elapsed = 0;
+        let interval = POLL_START_MS;
+        while (elapsed < POLL_TIMEOUT_MS) {
+            await new Promise(resolve => setTimeout(resolve, interval));
+            elapsed += interval;
+            interval = Math.min(interval * 2, POLL_MAX_MS);
             // Check if Claude wrote the config file directly
             try {
                 await fs.access(configFilePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {
@@ -33,8 +33,8 @@
     "url": ""
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.87",
-    "@anthropic-ai/sdk": "^0.80.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.126",
+    "@anthropic-ai/sdk": "^0.92.0",
     "@fastify/static": "^9.0.0",
     "@xenova/transformers": "^2.17.2",
     "anthropic-proxy": "^1.3.0",