@exreve/exk 1.0.55 → 1.0.57

package/dist/app-child.js

@@ -1,1038 +0,0 @@
-#!/usr/bin/env node
-/**
- * TalkToCode CLI - Child Process (App Bundle)
- *
- * This is the child process that contains all application logic.
- * It is spawned by the updater process (updater.ts).
- *
- * This file is what gets updated during updates - the updater stays constant.
- */
-import { Command } from 'commander';
-import { io } from 'socket.io-client';
-import { v4 as uuidv4 } from 'uuid';
-import fs from 'fs/promises';
-import fsSync from 'fs';
-import path from 'path';
-import os, { networkInterfaces } from 'os';
-import { Buffer } from 'buffer';
-import crypto from 'crypto';
-import { createProject, deleteProject } from './projectManager.js';
-import { agentSessionManager } from './agentSession.js';
-import { registerGitHubHandlers } from './githubHandlers.js';
-import { registerCloudflaredHandlers } from './cloudflaredHandlers.js';
-import { registerContainerHandlers } from './containerHandlers.js';
-import { registerSessionHandlers } from './sessionHandlers.js';
-import { registerAppHandlers } from './appHandlers.js';
-import { registerFsHandlers } from './fsHandlers.js';
-import { registerUpdateHandlers } from './updateHandlers.js';
-import { execSync } from 'child_process';
-import readline from 'readline';
-import { fileURLToPath } from 'url';
-import { createHash } from 'crypto';
-// ============ Update IPC (Child -> Updater) ============
-/**
- * Request update from parent updater process
- */
-function requestUpdateFromParent() {
-    const updaterPid = process.env.TTC_UPDATER_PID;
-    if (updaterPid) {
-        try {
-            // Send SIGUSR1 to parent to request update
-            process.kill(parseInt(updaterPid, 10), 'SIGUSR1');
-        }
-        catch (error) {
-            console.error('Failed to request update from parent:', error);
-        }
-    }
-}
-// ============ Constants ============
-const CONFIG_DIR = path.join(os.homedir(), '.talk-to-code');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const DEVICE_ID_FILE = path.join(CONFIG_DIR, 'device-id.json');
-const DEVICE_CONFIG_FILE = path.join(CONFIG_DIR, 'device-config.json');
-const AI_CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
-const DEFAULT_API_URL = 'https://api.talk-to-code.com';
-// ============ Helpers ============
-async function readConfig() {
-    try {
-        const data = await fs.readFile(CONFIG_FILE, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch {
-        return { apiUrl: DEFAULT_API_URL };
-    }
-}
-async function writeConfig(config) {
-    await fs.mkdir(CONFIG_DIR, { recursive: true });
-    await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-/**
- * Fetch AI config from server and save to ~/.talk-to-code/ai-config.json
- */
-async function fetchAiConfig(authToken) {
-    try {
-        const config = await readConfig();
-        const res = await fetch(`${config.apiUrl}/config/ai`, {
-            headers: { Authorization: `Bearer ${authToken}` },
-        });
-        if (!res.ok) {
-            console.log(`[fetchAiConfig] Server returned ${res.status}`);
-            return false;
-        }
-        const data = await res.json();
-        if (!data.success || !data.aiConfig) {
-            console.log('[fetchAiConfig] No AI config available for this user');
-            return false;
-        }
-        await fs.writeFile(AI_CONFIG_FILE, JSON.stringify(data.aiConfig, null, 2));
-        console.log('[fetchAiConfig] AI config saved successfully');
-        return true;
-    }
-    catch (error) {
-        console.log(`[fetchAiConfig] Failed: ${error.message}`);
-        return false;
-    }
-}
-/** 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;
-    }
-    catch {
-        return false;
-    }
-}
-async function readDeviceAuthToken() {
-    const env = process.env.TTC_AUTH_TOKEN?.trim();
-    if (env)
-        return env;
-    try {
-        const raw = await fs.readFile(DEVICE_CONFIG_FILE, 'utf-8');
-        const j = JSON.parse(raw);
-        return typeof j.authToken === 'string' ? j.authToken.trim() : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function readDiskDeviceConfig() {
-    try {
-        const raw = await fs.readFile(DEVICE_CONFIG_FILE, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return {};
-    }
-}
-async function writeDeviceConfigMerged(partial) {
-    const prev = await readDiskDeviceConfig();
-    const email = partial.email !== undefined ? partial.email : prev.email;
-    let token;
-    if (partial.authToken !== undefined) {
-        token = partial.authToken.trim() || undefined;
-    }
-    else {
-        token = typeof prev.authToken === 'string' && prev.authToken.trim() ? prev.authToken.trim() : undefined;
-    }
-    const out = {};
-    if (email)
-        out.email = email;
-    if (token)
-        out.authToken = token;
-    await fs.mkdir(CONFIG_DIR, { recursive: true });
-    await fs.writeFile(DEVICE_CONFIG_FILE, JSON.stringify(out, null, 2));
-}
-async function maybeFetchAiConfigIfMissing() {
-    if (hasAiCredentials())
-        return;
-    const jwt = await readDeviceAuthToken();
-    if (!jwt)
-        return;
-    const ok = await fetchAiConfig(jwt);
-    if (!ok && !hasAiCredentials()) {
-        const cfg = await readConfig();
-        console.warn(`[CLI] No AI key in ai-config.json yet. Could not sync from ${cfg.apiUrl}/config/ai — agent prompts will fail until this succeeds.`);
-    }
-}
-function scheduleAiConfigSync(authToken) {
-    void fetchAiConfig(authToken).then((ok) => {
-        if (!ok && !hasAiCredentials()) {
-            console.warn('[CLI] AI config sync failed; check backend /config/ai and apiUrl.');
-        }
-    });
-}
-async function getDeviceId() {
-    try {
-        const data = await fs.readFile(DEVICE_ID_FILE, 'utf-8');
-        return JSON.parse(data).deviceId;
-    }
-    catch {
-        const deviceId = uuidv4();
-        await fs.mkdir(CONFIG_DIR, { recursive: true });
-        await fs.writeFile(DEVICE_ID_FILE, JSON.stringify({ deviceId }, null, 2));
-        return deviceId;
-    }
-}
-function getLocalIpAddress() {
-    const nets = networkInterfaces();
-    for (const name of Object.keys(nets)) {
-        for (const net of nets[name]) {
-            if (net.family === 'IPv4' && !net.internal) {
-                return net.address;
-            }
-        }
-    }
-    return 'Unknown';
-}
-function getHostname() {
-    return os.hostname() || 'Unknown';
-}
-async function connect() {
-    const config = await readConfig();
-    const deviceId = await getDeviceId();
-    return new Promise((resolve, reject) => {
-        const socket = io(config.apiUrl, {
-            transports: ['websocket', 'polling'],
-        });
-        socket.on('connect', () => {
-            socket.emit('register', { type: 'cli', deviceId });
-            resolve(socket);
-        });
-        socket.on('registered', ({ type }) => {
-            console.log(`Connected as ${type}`);
-        });
-        socket.on('connect_error', (err) => {
-            reject(err);
-        });
-    });
-}
-const CURRENT_FILE = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(CURRENT_FILE);
-function getCliHash() {
-    return createHash('sha256').update(fsSync.readFileSync(CURRENT_FILE)).digest('hex');
-}
-async function checkForUpdate() {
-    try {
-        const config = await readConfig();
-        const res = await fetch(`${config.apiUrl}/update/check`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ hash: getCliHash(), platform: os.platform() })
-        });
-        if (!res.ok)
-            return null;
-        return await res.json();
-    }
-    catch {
-        return null;
-    }
-}
-async function replaceSelf(tarballBuffer) {
-    const extractDir = path.join(os.tmpdir(), `ttc-update-${Date.now()}`);
-    await fs.mkdir(extractDir, { recursive: true });
-    const tarPath = path.join(extractDir, 'ttc-cli.tar.gz');
-    await fs.writeFile(tarPath, tarballBuffer);
-    execSync(`tar -xzf "${tarPath}" -C "${extractDir}"`);
-    await fs.unlink(tarPath);
-    // Preserve user config/token files (never overwrite on update)
-    const preserveFiles = ['device-config.json', 'device-id.json', 'config.json'];
-    const preserved = {};
-    for (const f of preserveFiles) {
-        try {
-            preserved[f] = await fs.readFile(path.join(CONFIG_DIR, f));
-        }
-        catch {
-            /* file may not exist */
-        }
-    }
-    const cliDest = path.join(CONFIG_DIR, 'cli');
-    const sharedDest = path.join(CONFIG_DIR, 'shared');
-    await fs.rm(cliDest, { recursive: true, force: true });
-    await fs.rm(sharedDest, { recursive: true, force: true });
-    await fs.cp(path.join(extractDir, 'cli'), cliDest, { recursive: true });
-    await fs.cp(path.join(extractDir, 'shared'), sharedDest, { recursive: true });
-    await fs.copyFile(path.join(extractDir, 'package.json'), path.join(CONFIG_DIR, 'package.json'));
-    await fs.rm(extractDir, { recursive: true, force: true });
-    // Restore preserved config
-    for (const f of preserveFiles) {
-        if (preserved[f])
-            await fs.writeFile(path.join(CONFIG_DIR, f), preserved[f]);
-    }
-    console.log('✓ CLI updated');
-    const npmPaths = [path.join(os.homedir(), '.nvm/versions/node/v22/bin/npm'), path.join(os.homedir(), '.nvm/versions/node/v20/bin/npm')];
-    const npmBin = npmPaths.find(p => fsSync.existsSync(p)) || 'npm';
-    try {
-        execSync(`"${npmBin}" install --omit=dev`, { cwd: CONFIG_DIR, stdio: 'inherit' });
-        console.log('✓ Dependencies updated');
-    }
-    catch {
-        console.warn('⚠ npm install failed');
-    }
-}
-async function selfUpdate(force = false) {
-    const info = await checkForUpdate();
-    if (!info || !info.updateAvailable) {
-        console.log('✓ Already up to date');
-        return;
-    }
-    console.log('📦 Update available!');
-    if (!force && process.stdin.isTTY) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        const answer = await new Promise(r => rl.question('Update now? [Y/n] ', a => { rl.close(); r(a.trim()); }));
-        if (answer.toLowerCase().startsWith('n'))
-            return;
-    }
-    if (!info.downloadUrl || !info.hash)
-        return;
-    console.log('Downloading...');
-    const res = await fetch(info.downloadUrl);
-    if (!res.ok)
-        throw new Error('Download failed');
-    const bundle = Buffer.from(await res.arrayBuffer());
-    if (createHash('sha256').update(bundle).digest('hex') !== info.hash) {
-        throw new Error('Hash mismatch');
-    }
-    await replaceSelf(bundle);
-    process.exit(0);
-}
-// ============ Commands ============
-async function registerDevice(name, email) {
-    try {
-        const deviceId = await getDeviceId();
-        let deviceEmail = email;
-        // If we already have a valid token, skip approval email and just register
-        try {
-            const deviceConfig = await readDiskDeviceConfig();
-            const existingToken = deviceConfig.authToken;
-            if (existingToken && typeof existingToken === 'string') {
-                const config = await readConfig();
-                const meRes = await fetch(`${config.apiUrl}/auth/me`, {
-                    headers: { Authorization: `Bearer ${existingToken}` }
-                });
-                const meData = await meRes.json();
-                if (meRes.ok && meData.success && meData.user?.email) {
-                    console.log(`✓ Using existing auth token for ${meData.user.email}`);
-                    deviceEmail = deviceEmail || meData.user.email;
-                    const socket = await connect();
-                    await new Promise((resolve, reject) => {
-                        socket.emit('device:register', {
-                            deviceId,
-                            name: name || `CLI Device ${deviceId.slice(0, 8)}`,
-                            ipAddress: getLocalIpAddress(),
-                            hostname: getHostname(),
-                            email: deviceEmail
-                        }, ({ success, device, error }) => {
-                            socket.disconnect();
-                            if (success && device) {
-                                console.log(`✓ Device registered!`);
-                                console.log(`Device ID: ${device.deviceId}`);
-                                console.log(`Name: ${device.name}`);
-                                console.log(`Email: ${device.email}`);
-                                resolve();
-                            }
-                            else {
-                                reject(new Error(error || 'Registration failed'));
-                            }
-                        });
-                    });
-                    await fetchAiConfig(existingToken);
-                    return;
-                }
-            }
-        }
-        catch {
-            // No config or invalid token - continue with approval flow
-        }
-        // Prompt for email if not provided
-        if (!deviceEmail) {
-            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            deviceEmail = await new Promise((resolve) => {
-                rl.question('Enter your email address: ', (answer) => {
-                    rl.close();
-                    resolve(answer.trim());
-                });
-            });
-        }
-        if (!deviceEmail?.includes('@')) {
-            console.error('✗ Valid email address is required');
-            throw new Error('Valid email address is required');
-        }
-        // Generate 32-byte random token (base64url encoded)
-        const randomBytes = crypto.randomBytes(32);
-        const approvalToken = randomBytes.toString('base64url'); // base64url encoding (no padding, URL-safe)
-        console.log(`\n📧 Sending approval request to ${deviceEmail}...`);
-        // Send approval request
-        const config = await readConfig();
-        const response = await fetch(`${config.apiUrl}/auth/approval-request`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({
-                email: deviceEmail,
-                deviceId,
-                approvalToken
-            })
-        });
-        const result = await response.json();
-        if (!result.success) {
-            console.error(`✗ Failed to send approval request: ${result.error || 'Unknown error'}`);
-            throw new Error(result.error || 'Failed to send approval request');
-        }
-        console.log(`✓ Approval email sent! Check your inbox (${deviceEmail})`);
-        console.log(`⏳ Waiting for approval...`);
-        // Poll every 5 seconds for approval
-        const maxAttempts = 120; // 10 minutes max (120 * 5s)
-        let attempts = 0;
-        const checkApproval = async () => {
-            attempts++;
-            try {
-                const statusResponse = await fetch(`${config.apiUrl}/auth/approval-status?token=${approvalToken}`);
-                const statusResult = await statusResponse.json();
-                if (statusResult.success && statusResult.approved) {
-                    return statusResult.token || null; // Return permanent auth token
-                }
-                if (statusResult.error && !statusResult.pending) {
-                    console.error(`\n✗ ${statusResult.error}`);
-                    return null;
-                }
-                return null; // Still pending
-            }
-            catch (error) {
-                console.error(`\n✗ Error checking approval status: ${error.message}`);
-                return null;
-            }
-        };
-        // Poll until approved or timeout
-        while (attempts < maxAttempts) {
-            await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
-            const token = await checkApproval();
-            if (token) {
-                // Device approved! Store permanent token
-                await writeDeviceConfigMerged({ email: deviceEmail, authToken: token });
-                console.log(`\n✓ Device approved!`);
-                // Register device with backend and wait for completion
-                const socket = await connect();
-                await new Promise((resolve, reject) => {
-                    socket.emit('device:register', {
-                        deviceId,
-                        name: name || `CLI Device ${deviceId.slice(0, 8)}`,
-                        ipAddress: getLocalIpAddress(),
-                        hostname: getHostname(),
-                        email: deviceEmail
-                    }, ({ success, device, error }) => {
-                        socket.disconnect();
-                        if (success && device) {
-                            console.log(`✓ Device registered!`);
-                            console.log(`Device ID: ${device.deviceId}`);
-                            console.log(`Name: ${device.name}`);
-                            console.log(`Email: ${device.email}`);
-                            console.log(`IP Address: ${device.ipAddress || 'Unknown'}`);
-                            console.log(`Hostname: ${device.hostname || 'Unknown'}`);
-                            resolve();
-                        }
-                        else {
-                            reject(new Error(error || 'Registration failed'));
-                        }
-                    });
-                });
-                await fetchAiConfig(token);
-                return; // Successfully registered
-            }
-            // Show progress every 30 seconds
-            if (attempts % 6 === 0) {
-                process.stdout.write(`\r⏳ Still waiting... (${attempts * 5}s)`);
-            }
-        }
-        console.error(`\n✗ Approval timeout. Please check your email and try again.`);
-        throw new Error('Approval timeout');
-    }
-    catch (error) {
-        console.error('Failed to register device:', error.message);
-        throw error;
-    }
-}
-// Active sessions map - persists across reconnections
-const activeSessions = new Map();
-async function runDaemon(foreground = false, email) {
-    const config = await readConfig();
-    const deviceId = await getDeviceId();
-    const ipAddress = getLocalIpAddress();
-    const hostname = getHostname();
-    // Silent update check on startup
-    checkForUpdate().then(info => {
-        if (info?.updateAvailable)
-            console.log('📦 Update available: run "ttc update"');
-    }).catch(() => { });
-    if (foreground)
-        console.log('=== TalkToCode CLI (Foreground) ===');
-    else
-        console.log('Starting daemon...');
-    console.log(`API: ${config.apiUrl}`);
-    console.log(`Device: ${deviceId}`);
-    console.log(`Host: ${hostname}`);
-    // Test if server is reachable
-    if (foreground) {
-        try {
-            const url = new URL(config.apiUrl);
-            const testUrl = `${url.protocol}//${url.host}`;
-            console.log(`Testing connection to ${testUrl}...`);
-            const response = await fetch(testUrl, {
-                method: 'GET',
-                signal: AbortSignal.timeout(5000)
-            });
-            console.log(`✓ Server is reachable (HTTP ${response.status})`);
-        }
-        catch (error) {
-            console.error(`✗ Cannot reach server: ${error.message}`);
-            console.error(`  Make sure the backend server is running at ${config.apiUrl}`);
-        }
-    }
-    console.log('');
-    await maybeFetchAiConfigIfMissing();
-    let socket = null;
-    let reconnectTimeout = null;
-    let reconnectAttempts = 0;
-    const MAX_RECONNECT_ATTEMPTS = Infinity; // Keep trying forever
-    const connectAndRegister = async () => {
-        try {
-            socket = io(config.apiUrl, {
-                transports: ['websocket', 'polling'],
-                reconnection: true,
-                reconnectionDelay: 1000,
-                reconnectionDelayMax: 10000,
-                reconnectionAttempts: MAX_RECONNECT_ATTEMPTS,
-                timeout: 20000,
-                forceNew: true,
-                upgrade: true,
-            });
-            // Wire socket reference for agentSession to fetch history from backend
-            agentSessionManager.setSocketRef(socket);
-            if (foreground) {
-                console.log(`Attempting to connect to: ${config.apiUrl}`);
-            }
-            // Register event handlers once (outside registered callback to prevent duplicates)
-            // Project handlers
-            socket.on('project:create', async (data, callback) => {
-                try {
-                    if (foreground) {
-                        console.log(`📁 Creating project: ${data.name} at ${data.path}`);
-                    }
-                    const result = await createProject({
-                        projectId: data.projectId || uuidv4(),
-                        name: data.name,
-                        path: data.path,
-                        sourcePath: data.sourcePath
-                    });
-                    if (result.success) {
-                        if (foreground) {
-                            console.log(`✓ Project created: ${data.name} at ${result.actualPath || data.path}`);
-                        }
-                        else {
-                            console.log(`Project created: ${data.name} at ${result.actualPath || data.path}`);
-                        }
-                    }
-                    else {
-                        if (foreground) {
-                            console.error(`✗ Failed to create project: ${result.error || 'Unknown error'}`);
-                        }
-                    }
-                    callback?.({
-                        success: result.success,
-                        error: result.error,
-                        actualPath: result.actualPath
-                    });
-                }
-                catch (error) {
-                    if (foreground) {
-                        console.error(`✗ Error creating project: ${error.message}`);
-                    }
-                    callback?.({ success: false, error: error.message });
-                }
-            });
-            socket.on('project:delete', async (data, callback) => {
-                try {
-                    const { projectId, path } = data;
-                    if (!path) {
-                        callback?.({ success: false, error: 'Project path required for deletion' });
-                        return;
-                    }
-                    if (foreground) {
-                        console.log(`🗑️  Deleting project: ${projectId} at ${path}`);
-                    }
-                    const result = await deleteProject(path);
-                    if (result.success) {
-                        if (foreground) {
-                            console.log(`✓ Project deleted: ${projectId} at ${path}`);
-                        }
-                        else {
-                            console.log(`Project deleted: ${projectId} at ${path}`);
-                        }
-                    }
-                    else {
-                        if (foreground) {
-                            console.error(`✗ Failed to delete project: ${result.error || 'Unknown error'}`);
-                        }
-                    }
-                    callback?.(result);
-                }
-                catch (error) {
-                    if (foreground) {
-                        console.error(`✗ Error deleting project: ${error.message}`);
-                    }
-                    callback?.({ success: false, error: error.message });
-                }
-            });
-            // GitHub handlers (extracted to cli/githubHandlers.ts)
-            registerGitHubHandlers(socket, foreground);
-            // FS handlers (extracted to cli/fsHandlers.ts)
-            registerFsHandlers(socket);
-            // Update handlers (extracted to cli/updateHandlers.ts)
-            registerUpdateHandlers(socket, foreground, readConfig, requestUpdateFromParent);
-            // Session handlers (extracted to cli/sessionHandlers.ts)
-            registerSessionHandlers(socket, foreground, activeSessions, () => socket);
-            // App control handlers (extracted to cli/appHandlers.ts)
-            registerAppHandlers(socket, foreground);
-            socket.on('connect', () => {
-                if (foreground) {
-                    console.log(`✓ Connected to backend at ${config.apiUrl}`);
-                    if (socket) {
-                        console.log(`   Socket ID: ${socket.id}`);
-                    }
-                }
-                else {
-                    console.log('Connected to backend');
-                }
-                reconnectAttempts = 0;
-                // Register as CLI device
-                if (socket) {
-                    socket.emit('register', { type: 'cli', deviceId });
-                }
-            });
-            socket.on('registered', async ({ type }) => {
-                if (foreground) {
-                    console.log(`✓ Registered as ${type}`);
-                }
-                else {
-                    console.log(`Registered as ${type}`);
-                }
-                // Check for auth token: env TTC_AUTH_TOKEN or device-config.json (from previous approval)
-                let authToken = process.env.TTC_AUTH_TOKEN;
-                let deviceEmail = email;
-                let skipEmailFlow = false;
-                // Load from device-config if no env token (reuse state from previous approval)
-                if (!authToken) {
-                    try {
-                        const deviceConfig = await readDiskDeviceConfig();
-                        authToken = deviceConfig.authToken;
-                        if (!deviceEmail && deviceConfig.email)
-                            deviceEmail = deviceConfig.email;
-                    }
-                    catch {
-                        // No device config yet
-                    }
-                }
-                if (authToken) {
-                    try {
-                        const parts = authToken.split('.');
-                        if (parts.length === 3) {
-                            const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
-                            if (payload.type === 'device_auth' && payload.email) {
-                                deviceEmail = payload.email;
-                                skipEmailFlow = true;
-                                if (foreground) {
-                                    console.log(`✓ Using stored auth token for ${deviceEmail}`);
-                                }
-                            }
-                        }
-                    }
-                    catch (err) {
-                        if (foreground) {
-                            console.warn(`⚠️  Invalid auth token in config, falling back to normal auth`);
-                        }
-                        authToken = undefined;
-                    }
-                }
-                // Load device email from config if not using token and not provided
-                if (!deviceEmail && !skipEmailFlow) {
-                    try {
-                        const deviceConfig = await readDiskDeviceConfig();
-                        deviceEmail = deviceConfig.email;
-                    }
-                    catch {
-                        // No device config yet
-                    }
-                }
-                // Register device with backend
-                let needsApprovalLoggedOnce = false;
-                const registerDevice = () => {
-                    // Determine device name
-                    const containerName = process.env.CONTAINER_NAME;
-                    const deviceName = containerName ? `Container: ${containerName}` : `CLI Device ${hostname}`;
-                    socket.emit('device:register', {
-                        deviceId,
-                        name: deviceName,
-                        ipAddress,
-                        hostname,
-                        email: deviceEmail,
-                        // When using auth token, include the token for verification
-                        authToken: skipEmailFlow ? authToken : undefined
-                    }, ({ success, needsApproval, message, device, error }) => {
-                        if (success && device) {
-                            needsApprovalLoggedOnce = false;
-                            if (foreground) {
-                                console.log(`✓ Device registered: ${device.name}`);
-                                if (device.approved) {
-                                    console.log(`✓ Device approved and ready`);
-                                }
-                            }
-                            else {
-                                console.log(`Device registered: ${device.name}${device.approved ? ' (approved)' : ' (pending approval)'}`);
-                            }
-                            // Save config: email + authToken (preserve token so next run can reuse)
-                            if (device.email) {
-                                void writeDeviceConfigMerged({
-                                    email: device.email,
-                                    ...(authToken ? { authToken } : {}),
-                                }).catch(() => { });
-                            }
-                            if (authToken) {
-                                scheduleAiConfigSync(authToken);
-                            }
-                        }
-                        else if (needsApproval) {
-                            // Persist email when approval was requested so restarts don't prompt again
-                            if (deviceEmail) {
-                                void writeDeviceConfigMerged({ email: deviceEmail }).catch(() => { });
-                            }
-                            // Only log once to avoid flooding logs every 30s on heartbeat
-                            if (!needsApprovalLoggedOnce) {
-                                needsApprovalLoggedOnce = true;
-                                if (foreground) {
-                                    console.log(`\n⚠️  ${message || 'Device approval required'}`);
-                                    if (!deviceEmail) {
-                                        console.log(`   Please run: npx tsx index.ts register --email your@email.com`);
-                                    }
-                                    else {
-                                        console.log(`   Check your email (${deviceEmail}) and click the approval link.`);
-                                    }
-                                }
-                                else {
-                                    console.log(`⚠️  Device approval required: ${message || 'Please approve device'}`);
-                                }
-                            }
-                        }
-                        else if (error) {
-                            console.error(`✗ Registration error: ${error}`);
-                        }
-                    });
-                };
-                registerDevice();
-                // Update lastSeen every 30 seconds while connected
-                const heartbeatInterval = setInterval(() => {
-                    if (socket?.connected) {
-                        registerDevice();
-                    }
-                    else {
-                        clearInterval(heartbeatInterval);
-                    }
-                }, 30000);
-                socket.heartbeatInterval = heartbeatInterval;
-            });
-            // Cloudflared handlers (extracted to cli/cloudflaredHandlers.ts)
-            registerCloudflaredHandlers(socket, foreground);
-            // Container handlers (extracted to cli/containerHandlers.ts)
-            registerContainerHandlers(socket, foreground, path.dirname(CURRENT_FILE));
-            socket.on('disconnect', (reason) => {
-                if (foreground) {
-                    console.log(`\n⚠️  Disconnected: ${reason}`);
-                    console.log('   Attempting to reconnect...');
-                }
-                else {
-                    console.log(`Disconnected: ${reason}`);
-                }
-                // Clear heartbeat interval
-                if (socket.heartbeatInterval) {
-                    clearInterval(socket.heartbeatInterval);
-                }
-                if (reason === 'io server disconnect') {
-                    // Server disconnected, reconnect manually
-                    socket.connect();
-                }
-                else {
-                    // Client disconnect or transport close: schedule full reconnect so process stays alive
-                    if (reconnectTimeout)
-                        clearTimeout(reconnectTimeout);
-                    const delay = 2000;
-                    if (!foreground)
-                        console.log(`Reconnecting in ${delay}ms...`);
-                    reconnectTimeout = setTimeout(connectAndRegister, delay);
-                }
-            });
-            socket.on('connect_error', (err) => {
-                reconnectAttempts++;
-                if (foreground) {
-                    console.error(`✗ Connection error (attempt ${reconnectAttempts}): ${err.message}`);
-                    if (err.type) {
-                        console.error(`   Error type: ${err.type}`);
-                    }
-                    if (err.description) {
-                        console.error(`   Error description: ${err.description}`);
-                    }
-                    console.error(`   Connecting to: ${config.apiUrl}`);
-                    if (err.cause) {
-                        console.error(`   Cause:`, err.cause);
-                    }
-                }
-                else {
-                    console.error(`Connection error (attempt ${reconnectAttempts}):`, err.message);
-                }
-            });
-            // Keep process alive
-            socket.on('error', (err) => {
-                if (foreground) {
-                    console.error(`✗ Socket error: ${err}`);
-                }
-                else {
-                    console.error('Socket error:', err);
-                }
-            });
-        }
-        catch (error) {
-            if (foreground) {
-                console.error(`✗ Failed to connect: ${error.message}`);
-            }
-            else {
-                console.error('Failed to connect:', error.message);
-            }
-            reconnectAttempts++;
-            if (reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
-                const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
-                if (foreground) {
-                    console.log(`⏳ Reconnecting in ${delay}ms...`);
-                }
-                else {
-                    console.log(`Reconnecting in ${delay}ms...`);
-                }
-                reconnectTimeout = setTimeout(connectAndRegister, delay);
-            }
-        }
-    };
-    // Handle graceful shutdown
-    const shutdown = () => {
-        if (foreground) {
-            console.log('\n\n🛑 Shutting down gracefully...');
-        }
-        else {
-            console.log('\nShutting down...');
-        }
-        if (reconnectTimeout) {
-            clearTimeout(reconnectTimeout);
-        }
-        if (socket) {
-            // Clear heartbeat interval
-            if (socket.heartbeatInterval) {
-                clearInterval(socket.heartbeatInterval);
-            }
-            socket.disconnect();
-        }
-        process.exit(0);
-    };
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
-    process.on('SIGHUP', shutdown);
-    // Start connection
-    await connectAndRegister();
-    // Keep process alive
-    process.stdin.resume();
-}
-// ============ CLI Program ============
-const program = new Command();
-program
-    .name('ttc')
-    .description('TalkToCode CLI - Simple install and manage')
-    .version('1.0.0');
-// Config command
-program
-    .command('config')
-    .description('Get or set config (api-url)')
-    .option('--api-url <url>', 'API base URL')
-    .action(async (opts) => {
-    const config = await readConfig();
-    if (opts.apiUrl !== undefined) {
-        config.apiUrl = opts.apiUrl;
-        await writeConfig(config);
-        console.log('Set api-url:', config.apiUrl);
-    }
-    else {
-        console.log('Config:', JSON.stringify(config, null, 2));
-    }
-    process.exit(0);
-});
-// Install command
-program
-    .command('install')
-    .description('Install and register TTC CLI (installs as pm2 daemon)')
-    .argument('[email]', 'Email address for device approval')
-    .action(async (email) => {
-    try {
-        // First register the device
-        await registerDevice(undefined, email);
-        // After successful registration, install as service (Linux only)
-        if (process.platform === 'win32') {
-            console.log('\n✓ Device registered.');
-            console.log('On Windows, run the daemon manually: ttc daemon');
-            console.log('To run in background: start /B node path\\to\\ttc daemon');
-        }
-        else {
-            console.log('\n📦 Installing TTC with pm2...');
-            // install-service.sh: bundled at __dirname, or in ~/.talk-to-code for curl install
-            let installScript = path.join(__dirname, 'install-service.sh');
-            if (!fsSync.existsSync(installScript)) {
-                installScript = path.join(CONFIG_DIR, 'install-service.sh');
-            }
-            if (!fsSync.existsSync(installScript)) {
-                installScript = path.join(__dirname, '..', 'install-service.sh');
-            }
-            const scriptDir = path.dirname(installScript);
-            try {
-                await fs.access(installScript);
-                const { execSync } = await import('child_process');
-                execSync(`bash "${installScript}"`, {
-                    stdio: 'inherit',
-                    cwd: scriptDir,
-                    env: { ...process.env, PATH: process.env.PATH }
-                });
-                console.log('\n✓ TTC installation complete!');
-                console.log('The service is now running in the background.');
-            }
-            catch (scriptErr) {
-                const err = scriptErr;
-                console.log('\n⚠ Service installation had issues, but device is registered.');
-                if (err.message)
-                    console.error('Error:', err.message);
-                console.log('You can start the daemon manually with: ttc daemon');
-            }
-        }
-    }
-    catch (error) {
-        const errorMsg = error.message;
-        if (errorMsg.includes('approval') || errorMsg.includes('email')) {
-            // Registration failed - exit with error
-            process.exit(1);
-        }
-        // Service installation failed, but device is registered
-        console.log('\n⚠ Service installation had issues, but device is registered.');
-        console.log('You can start the daemon manually with: ttc daemon');
-    }
-    // Exit after install is complete
-    process.exit(0);
-});
-// Uninstall command
-program
-    .command('uninstall')
-    .description('Uninstall TTC CLI (removes service and config)')
-    .action(async () => {
-    console.log('🗑️  Uninstalling TTC CLI...');
-    if (process.platform === 'win32') {
-        console.log('On Windows there is no service to remove.');
-        console.log('To remove TTC completely:');
-        console.log('  1. Delete the ttc executable or folder');
-        console.log('  2. Remove config: rmdir /s /q "%USERPROFILE%\\.talk-to-code"');
-    }
-    else {
-        let installScript = path.join(__dirname, 'install-service.sh');
-        if (!fsSync.existsSync(installScript))
-            installScript = path.join(CONFIG_DIR, 'install-service.sh');
-        if (!fsSync.existsSync(installScript))
-            installScript = path.join(__dirname, '..', 'install-service.sh');
-        const scriptDir = path.dirname(installScript);
-        try {
-            await fs.access(installScript);
-            const { execSync } = await import('child_process');
-            execSync(`bash "${installScript}" --uninstall`, {
-                stdio: 'inherit',
-                cwd: scriptDir,
-                env: { ...process.env, PATH: process.env.PATH }
-            });
-            console.log('\n✓ Service uninstalled!');
-            console.log('To remove TTC completely, delete the binary:');
-            console.log('  rm ~/.local/bin/ttc');
-        }
-        catch (error) {
-            console.log('\n⚠ Service uninstall script not found or failed.');
-            console.log('To remove TTC completely, delete:');
-            console.log('  rm ~/.local/bin/ttc');
-            console.log('  rm -rf ~/.talk-to-code');
-        }
-    }
-    // Exit after uninstall is complete
-    process.exit(0);
-});
-// Update command
-program
-    .command('update')
-    .description('Check for and apply CLI updates')
-    .option('-f, --force', 'Update without confirmation')
-    .action(async (options) => {
-    await selfUpdate(options.force);
-    process.exit(0);
-});
-program
-    .command('check-update')
-    .description('Check for updates')
-    .action(async () => {
-    const info = await checkForUpdate();
-    if (!info)
-        process.exit(1);
-    if (!info.updateAvailable) {
-        console.log('✓ Up to date');
-        process.exit(0);
-    }
-    console.log('📦 Update available');
-    console.log('Run "ttc update" to install');
-    process.exit(0);
-});
-// Run (connect to backend and process prompts)
-program
-    .command('run')
-    .description('Run CLI and connect to backend')
-    .option('--email <email>', 'Email for device approval')
-    .action((options) => {
-    runDaemon(false, options.email).catch((error) => {
-        console.error('Run error:', error.message);
-        process.exit(1);
-    });
-});
-// Hidden daemon command (internal alias)
-program
-    .command('daemon', { hidden: true })
-    .description('Run daemon (internal)')
-    .option('--foreground', 'Run in foreground', false)
-    .option('--email <email>', 'Email address')
-    .action((options) => {
-    runDaemon(options.foreground, options.email).catch((error) => {
-        console.error('Daemon error:', error.message);
-        process.exit(1);
-    });
-});
-program.parse();