@exreve/exk 1.0.57 → 1.0.59

package/bin/exk

@@ -3,20 +3,18 @@
 // Runs compiled JavaScript directly (no tsx needed)
 
 import { resolve, dirname } from 'path'
-import { existsSync } from 'fs'
 import { fileURLToPath } from 'url'
+import { existsSync } from 'fs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
 const pkgDir = resolve(__dirname, '..')
-// dist layout varies by tsc root inference — check both locations
+// tsc outputs to dist/cli/ (see CLAUDE.md "tsc output goes to dist/cli/")
 const entryPoint = existsSync(resolve(pkgDir, 'dist', 'cli', 'index.js'))
   ? resolve(pkgDir, 'dist', 'cli', 'index.js')
   : resolve(pkgDir, 'dist', 'index.js')
 
-const args = process.argv.slice(2)
-
 // Import and run the compiled CLI
 import(entryPoint).catch(err => {
   console.error('Failed to start exk:', err.message)

package/dist/cli/agentSession.js

@@ -4,6 +4,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from '
 import { symlink as fsSymlink } from 'fs';
 import { getSkillContent } from './skills/index.js';
 import { isLocalModel, unwrapModelName, startOpenAIAdapter, getAdapterConfig } from './openaiAdapter.js';
+import { ensureProxy } from './proxyManager.js';
 import { createModuleMcpServer } from './moduleMcpServer.js';
 import path from 'path';
 import os from 'os';
@@ -203,6 +204,11 @@ const PROVIDERS = {
         baseUrl: 'https://openrouter.ai/api',
         models: ['gpt-oss-120b:cerebras'],
     },
+    cerebras: {
+        apiKey: '', // Populated from ai-config.json cerebrasApiKey (served by backend)
+        baseUrl: '', // Set dynamically when proxy starts
+        models: ['zai-glm-4.7'],
+    },
 };
 /** Resolve which provider to use based on model name or explicit provider ID.
  *  1. Populate provider API keys from ai-config.json (served by backend).
@@ -214,6 +220,7 @@ function resolveProvider(model, providerId) {
     const aiConfig = loadAiConfig();
     PROVIDERS.minimax.apiKey = aiConfig.minimaxApiKey || process.env.MINIMAX_API_KEY || '';
     PROVIDERS.openrouter.apiKey = aiConfig.openrouterApiKey || process.env.OPENROUTER_API_KEY || '';
+    PROVIDERS.cerebras.apiKey = aiConfig.cerebrasApiKey || process.env.CEREBRAS_API_KEY || '';
     if (!PROVIDERS.zai.apiKey)
         PROVIDERS.zai.apiKey = aiConfig.apiKey || '';
     // 1. Explicit provider selection
@@ -249,12 +256,13 @@ 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() : '';
-        const result = { apiKey, baseUrl, model, proxy, minimaxApiKey, openrouterApiKey };
+        const cerebrasApiKey = typeof config.cerebrasApiKey === 'string' ? config.cerebrasApiKey.trim() : '';
+        const result = { apiKey, baseUrl, model, proxy, minimaxApiKey, openrouterApiKey, cerebrasApiKey };
         _aiConfigCache = { data: result, ts: now };
         return result;
     }
     catch {
-        const fallback = { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '', openrouterApiKey: '' };
+        const fallback = { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '', minimaxApiKey: '', openrouterApiKey: '', cerebrasApiKey: '' };
         _aiConfigCache = { data: fallback, ts: now };
         return fallback;
     }
@@ -873,6 +881,23 @@ export class AgentSessionManager {
                         settingsEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolved.model;
                         settingsEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
                     }
+                    // For Cerebras: start anthropic-proxy-rs and route through it
+                    if (resolved.provider === 'cerebras') {
+                        const proxyUrl = await ensureProxy({
+                            upstreamUrl: 'https://api.cerebras.ai/v1',
+                            apiKey: resolved.apiKey,
+                            model: resolved.model,
+                        });
+                        effectiveApiKey = 'cerebras-via-proxy'; // Proxy doesn't validate the key
+                        effectiveEnv = envForClaudeCodeChild(undefined, { ...resolved, baseUrl: proxyUrl });
+                        settingsEnv.ANTHROPIC_API_KEY = effectiveApiKey;
+                        settingsEnv.ANTHROPIC_BASE_URL = proxyUrl;
+                        settingsEnv.ANTHROPIC_MODEL = resolved.model;
+                        settingsEnv.ANTHROPIC_DEFAULT_SONNET_MODEL = resolved.model;
+                        settingsEnv.ANTHROPIC_DEFAULT_OPUS_MODEL = resolved.model;
+                        settingsEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolved.model;
+                        settingsEnv.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
+                    }
                     effectiveSettings = { env: settingsEnv };
                     console.log(`[agentSession] Provider: ${resolved.provider}, baseUrl: ${resolved.baseUrl}, model: ${resolved.model}`);
                 }
@@ -941,6 +966,36 @@ export class AgentSessionManager {
                                 session.claudeSessionId = msg.session_id;
                                 saveSessionState(sessionId, { claudeSessionId: msg.session_id, model: session.model, provider: resolveProvider(session.model).provider, updatedAt: Date.now() });
                             }
+                            // Detect context window limit error from the API
+                            // The SDK sends this as an assistant message with error: 'max_output_tokens'
+                            // when the provider returns 'model_context_window_exceeded'
+                            const isContextWindowError = msg.error === 'max_output_tokens' && ((typeof msg.message === 'string' && msg.message.includes('context window limit')) ||
+                                (Array.isArray(msg.message?.content) && msg.message.content.some((c) => typeof c?.text === 'string' && c.text.includes('context window limit'))));
+                            if (isContextWindowError) {
+                                console.warn(`[AgentSessionManager] Context window limit reached for session ${sessionId}. Clearing context for fresh start.`);
+                                // Clear the session ID so next prompt starts fresh (no resume)
+                                session.claudeSessionId = undefined;
+                                session.contextLost = true;
+                                deleteSessionState(sessionId);
+                                // Emit a user-friendly system message
+                                onOutput({
+                                    type: 'system',
+                                    data: {
+                                        message: 'Context window limit reached. Session context has been cleared. The next prompt will start fresh with a summary of previous conversation.',
+                                        subtype: 'context_window_reset',
+                                    },
+                                    timestamp: Date.now(),
+                                    metadata: {
+                                        subtype: 'context_window_reset',
+                                        contextInfo: {
+                                            messageCount: session.messages.length,
+                                            totalInputTokens: session.totalInputTokens,
+                                            totalOutputTokens: session.totalOutputTokens,
+                                            totalTokens: session.totalInputTokens + session.totalOutputTokens,
+                                        }
+                                    }
+                                });
+                            }
                             session.messages.push({
                                 role: 'assistant',
                                 content: msg.message,

package/dist/cli/app-child.js

@@ -211,7 +211,7 @@ async function connect() {
     const deviceId = await getDeviceId();
     return new Promise((resolve, reject) => {
         const socket = io(config.apiUrl, {
-            transports: ['websocket', 'polling'],
+            transports: ['polling', 'websocket'],
         });
         socket.on('connect', () => {
             socket.emit('register', { type: 'cli', deviceId });
@@ -516,7 +516,7 @@ async function runDaemon(foreground = false, email) {
     const connectAndRegister = async () => {
         try {
             socket = io(config.apiUrl, {
-                transports: ['websocket', 'polling'],
+                transports: ['polling', 'websocket'],
                 reconnection: true,
                 reconnectionDelay: 1000,
                 reconnectionDelayMax: 10000,

package/dist/cli/benchmark-models-sdk.js

@@ -0,0 +1,386 @@
+/**
+ * SDK Benchmark: MiniMax M2.7-highspeed vs Cerebras zai-glm-4.7 (via anthropic-proxy-rs)
+ *
+ * Both providers are tested through the Claude Agent SDK query().
+ * Task: Generate a complete HTML real estate page.
+ * Measures: total output tokens, total duration, TPS.
+ *
+ * Usage:
+ *   cd cli && npx tsx benchmark-models-sdk.ts
+ *
+ * Requirements:
+ *   - @anthropic-ai/claude-agent-sdk installed
+ *   - anthropic-proxy binary (cargo install --git https://github.com/m0n0x41d/anthropic-proxy-rs --locked)
+ *   - MiniMax API key in ~/.talk-to-code/ai-config.json
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { createRequire } from 'module';
+import { execSync, spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+// ── Config ──────────────────────────────────────────────────────────
+const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
+const PROXY_PORT = 8401;
+const EMPTY_DIR = path.join(os.homedir(), '.talk-to-code', 'empty-config-dir');
+const TASK_PROMPT = `Create a complete, beautiful HTML real estate property listing page. Include:
+- A hero section with a large property image placeholder and price overlay
+- Property details: 4 bed, 3 bath, 2,450 sq ft, built 2021
+- A photo gallery section with 6 image placeholders in a grid
+- Features list with icons (pool, garage, garden, smart home, solar panels, fireplace)
+- Neighborhood info section with nearby schools, restaurants, parks
+- A mortgage calculator with sliders for down payment and interest rate
+- An agent contact form with name, email, phone, message fields
+- A Google Maps embed placeholder
+- A "Similar Properties" section with 3 cards
+- Full responsive design with a mobile hamburger menu
+- Use CSS variables for the color scheme (warm earth tones)
+- All in a single self-contained HTML file with embedded CSS and minimal JS for the calculator and menu
+Output ONLY the HTML code, nothing else.`;
+function loadConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(AI_CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+// ── Colors ──────────────────────────────────────────────────────────
+const GREEN = '\x1b[32m', RED = '\x1b[31m', CYAN = '\x1b[36m', YELLOW = '\x1b[33m';
+const BOLD = '\x1b[1m', DIM = '\x1b[2m', MAGENTA = '\x1b[35m', RESET = '\x1b[0m';
+function hr() { console.log('─'.repeat(70)); }
+// ── Resolve Claude Code executable ──────────────────────────────────
+function resolveClaudeExe() {
+    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)) {
+                try {
+                    execSync(`${nativePath} --version`, { stdio: 'pipe', timeout: 5000 });
+                    return nativePath;
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    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();
+// ── Proxy management ────────────────────────────────────────────────
+let proxyProcess = null;
+async function startProxy(apiKey, model, port) {
+    const proxyBin = path.join(os.homedir(), '.cargo', 'bin', 'anthropic-proxy');
+    if (!fs.existsSync(proxyBin)) {
+        throw new Error(`anthropic-proxy not found at ${proxyBin}`);
+    }
+    const proxyEnv = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (v !== undefined)
+            proxyEnv[k] = v;
+    }
+    proxyEnv.UPSTREAM_BASE_URL = 'https://api.cerebras.ai/v1';
+    proxyEnv.UPSTREAM_API_KEY = apiKey;
+    proxyEnv.PORT = String(port);
+    proxyEnv.COMPLETION_MODEL = model;
+    proxyEnv.REASONING_MODEL = model;
+    proxyEnv.PATH = `${path.join(os.homedir(), '.cargo', 'bin')}:${proxyEnv.PATH || ''}`;
+    proxyProcess = spawn(proxyBin, [], { env: proxyEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+    // Wait for proxy to be ready
+    for (let i = 0; i < 30; i++) {
+        await new Promise(r => setTimeout(r, 300));
+        try {
+            const resp = await fetch(`http://127.0.0.1:${port}/v1/messages`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'x-api-key': 'ping', 'anthropic-version': '2023-06-01' },
+                body: JSON.stringify({ model, max_tokens: 4, messages: [{ role: 'user', content: 'hi' }] }),
+            });
+            if (resp.ok || resp.status === 400)
+                return;
+        }
+        catch { }
+    }
+    throw new Error('Proxy health check timed out');
+}
+function stopProxy() {
+    if (proxyProcess) {
+        try {
+            proxyProcess.kill('SIGTERM');
+        }
+        catch { }
+        setTimeout(() => { try {
+            proxyProcess?.kill('SIGKILL');
+        }
+        catch { } }, 2000);
+        proxyProcess = null;
+    }
+}
+async function runSdkBenchmark(provider) {
+    const start = Date.now();
+    let initMs = 0;
+    let firstTokenMs = 0;
+    let outputText = '';
+    let writeToolCalls = 0;
+    let assistantEvents = 0;
+    let toolResultEvents = 0;
+    let firstAssistant = true;
+    const eventTypes = new Set();
+    fs.mkdirSync(EMPTY_DIR, { recursive: true });
+    const env = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (v !== undefined)
+            env[k] = v;
+    }
+    env.ANTHROPIC_API_KEY = provider.apiKey;
+    env.ANTHROPIC_BASE_URL = provider.baseUrl;
+    env.ANTHROPIC_MODEL = provider.model;
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL = provider.model;
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL = provider.model;
+    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = provider.model;
+    env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
+    env.IS_SANDBOX = '1';
+    env.CLAUDE_CONFIG_DIR = EMPTY_DIR;
+    try {
+        const q = query({
+            prompt: TASK_PROMPT,
+            options: {
+                apiKey: provider.apiKey,
+                model: provider.model,
+                cwd: '/tmp',
+                permissionMode: 'bypassPermissions',
+                allowDangerouslySkipPermissions: true,
+                maxTurns: 5,
+                env,
+                settings: { env },
+                ...(CLAUDE_EXE ? { pathToClaudeCodeExecutable: CLAUDE_EXE } : {}),
+            },
+        });
+        for await (const event of q) {
+            const now = Date.now();
+            eventTypes.add(event.type);
+            if (event.type === 'system' && event.subtype === 'init') {
+                initMs = now - start;
+            }
+            if (event.type === 'assistant') {
+                if (firstAssistant) {
+                    firstTokenMs = now - start;
+                    firstAssistant = false;
+                }
+                assistantEvents++;
+                const data = event.data;
+                if (typeof data === 'string') {
+                    try {
+                        const parsed = JSON.parse(data);
+                        for (const block of (parsed?.content || [])) {
+                            if (block.type === 'text' && block.text) {
+                                outputText += block.text;
+                            }
+                            if (block.type === 'tool_use') {
+                                if (block.name === 'Write') {
+                                    writeToolCalls++;
+                                    // Capture the file content from Write tool input
+                                    if (block.input?.content) {
+                                        outputText += block.input.content;
+                                    }
+                                    if (block.input?.file_path) {
+                                        outputText += `\n<!-- File: ${block.input.file_path} -->\n`;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        outputText += data;
+                    }
+                }
+            }
+            if (event.type === 'tool_use_summary') {
+                toolResultEvents++;
+                // tool_use_summary contains tool results in metadata
+                const data = event.data;
+                if (typeof data === 'string') {
+                    try {
+                        const parsed = JSON.parse(data);
+                        // Extract tool result text
+                        const result = parsed?.metadata?.toolResult;
+                        if (result) {
+                            if (typeof result === 'string')
+                                outputText += result;
+                            else if (typeof result === 'object')
+                                outputText += JSON.stringify(result);
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (event.type === 'result') {
+                const totalMs = now - start;
+                // Also try to extract text from the result event itself
+                const data = event.data;
+                if (typeof data === 'string') {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (parsed.result)
+                            outputText += parsed.result;
+                    }
+                    catch { }
+                }
+                const outputChars = outputText.length;
+                const estimatedTokens = Math.round(outputChars / 3.5);
+                const tps = estimatedTokens > 0 && totalMs > 0 ? (estimatedTokens / (totalMs / 1000)) : 0;
+                return { provider: provider.name, totalMs, initMs, firstTokenMs, outputText, outputChars, estimatedTokens, tps, writeToolCalls, assistantEvents, toolResultEvents, allEventTypes: Array.from(eventTypes) };
+            }
+        }
+        const totalMs = Date.now() - start;
+        const outputChars = outputText.length;
+        const estimatedTokens = Math.round(outputChars / 3.5);
+        const tps = estimatedTokens > 0 && totalMs > 0 ? (estimatedTokens / (totalMs / 1000)) : 0;
+        return { provider: provider.name, totalMs, initMs, firstTokenMs, outputText, outputChars, estimatedTokens, tps, writeToolCalls, assistantEvents, toolResultEvents, allEventTypes: Array.from(eventTypes) };
+    }
+    catch (err) {
+        return {
+            provider: provider.name, totalMs: Date.now() - start, initMs, firstTokenMs,
+            outputText, outputChars: outputText.length, estimatedTokens: 0, tps: 0,
+            writeToolCalls, assistantEvents, toolResultEvents, allEventTypes: Array.from(eventTypes),
+            error: err.message,
+        };
+    }
+}
+// ── Main ────────────────────────────────────────────────────────────
+async function main() {
+    console.log(`\n${BOLD}╔══════════════════════════════════════════════════════════════════════╗${RESET}`);
+    console.log(`${BOLD}║  SDK Benchmark: MiniMax M2.7-highspeed vs Cerebras zai-glm-4.7     ║${RESET}`);
+    console.log(`${BOLD}║  Task: Generate a complete HTML real estate page                    ║${RESET}`);
+    console.log(`${BOLD}╚══════════════════════════════════════════════════════════════════════╝${RESET}\n`);
+    const config = loadConfig();
+    const minimaxKey = config.minimaxApiKey || process.env.MINIMAX_API_KEY || '';
+    const cerebrasKey = process.env.CEREBRAS_API_KEY || 'csk-866r3e66p52mcmj3v4f29fdc86nr8pjx6yd4chxhvk8v2f3r';
+    if (!CLAUDE_EXE) {
+        console.log(`${RED}ERROR: Claude Code executable not found. Need @anthropic-ai/claude-agent-sdk-linux-x64${RESET}`);
+        process.exit(1);
+    }
+    console.log(`${CYAN}Claude Exe:${RESET}  ${CLAUDE_EXE}`);
+    console.log(`${CYAN}Task:${RESET}       Generate HTML real estate page (~${TASK_PROMPT.length} char prompt)`);
+    console.log();
+    const providers = [];
+    if (minimaxKey) {
+        providers.push({
+            name: 'MiniMax M2.7-highspeed',
+            model: 'MiniMax-M2.7-highspeed',
+            apiKey: minimaxKey,
+            baseUrl: 'https://api.minimax.io/anthropic',
+            needsProxy: false,
+        });
+    }
+    else {
+        console.log(`${YELLOW}WARNING: No MiniMax API key. Skipping MiniMax test.${RESET}\n`);
+    }
+    providers.push({
+        name: 'Cerebras zai-glm-4.7',
+        model: 'zai-glm-4.7',
+        apiKey: cerebrasKey,
+        baseUrl: `http://127.0.0.1:${PROXY_PORT}`,
+        needsProxy: true,
+        proxyPort: PROXY_PORT,
+    });
+    const allResults = [];
+    for (const provider of providers) {
+        console.log(`${BOLD}${MAGENTA}═══ ${provider.name} ═══${RESET}`);
+        hr();
+        // Start proxy if needed
+        if (provider.needsProxy) {
+            console.log(`${DIM}Starting anthropic-proxy-rs for Cerebras...${RESET}`);
+            try {
+                await startProxy(cerebrasKey, provider.model, provider.proxyPort);
+                console.log(`${DIM}Proxy ready on port ${provider.proxyPort}${RESET}\n`);
+            }
+            catch (err) {
+                console.log(`${RED}Proxy failed: ${err.message}. Skipping Cerebras.${RESET}\n`);
+                continue;
+            }
+        }
+        console.log(`${CYAN}Model:${RESET}    ${provider.model}`);
+        console.log(`${CYAN}Base URL:${RESET} ${provider.baseUrl}`);
+        console.log(`${CYAN}API Key:${RESET}  ${provider.apiKey.slice(0, 12)}...`);
+        console.log();
+        // Run 1
+        console.log(`${DIM}[${new Date().toISOString()}] Starting query()...${RESET}`);
+        const result = await runSdkBenchmark(provider);
+        allResults.push(result);
+        if (result.error) {
+            console.log(`${RED}FAILED: ${result.error}${RESET}\n`);
+        }
+        else {
+            console.log(`${GREEN}Completed in ${(result.totalMs / 1000).toFixed(1)}s${RESET}`);
+            console.log(`  Init (spawn):        ${result.initMs}ms`);
+            console.log(`  Time to 1st token:   ${result.firstTokenMs}ms`);
+            console.log(`  Total duration:      ${(result.totalMs / 1000).toFixed(1)}s`);
+            console.log(`  Event types:         ${result.allEventTypes.join(', ')}`);
+            console.log(`  Assistant events:    ${result.assistantEvents}`);
+            console.log(`  Tool result events:  ${result.toolResultEvents}`);
+            console.log(`  Write tool calls:    ${result.writeToolCalls}`);
+            console.log(`  Output chars:        ${result.outputChars.toLocaleString()}`);
+            console.log(`  Estimated tokens:    ~${result.estimatedTokens.toLocaleString()}`);
+            console.log(`  Throughput:          ${BOLD}${GREEN}${result.tps.toFixed(1)} tokens/sec${RESET}`);
+            // Save the output
+            const slug = provider.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+            const outputPath = `/tmp/benchmark-${slug}.txt`;
+            fs.writeFileSync(outputPath, result.outputText);
+            console.log(`  Output saved:        ${outputPath}`);
+        }
+        console.log();
+        // Stop proxy
+        if (provider.needsProxy) {
+            stopProxy();
+        }
+    }
+    // ── Comparison ────────────────────────────────────────────────────
+    console.log(`${BOLD}══════════════════════════════════════════════════════════════════════${RESET}`);
+    console.log(`${BOLD}  COMPARISON${RESET}`);
+    console.log(`${BOLD}══════════════════════════════════════════════════════════════════════${RESET}\n`);
+    const validResults = allResults.filter(r => !r.error);
+    for (const r of validResults) {
+        console.log(`  ${CYAN}${r.provider}:${RESET}`);
+        console.log(`    Duration:   ${(r.totalMs / 1000).toFixed(1)}s`);
+        console.log(`    Tokens:     ~${r.estimatedTokens.toLocaleString()}`);
+        console.log(`    TPS:        ${GREEN}${BOLD}${r.tps.toFixed(1)}${RESET}`);
+        console.log(`    1st token:  ${(r.firstTokenMs / 1000).toFixed(1)}s`);
+        console.log();
+    }
+    if (validResults.length === 2) {
+        const [a, b] = validResults;
+        const faster = a.totalMs < b.totalMs ? a : b;
+        const slower = a.totalMs < b.totalMs ? b : a;
+        const speedup = (slower.totalMs / faster.totalMs).toFixed(1);
+        const saved = ((slower.totalMs - faster.totalMs) / 1000).toFixed(1);
+        console.log(`  ${BOLD}Winner:${RESET} ${GREEN}${faster.provider}${RESET} is ${BOLD}${speedup}x faster${RESET}`);
+        console.log(`  ${BOLD}Time saved:${RESET} ${saved}s`);
+        console.log();
+        if (faster.tps > slower.tps) {
+            const tpsDiff = (faster.tps / slower.tps).toFixed(1);
+            console.log(`  ${BOLD}TPS advantage:${RESET} ${faster.provider} is ${tpsDiff}x higher throughput`);
+        }
+    }
+    console.log(`${BOLD}══════════════════════════════════════════════════════════════════════${RESET}\n`);
+}
+process.on('SIGINT', () => { stopProxy(); process.exit(130); });
+process.on('SIGTERM', () => { stopProxy(); process.exit(143); });
+process.on('exit', () => stopProxy());
+main().catch((err) => {
+    console.error('Unhandled error:', err);
+    stopProxy();
+    process.exit(1);
+});

package/dist/cli/index.js

@@ -8,6 +8,7 @@ import path from 'path';
 import os, { networkInterfaces } from 'os';
 import { Buffer } from 'buffer';
 import crypto from 'crypto';
+import { stopAllProxies } from './proxyManager.js';
 import { createProject, deleteProject } from './projectManager.js';
 import { startSending, startReceiving } from './transferService.js';
 import { registerGitHubHandlers } from './githubHandlers.js';
@@ -212,7 +213,7 @@ async function connect() {
     const deviceId = await getDeviceId();
     return new Promise((resolve, reject) => {
         const socket = io(config.apiUrl, {
-            transports: ['websocket', 'polling'],
+            transports: ['polling', 'websocket'],
         });
         socket.on('connect', () => {
             socket.emit('register', { type: 'cli', deviceId });
@@ -473,7 +474,7 @@ async function runDaemon(foreground = false, email) {
                 socket = null;
             }
             socket = io(config.apiUrl, {
-                transports: ['websocket', 'polling'],
+                transports: ['polling', 'websocket'],
                 reconnection: true,
                 reconnectionDelay: 1000,
                 reconnectionDelayMax: 10000,
@@ -971,6 +972,7 @@ async function runDaemon(foreground = false, email) {
             }
             socket.disconnect();
         }
+        stopAllProxies();
         process.exit(0);
     };
     process.on('SIGTERM', shutdown);

package/dist/cli/moduleMcpServer.js

@@ -9,6 +9,7 @@ import { z } from 'zod';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import sharp from 'sharp';
 import { getOpenrouterApiKey, getApiUrl } from './agentSession.js';
 const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
 /** Comprehensive MIME type map for file extension detection */
@@ -51,12 +52,53 @@ function getMimeType(filePath) {
     const ext = path.extname(filePath).toLowerCase().replace('.', '');
     return MIME_MAP[ext] || 'application/octet-stream';
 }
+const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'tiff', 'tif', 'avif']);
+const MAX_IMAGE_DIMENSION = 2048; // max width or height in pixels
+const MAX_IMAGE_BYTES = 2 * 1024 * 1024; // 2 MB target after compression
+function isImageFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    return IMAGE_EXTENSIONS.has(ext);
+}
+/**
+ * Compress and resize an image buffer using sharp.
+ * - Resizes so neither dimension exceeds MAX_IMAGE_DIMENSION (fit: inside, no upscale)
+ * - Converts to JPEG quality 80 (or WebP for non-photo sources)
+ * - If already small enough, returns the original buffer unchanged
+ */
+async function compressImage(buf) {
+    const metadata = await sharp(buf).metadata();
+    const { width = 0, height = 0, size = 0 } = metadata;
+    // If already under limits, keep as-is
+    const needsResize = width > MAX_IMAGE_DIMENSION || height > MAX_IMAGE_DIMENSION;
+    const needsCompress = (size || buf.length) > MAX_IMAGE_BYTES;
+    if (!needsResize && !needsCompress) {
+        // Keep original format
+        const fmt = metadata.format || 'jpeg';
+        const mime = fmt === 'png' ? 'image/png' : fmt === 'webp' ? 'image/webp' : 'image/jpeg';
+        return { data: buf, mime };
+    }
+    let pipeline = sharp(buf)
+        .resize(MAX_IMAGE_DIMENSION, MAX_IMAGE_DIMENSION, { fit: 'inside', withoutEnlargement: true });
+    // Convert to JPEG for best compression on photos; use WebP for PNGs with alpha
+    const hasAlpha = metadata.hasAlpha;
+    if (hasAlpha) {
+        pipeline = pipeline.webp({ quality: 80 });
+        return { data: await pipeline.toBuffer(), mime: 'image/webp' };
+    }
+    pipeline = pipeline.jpeg({ quality: 80 });
+    return { data: await pipeline.toBuffer(), mime: 'image/jpeg' };
+}
 /**
- * Convert a file to a data URI (base64 encoded)
+ * Convert a file to a data URI (base64 encoded).
+ * Images are compressed and resized before encoding.
  */
