@exreve/exk 1.0.51 → 1.0.52

package/dist/cli/appRunner.js

@@ -0,0 +1,383 @@
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+/** Cross-platform: run a shell command (sh -c on Unix, cmd /c on Windows) */
+function shellSpawnOpts(command) {
+    if (process.platform === 'win32') {
+        return { shell: process.env.COMSPEC || 'cmd.exe', args: ['/c', command] };
+    }
+    return { shell: 'sh', args: ['-c', command] };
+}
+import Fastify from 'fastify';
+import fastifyStatic from '@fastify/static';
+// ============ Base Runner ============
+export class BaseRunner {
+    app;
+    projectPath;
+    projectId;
+    callbacks;
+    stats;
+    process = null;
+    logFile;
+    constructor(app, projectPath, projectId, callbacks) {
+        this.app = app;
+        this.projectPath = projectPath;
+        this.projectId = projectId;
+        this.callbacks = callbacks;
+        this.stats = {
+            startTime: Date.now(),
+            requests: 0,
+            errors: 0,
+        };
+        this.logFile = path.join(os.homedir(), '.talk-to-code', 'app-logs', `${projectId}-${app.name}.log`);
+    }
+    async writeLog(type, data) {
+        const timestamp = new Date().toISOString();
+        const logLine = `[${timestamp}] [${type.toUpperCase()}] ${data}\n`;
+        try {
+            await fs.appendFile(this.logFile, logLine, 'utf-8');
+        }
+        catch (error) {
+            // Ignore log write errors
+        }
+        this.callbacks.onOutput?.({
+            type,
+            data,
+            timestamp: Date.now(),
+        });
+    }
+    updateStats() {
+        if (this.process) {
+            try {
+                const memUsage = process.memoryUsage();
+                this.stats.memoryUsage = memUsage;
+            }
+            catch {
+                // Ignore
+            }
+        }
+        this.callbacks.onStats?.(this.stats);
+    }
+}
+// ============ Static Frontend Runner ============
+export class StaticFrontendRunner extends BaseRunner {
+    fastify = null;
+    port;
+    constructor(app, projectPath, projectId, callbacks) {
+        super(app, projectPath, projectId, callbacks);
+        this.port = app.port || 3000;
+    }
+    async start() {
+        try {
+            await this.writeLog('system', `Starting static frontend server for ${this.app.name} on port ${this.port}`);
+            // Determine build directory (use buildDir from config if provided)
+            const buildDirName = this.app.buildDir || 'dist';
+            const buildDir = this.app.directory
+                ? path.join(this.projectPath, this.app.directory, buildDirName)
+                : path.join(this.projectPath, buildDirName);
+            // Check if specified build dir exists, fallback to dist, build, or public
+            let staticDir = buildDir;
+            const dirsToTry = buildDirName !== 'dist' ? [buildDirName, 'dist', 'build', 'public'] : ['dist', 'build', 'public'];
+            let found = false;
+            for (const dirName of dirsToTry) {
+                const testDir = this.app.directory
+                    ? path.join(this.projectPath, this.app.directory, dirName)
+                    : path.join(this.projectPath, dirName);
+                try {
+                    await fs.access(testDir);
+                    staticDir = testDir;
+                    found = true;
+                    break;
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!found) {
+                return {
+                    success: false,
+                    error: `No build directory found. Tried: ${dirsToTry.join(', ')}`
+                };
+            }
+            await this.writeLog('system', `Serving static files from: ${staticDir}`);
+            // Create Fastify instance
+            this.fastify = Fastify({
+                logger: {
+                    level: 'info',
+                    transport: {
+                        target: 'pino-pretty',
+                        options: {
+                            translateTime: 'HH:MM:ss Z',
+                            ignore: 'pid,hostname',
+                        },
+                    },
+                },
+            });
+            // Register static file serving
+            await this.fastify.register(fastifyStatic, {
+                root: staticDir,
+                prefix: '/',
+            });
+            // Add request logging middleware
+            this.fastify.addHook('onRequest', async (request, reply) => {
+                this.stats.requests++;
+                this.stats.lastRequestTime = Date.now();
+                this.updateStats();
+                await this.writeLog('stdout', `${request.method} ${request.url} - ${reply.statusCode}`);
+            });
+            // Add error handling
+            this.fastify.setErrorHandler(async (error, request, reply) => {
+                this.stats.errors++;
+                this.updateStats();
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                await this.writeLog('stderr', `Error: ${errorMessage} - ${request.method} ${request.url}`);
+                reply.status(500).send({ error: 'Internal Server Error' });
+            });
+            // Start server
+            await this.fastify.listen({ port: this.port, host: '0.0.0.0' });
+            await this.writeLog('system', `Static server started successfully on port ${this.port}`);
+            // Create a mock process for compatibility
+            this.process = {
+                pid: process.pid,
+                kill: (_signal) => {
+                    this.stop();
+                },
+            };
+            return {
+                success: true,
+                pid: process.pid,
+            };
+        }
+        catch (error) {
+            await this.writeLog('stderr', `Failed to start static server: ${error.message}`);
+            this.callbacks.onError?.(error.message);
+            return {
+                success: false,
+                error: error.message || 'Failed to start static server'
+            };
+        }
+    }
+    async stop() {
+        try {
+            if (this.fastify) {
+                await this.writeLog('system', `Stopping static server for ${this.app.name}`);
+                await this.fastify.close();
+                this.fastify = null;
+                await this.writeLog('system', `Static server stopped`);
+                this.callbacks.onExit?.(0);
+                return { success: true };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            await this.writeLog('stderr', `Error stopping static server: ${error.message}`);
+            return {
+                success: false,
+                error: error.message || 'Failed to stop static server'
+            };
+        }
+    }
+    getStats() {
+        return {
+            ...this.stats,
+            memoryUsage: process.memoryUsage(),
+        };
+    }
+}
+// ============ Backend Runner (Express/Fastify wrapper) ============
+export class BackendRunner extends BaseRunner {
+    // process is inherited from BaseRunner as protected
+    async start() {
+        try {
+            await this.writeLog('system', `Starting backend app: ${this.app.name}`);
+            // Determine working directory
+            const workingDir = this.app.directory
+                ? path.join(this.projectPath, this.app.directory)
+                : this.projectPath;
+            // Check if directory exists
+            try {
+                await fs.access(workingDir);
+            }
+            catch {
+                return {
+                    success: false,
+                    error: `App directory does not exist: ${this.app.directory || 'root'}`
+                };
+            }
+            // Prepare environment variables
+            const env = {
+                ...process.env,
+                ...this.app.env,
+                NODE_ENV: this.app.env?.NODE_ENV || process.env.NODE_ENV || 'development',
+                PORT: this.app.port?.toString() || process.env.PORT || '3000',
+            };
+            // Ensure log directory exists
+            const logDir = path.dirname(this.logFile);
+            await fs.mkdir(logDir, { recursive: true });
+            // Spawn the backend process (cross-platform shell)
+            const { shell, args } = shellSpawnOpts(this.app.startCommand);
+            this.process = spawn(shell, args, {
+                cwd: workingDir,
+                env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                detached: false,
+            });
+            if (!this.process.pid) {
+                return {
+                    success: false,
+                    error: 'Failed to spawn process'
+                };
+            }
+            await this.writeLog('system', `Backend process started with PID: ${this.process.pid}`);
+            // Capture stdout
+            this.process.stdout?.on('data', async (data) => {
+                const output = data.toString();
+                await this.writeLog('stdout', output);
+            });
+            // Capture stderr
+            this.process.stderr?.on('data', async (data) => {
+                const output = data.toString();
+                this.stats.errors++;
+                this.updateStats();
+                await this.writeLog('stderr', output);
+            });
+            // Handle process exit
+            this.process.on('exit', async (code) => {
+                await this.writeLog('system', `Process exited with code ${code}`);
+                this.process = null;
+                this.callbacks.onExit?.(code);
+            });
+            // Handle process errors
+            this.process.on('error', async (error) => {
+                this.stats.errors++;
+                this.updateStats();
+                await this.writeLog('stderr', `Process error: ${error.message}`);
+                this.callbacks.onError?.(error.message);
+            });
+            // Start stats collection interval
+            const statsInterval = setInterval(() => {
+                if (this.process) {
+                    this.updateStats();
+                }
+                else {
+                    clearInterval(statsInterval);
+                }
+            }, 5000);
+            return {
+                success: true,
+                pid: this.process.pid,
+            };
+        }
+        catch (error) {
+            await this.writeLog('stderr', `Failed to start backend: ${error.message}`);
+            this.callbacks.onError?.(error.message);
+            return {
+                success: false,
+                error: error.message || 'Failed to start backend'
+            };
+        }
+    }
+    async stop() {
+        try {
+            if (!this.process) {
+                return { success: true };
+            }
+            await this.writeLog('system', `Stopping backend app: ${this.app.name}`);
+            // Try custom stop command first
+            if (this.app.stopCommand) {
+                try {
+                    const workingDir = this.app.directory
+                        ? path.join(this.projectPath, this.app.directory)
+                        : this.projectPath;
+                    const { shell: stopShell, args: stopArgs } = shellSpawnOpts(this.app.stopCommand);
+                    spawn(stopShell, stopArgs, {
+                        cwd: workingDir,
+                        stdio: 'ignore',
+                    });
+                    // Wait for graceful shutdown
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    // If still running, kill it
+                    if (this.process && this.process.pid) {
+                        try {
+                            process.kill(this.process.pid, 0); // Check if still alive
+                            this.process.kill('SIGTERM');
+                            await new Promise(resolve => setTimeout(resolve, 2000));
+                            if (this.process && this.process.pid) {
+                                try {
+                                    process.kill(this.process.pid, 0);
+                                    this.process.kill('SIGKILL');
+                                }
+                                catch {
+                                    // Process already dead
+                                }
+                            }
+                        }
+                        catch {
+                            // Process already dead
+                        }
+                    }
+                }
+                catch (error) {
+                    // Fall back to killing process
+                    if (this.process) {
+                        this.process.kill('SIGTERM');
+                        await new Promise(resolve => setTimeout(resolve, 2000));
+                        if (this.process) {
+                            this.process.kill('SIGKILL');
+                        }
+                    }
+                }
+            }
+            else {
+                // Default: kill the process
+                this.process.kill('SIGTERM');
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                if (this.process) {
+                    this.process.kill('SIGKILL');
+                }
+            }
+            this.process = null;
+            await this.writeLog('system', `Backend app stopped`);
+            return { success: true };
+        }
+        catch (error) {
+            await this.writeLog('stderr', `Error stopping backend: ${error.message}`);
+            return {
+                success: false,
+                error: error.message || 'Failed to stop backend'
+            };
+        }
+    }
+    getStats() {
+        return {
+            ...this.stats,
+            memoryUsage: this.process ? process.memoryUsage() : undefined,
+        };
+    }
+}
+// ============ Runner Factory ============
+export function createRunner(app, projectPath, projectId, callbacks) {
+    // Use explicit appType if provided, otherwise detect
+    if (app.appType === 'static-frontend') {
+        return new StaticFrontendRunner(app, projectPath, projectId, callbacks);
+    }
+    if (app.appType === 'backend') {
+        return new BackendRunner(app, projectPath, projectId, callbacks);
+    }
+    // Auto-detect based on framework and other indicators
+    const framework = app.framework?.toLowerCase() || '';
+    const type = app.type?.toLowerCase() || '';
+    // Static frontend apps
+    if (framework.includes('react') ||
+        framework.includes('vue') ||
+        framework.includes('angular') ||
+        framework.includes('svelte') ||
+        (framework.includes('next') && type === 'http') ||
+        app.name.toLowerCase().includes('frontend') ||
+        app.name.toLowerCase().includes('client')) {
+        return new StaticFrontendRunner(app, projectPath, projectId, callbacks);
+    }
+    // Backend apps (Express, Fastify, etc.)
+    return new BackendRunner(app, projectPath, projectId, callbacks);
+}

package/dist/cli/cloudflaredHandlers.js

@@ -0,0 +1,279 @@
+/**
+ * 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 });
+        }
+    });
+}