@exreve/exk 1.0.54 → 1.0.56

package/dist/benchmark-startup.js

@@ -1,347 +0,0 @@
-/**
- * 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/cloudflaredHandlers.js

@@ -1,279 +0,0 @@
-/**
- * Cloudflared Handlers Module
- *
- * Handles cloudflared:check, cloudflared:sync, cloudflared:login,
- * cloudflared:regenerate operations.
- */
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { spawn, execSync } from 'child_process';
-export function registerCloudflaredHandlers(socket, foreground) {
-    socket.on('cloudflared:check:request', async () => {
-        try {
-            let installed = false;
-            let hasCert = false;
-            try {
-                execSync('which cloudflared', { stdio: 'ignore' });
-                installed = true;
-                const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
-                try {
-                    const stats = await fs.stat(certPath);
-                    hasCert = stats.isFile();
-                    if (foreground && hasCert) {
-                        console.log(`✓ Found cert.pem at ${certPath}`);
-                    }
-                }
-                catch (err) {
-                    hasCert = false;
-                    if (foreground) {
-                        console.log(`✗ cert.pem not found at ${certPath}: ${err.message}`);
-                    }
-                }
-            }
-            catch {
-                installed = false;
-            }
-            socket.emit('cloudflared:check:response', { installed, hasCert });
-            if (foreground) {
-                console.log(`Cloudflared check: installed=${installed}, hasCert=${hasCert}`);
-            }
-        }
-        catch (error) {
-            socket.emit('cloudflared:check:response', { installed: false, hasCert: false });
-        }
-    });
-    socket.on('cloudflared:sync:request', async () => {
-        try {
-            const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
-            if (foreground) {
-                console.log(`Syncing credentials from ${certPath}`);
-            }
-            const certContent = await fs.readFile(certPath, 'utf-8');
-            const tokenMatch = certContent.match(/-----BEGIN ARGO TUNNEL TOKEN-----\s*([\s\S]*?)\s*-----END ARGO TUNNEL TOKEN-----/);
-            if (tokenMatch && tokenMatch[1]) {
-                const tokenBase64 = tokenMatch[1].replace(/\s/g, '');
-                const tokenJson = Buffer.from(tokenBase64, 'base64').toString('utf-8');
-                const tokenData = JSON.parse(tokenJson);
-                const apiToken = tokenData.apiToken;
-                const accountId = tokenData.accountID;
-                const zoneId = tokenData.zoneID;
-                if (foreground) {
-                    console.log(`✓ Extracted credentials: accountId=${accountId}, zoneId=${zoneId}`);
-                }
-                socket.emit('cloudflared:sync:complete', {
-                    accountId,
-                    accountName: undefined,
-                    apiToken,
-                    zoneId
-                });
-            }
-            else {
-                const error = 'Failed to extract token from cert.pem';
-                if (foreground) {
-                    console.error(`✗ ${error}`);
-                }
-                socket.emit('cloudflared:sync:error', { error });
-            }
-        }
-        catch (error) {
-            const errorMsg = `Failed to read cert.pem: ${error.message}`;
-            if (foreground) {
-                console.error(`✗ ${errorMsg}`);
-            }
-            socket.emit('cloudflared:sync:error', { error: errorMsg });
-        }
-    });
-    socket.on('cloudflared:login:request', async () => {
-        try {
-            // Check if cloudflared is installed
-            try {
-                execSync('which cloudflared', { stdio: 'ignore' });
-            }
-            catch {
-                socket.emit('cloudflared:login:error', { error: 'cloudflared is not installed' });
-                return;
-            }
-            const loginProcess = spawn('cloudflared', ['tunnel', 'login'], {
-                stdio: ['ignore', 'pipe', 'pipe']
-            });
-            let stdout = '';
-            let stderr = '';
-            let urlEmitted = false;
-            let alreadyLoggedIn = false;
-            let certPath = null;
-            const extractCertPath = (text) => {
-                const pathMatch = text.match(/existing certificate at\s+([^\s]+)/i) ||
-                    text.match(/certificate at\s+([^\s]+)/i) ||
-                    text.match(/cert\.pem.*?at\s+([^\s]+)/i);
-                return pathMatch ? pathMatch[1] : null;
-            };
-            const extractLoginUrl = (text) => {
-                const urlPatterns = [
-                    /https:\/\/dash\.cloudflare\.com\/argotunnel[^\s\)]+/g,
-                    /https:\/\/[^\s\)]+cloudflareaccess\.org[^\s\)]+/g,
-                    /https:\/\/[^\s\)]+cloudflare\.com[^\s\)]+/g
-                ];
-                for (const pattern of urlPatterns) {
-                    const matches = text.match(pattern);
-                    if (matches && matches.length > 0) {
-                        return matches[0];
-                    }
-                }
-                return null;
-            };
-            loginProcess.stdout.on('data', (data) => {
-                const text = data.toString();
-                stdout += text;
-                if (text.includes('existing certificate') || text.includes('cert.pem which login would overwrite')) {
-                    alreadyLoggedIn = true;
-                    const extractedPath = extractCertPath(text);
-                    if (extractedPath) {
-                        certPath = extractedPath;
-                    }
-                }
-                if (!alreadyLoggedIn && !urlEmitted) {
-                    const url = extractLoginUrl(text);
-                    if (url) {
-                        urlEmitted = true;
-                        socket.emit('cloudflared:login:url', { loginUrl: url });
-                    }
-                }
-            });
-            loginProcess.stderr.on('data', (data) => {
-                const text = data.toString();
-                stderr += text;
-                if (text.includes('existing certificate') || text.includes('cert.pem which login would overwrite')) {
-                    alreadyLoggedIn = true;
-                    const extractedPath = extractCertPath(text);
-                    if (extractedPath) {
-                        certPath = extractedPath;
-                    }
-                }
-                if (!alreadyLoggedIn && !urlEmitted) {
-                    const url = extractLoginUrl(text);
-                    if (url) {
-                        urlEmitted = true;
-                        socket.emit('cloudflared:login:url', { loginUrl: url });
-                    }
-                }
-            });
-            loginProcess.on('close', async (code) => {
-                if (alreadyLoggedIn && certPath) {
-                    // Already logged in - extract credentials from existing cert
-                    try {
-                        if (foreground) {
-                            console.log(`Already logged in, extracting credentials from ${certPath}`);
-                        }
-                        const certContent = await fs.readFile(certPath, 'utf-8');
-                        const tokenMatch = certContent.match(/-----BEGIN ARGO TUNNEL TOKEN-----\s*([\s\S]*?)\s*-----END ARGO TUNNEL TOKEN-----/);
-                        if (tokenMatch && tokenMatch[1]) {
-                            const tokenBase64 = tokenMatch[1].replace(/\s/g, '');
-                            const tokenJson = Buffer.from(tokenBase64, 'base64').toString('utf-8');
-                            const tokenData = JSON.parse(tokenJson);
-                            if (foreground) {
-                                console.log(`✓ Extracted credentials from existing cert`);
-                            }
-                            socket.emit('cloudflared:login:complete', {
-                                accountId: tokenData.accountID,
-                                accountName: undefined,
-                                apiToken: tokenData.apiToken,
-                                zoneId: tokenData.zoneID
-                            });
-                        }
-                        else {
-                            const error = 'Failed to extract token from existing cert.pem';
-                            if (foreground) {
-                                console.error(`✗ ${error}`);
-                            }
-                            socket.emit('cloudflared:login:error', { error });
-                        }
-                    }
-                    catch (error) {
-                        const errorMsg = `Failed to read cert.pem: ${error.message}`;
-                        if (foreground) {
-                            console.error(`✗ ${errorMsg}`);
-                        }
-                        socket.emit('cloudflared:login:error', { error: errorMsg });
-                    }
-                }
-                else if (code === 0 && !alreadyLoggedIn) {
-                    // Login completed successfully - wait a moment then extract credentials
-                    if (foreground) {
-                        console.log('Login completed, extracting credentials...');
-                    }
-                    setTimeout(async () => {
-                        try {
-                            const certFilePath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
-                            const certContent = await fs.readFile(certFilePath, 'utf-8');
-                            const tokenMatch = certContent.match(/-----BEGIN ARGO TUNNEL TOKEN-----\s*([\s\S]*?)\s*-----END ARGO TUNNEL TOKEN-----/);
-                            if (tokenMatch && tokenMatch[1]) {
-                                const tokenBase64 = tokenMatch[1].replace(/\s/g, '');
-                                const tokenJson = Buffer.from(tokenBase64, 'base64').toString('utf-8');
-                                const tokenData = JSON.parse(tokenJson);
-                                if (foreground) {
-                                    console.log(`✓ Extracted credentials after login`);
-                                }
-                                socket.emit('cloudflared:login:complete', {
-                                    accountId: tokenData.accountID,
-                                    accountName: undefined,
-                                    apiToken: tokenData.apiToken,
-                                    zoneId: tokenData.zoneID
-                                });
-                            }
-                            else {
-                                const error = 'Failed to extract token from cert.pem after login';
-                                if (foreground) {
-                                    console.error(`✗ ${error}`);
-                                }
-                                socket.emit('cloudflared:login:error', { error });
-                            }
-                        }
-                        catch (error) {
-                            const errorMsg = `Failed to read cert.pem after login: ${error.message}`;
-                            if (foreground) {
-                                console.error(`✗ ${errorMsg}`);
-                            }
-                            socket.emit('cloudflared:login:error', { error: errorMsg });
-                        }
-                    }, 1000);
-                }
-                else if (!alreadyLoggedIn) {
-                    const error = `Login failed with code ${code}: ${stderr || stdout}`;
-                    if (foreground) {
-                        console.error(`✗ ${error}`);
-                    }
-                    socket.emit('cloudflared:login:error', { error });
-                }
-            });
-            loginProcess.on('error', (error) => {
-                socket.emit('cloudflared:login:error', { error: error.message });
-            });
-        }
-        catch (error) {
-            socket.emit('cloudflared:login:error', { error: error.message });
-        }
-    });
-    socket.on('cloudflared:regenerate:request', async () => {
-        try {
-            const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
-            // Delete existing cert.pem
-            try {
-                await fs.unlink(certPath);
-                if (foreground) {
-                    console.log(`✓ Deleted existing cert.pem`);
-                }
-            }
-            catch (error) {
-                if (foreground && error.code !== 'ENOENT') {
-                    console.log(`Note: Could not delete cert.pem: ${error.message}`);
-                }
-            }
-            // Emit success - frontend will then trigger login
-            socket.emit('cloudflared:regenerate:complete', {});
-        }
-        catch (error) {
-            socket.emit('cloudflared:regenerate:error', { error: error.message });
-        }
-    });
-}