-function fileToDataUri(filePath) {
+async function fileToDataUri(filePath) {
     try {
         const buf = fs.readFileSync(filePath);
+        if (isImageFile(filePath)) {
+            const { data, mime } = await compressImage(buf);
+            return `data:${mime};base64,${data.toString('base64')}`;
+        }
         const mime = getMimeType(filePath);
         return `data:${mime};base64,${buf.toString('base64')}`;
     }
@@ -83,7 +125,7 @@ function createAnalyzeImageTool(attachmentDir) {
             if (!fs.existsSync(imagePath)) {
                 return { content: [{ type: 'text', text: `Error: Image file not found: ${args.image_path}` }], isError: true };
             }
-            const dataUri = fileToDataUri(imagePath);
+            const dataUri = await fileToDataUri(imagePath);
             if (!dataUri) {
                 return { content: [{ type: 'text', text: `Error: Could not read image file: ${args.image_path}` }], isError: true };
             }

package/dist/cli/proxyManager.js

@@ -0,0 +1,214 @@
+/**
+ * Proxy Manager - Manages anthropic-proxy-rs instances
+ *
+ * Auto-installs anthropic-proxy-rs via cargo if not found.
+ * Provides start/stop/reuse of proxy instances for any OpenAI-compatible provider.
+ *
+ * Usage:
+ *   import { ensureProxy, stopAllProxies } from './proxyManager.js'
+ *
+ *   const proxyUrl = await ensureProxy({
+ *     upstreamUrl: 'https://api.cerebras.ai/v1',
+ *     apiKey: 'csk-...',
+ *     model: 'zai-glm-4.7',
+ *   })
+ *   // proxyUrl = 'http://127.0.0.1:8321' — Anthropic-compatible endpoint
+ */
+import { spawn, execSync } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import net from 'net';
+const runningProxies = new Map();
+// ── Binary resolution ───────────────────────────────────────────────
+function getProxyBinPath() {
+    return path.join(os.homedir(), '.cargo', 'bin', 'anthropic-proxy');
+}
+function isCargoInstalled() {
+    try {
+        execSync('cargo --version', { stdio: 'pipe', timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isProxyInstalled() {
+    return existsSync(getProxyBinPath());
+}
+/**
+ * Install anthropic-proxy-rs via cargo.
+ * Throws if cargo is not available or install fails.
+ */
+export async function installProxy() {
+    const binPath = getProxyBinPath();
+    if (existsSync(binPath))
+        return;
+    console.log('[proxyManager] anthropic-proxy not found, installing via cargo...');
+    if (!isCargoInstalled()) {
+        console.log('[proxyManager] Installing Rust toolchain...');
+        execSync("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y", {
+            stdio: 'pipe',
+            timeout: 120_000,
+            env: { ...process.env },
+        });
+    }
+    const cargoBin = path.join(os.homedir(), '.cargo', 'bin', 'cargo');
+    const cargoCmd = existsSync(cargoBin) ? cargoBin : 'cargo';
+    execSync(`${cargoCmd} install --git https://github.com/m0n0x41d/anthropic-proxy-rs --locked`, {
+        stdio: 'pipe',
+        timeout: 300_000,
+        env: {
+            ...process.env,
+            PATH: `${path.join(os.homedir(), '.cargo', 'bin')}:${process.env.PATH || ''}`,
+        },
+    });
+    if (!existsSync(binPath)) {
+        throw new Error('anthropic-proxy installation completed but binary not found at ' + binPath);
+    }
+    console.log('[proxyManager] anthropic-proxy installed successfully');
+}
+// ── Port finding ────────────────────────────────────────────────────
+function findFreePort(start, end) {
+    return new Promise((resolve, reject) => {
+        function tryPort(port) {
+            if (port > end) {
+                reject(new Error(`No free port in range ${start}-${end}`));
+                return;
+            }
+            const server = net.createServer();
+            server.listen(port, '127.0.0.1', () => {
+                const addr = server.address();
+                server.close(() => resolve(typeof addr === 'object' && addr ? addr.port : port));
+            });
+            server.on('error', () => tryPort(port + 1));
+        }
+        tryPort(start);
+    });
+}
+// ── Wait for proxy to be ready ──────────────────────────────────────
+function waitForProxy(port, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        function check() {
+            const socket = new net.Socket();
+            socket.setTimeout(500);
+            socket.on('connect', () => {
+                socket.destroy();
+                resolve();
+            });
+            socket.on('error', () => {
+                socket.destroy();
+                if (Date.now() - start > timeoutMs) {
+                    reject(new Error(`Proxy on port ${port} did not become ready within ${timeoutMs}ms`));
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            });
+            socket.on('timeout', () => {
+                socket.destroy();
+                if (Date.now() - start > timeoutMs) {
+                    reject(new Error(`Proxy on port ${port} did not become ready within ${timeoutMs}ms`));
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            });
+            socket.connect(port, '127.0.0.1');
+        }
+        check();
+    });
+}
+// ── Start / get proxy ───────────────────────────────────────────────
+function proxyKey(config) {
+    return `${config.upstreamUrl}::${config.model}`;
+}
+/**
+ * Ensure a proxy is running for the given config.
+ * Reuses existing proxy if already running for the same upstream+model.
+ * Auto-installs anthropic-proxy-rs if not found.
+ *
+ * Returns the local proxy URL (e.g. http://127.0.0.1:8321).
+ */
+export async function ensureProxy(config) {
+    const key = proxyKey(config);
+    // Reuse existing
+    const existing = runningProxies.get(key);
+    if (existing && !existing.process.killed) {
+        return existing.url;
+    }
+    // Auto-install if needed
+    await installProxy();
+    const portStart = config.portStart ?? 8321;
+    const portEnd = config.portEnd ?? 8340;
+    const port = await findFreePort(portStart, portEnd);
+    const binPath = getProxyBinPath();
+    const env = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (v !== undefined)
+            env[k] = v;
+    }
+    env.UPSTREAM_BASE_URL = config.upstreamUrl;
+    env.UPSTREAM_API_KEY = config.apiKey;
+    env.PORT = String(port);
+    env.COMPLETION_MODEL = config.model;
+    env.REASONING_MODEL = config.model;
+    env.PATH = `${path.join(os.homedir(), '.cargo', 'bin')}:${env.PATH || ''}`;
+    const child = spawn(binPath, [], {
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: false,
+    });
+    // Log proxy stderr for debugging
+    child.stderr?.on('data', (data) => {
+        const msg = data.toString().trim();
+        if (msg.includes('ERROR') || msg.includes('WARN')) {
+            console.error(`[proxyManager:${port}] ${msg}`);
+        }
+    });
+    child.on('exit', (code) => {
+        runningProxies.delete(key);
+        if (code && code !== 0) {
+            console.error(`[proxyManager] Proxy exited with code ${code}`);
+        }
+    });
+    // Wait for proxy to be listening
+    await waitForProxy(port, 10_000);
+    const url = `http://127.0.0.1:${port}`;
+    runningProxies.set(key, { process: child, port, url, key });
+    console.log(`[proxyManager] Started proxy on port ${port} -> ${config.upstreamUrl} (model: ${config.model})`);
+    return url;
+}
+/**
+ * Stop a specific proxy by config.
+ */
+export function stopProxy(config) {
+    const key = proxyKey(config);
+    const proxy = runningProxies.get(key);
+    if (proxy) {
+        try {
+            proxy.process.kill('SIGTERM');
+        }
+        catch { }
+        runningProxies.delete(key);
+    }
+}
+/**
+ * Stop all running proxies.
+ */
+export function stopAllProxies() {
+    for (const [, proxy] of runningProxies) {
+        try {
+            proxy.process.kill('SIGTERM');
+        }
+        catch { }
+    }
+    runningProxies.clear();
+}
+/**
+ * Check if anthropic-proxy-rs is installed.
+ */
+export function isInstalled() {
+    return isProxyInstalled();
+}

package/dist/shared/types/embed.js

@@ -0,0 +1,5 @@
+/**
+ * Types for embeddable script feature
+ * Allows websites to embed a floating AI button connected to TalkToCode sessions
+ */
+export {};

package/dist/shared/types.js

@@ -33,3 +33,5 @@ export function isWebFetchOutput(r) {
 export function isAgentOutput(r) {
     return typeof r === 'object' && r !== null && 'agentId' in r && 'status' in r && 'prompt' in r;
 }
+// ============ Embed Types ============
+export * from './types/embed.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {
@@ -44,12 +44,14 @@
     "fastify": "^5.7.2",
     "node-fetch": "^3.3.2",
     "pino-pretty": "^11.0.0",
+    "sharp": "^0.34.5",
     "socket.io-client": "^4.8.1",
     "uuid": "^11.0.3"
   },
   "devDependencies": {
     "@types/chokidar": "^2.1.3",
     "@types/node": "^22.10.2",
+    "@types/sharp": "^0.31.1",
     "@types/uuid": "^10.0.0",
     "@vercel/ncc": "^0.38.1",
     "esbuild": "^0.27.2",