@exreve/exk 1.0.55 → 1.0.57

package/dist/appRunner.js

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