@exreve/exk 1.0.7 → 1.0.8

package/dist/appManager.js

@@ -0,0 +1,222 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { createRunner } from './appRunner.js';
+// Store running app runners: projectId -> appName -> runner
+const runningApps = new Map();
+const LOGS_DIR = path.join(os.homedir(), '.talk-to-code', 'app-logs');
+/**
+ * Ensure logs directory exists
+ */
+const ensureLogsDir = () => fs.mkdir(LOGS_DIR, { recursive: true });
+/**
+ * Helper to remove app from running apps and clean up empty project maps
+ */
+const removeAppFromRunning = (projectId, appName) => {
+    const projectApps = runningApps.get(projectId);
+    if (projectApps) {
+        projectApps.delete(appName);
+        if (projectApps.size === 0) {
+            runningApps.delete(projectId);
+        }
+    }
+};
+/**
+ * Get log file path for an app
+ */
+function getLogFilePath(projectId, appName) {
+    return path.join(LOGS_DIR, `${projectId}-${appName}.log`);
+}
+/**
+ * Start an app using wrapper runner
+ */
+export async function startApp(projectPath, projectId, app) {
+    try {
+        // Check if already running
+        if (isAppRunning(projectId, app.name)) {
+            const running = getRunningApp(projectId, app.name);
+            return {
+                success: true,
+                processId: `${projectId}-${app.name}`,
+                pid: running?.pid
+            };
+        }
+        // Ensure logs directory exists
+        await ensureLogsDir();
+        const logFile = getLogFilePath(projectId, app.name);
+        // Create runner based on app type
+        const runner = createRunner(app, projectPath, projectId, {
+            onOutput: async (output) => {
+                // Logs are handled by the runner itself
+            },
+            onError: (error) => {
+                // Errors are logged by runner
+            },
+            onExit: (code) => {
+                removeAppFromRunning(projectId, app.name);
+            },
+            onStats: (stats) => {
+                // Stats updates can be used for monitoring
+            },
+        });
+        // Start the runner
+        const result = await runner.start();
+        if (!result.success) {
+            return result;
+        }
+        // Store runner info
+        if (!runningApps.has(projectId)) {
+            runningApps.set(projectId, new Map());
+        }
+        runningApps.get(projectId).set(app.name, {
+            runner,
+            pid: result.pid,
+            startTime: Date.now(),
+            logFile,
+        });
+        return {
+            success: true,
+            processId: `${projectId}-${app.name}`,
+            pid: result.pid,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to start app'
+        };
+    }
+}
+/**
+ * Stop an app using wrapper runner
+ */
+export async function stopApp(projectId, appName, app) {
+    try {
+        const running = getRunningApp(projectId, appName);
+        if (!running) {
+            return {
+                success: false,
+                error: 'App is not running'
+            };
+        }
+        // Stop using runner
+        const result = await running.runner.stop();
+        if (result.success) {
+            removeAppFromRunning(projectId, appName);
+        }
+        return result;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to stop app'
+        };
+    }
+}
+/**
+ * Restart an app
+ */
+export async function restartApp(projectPath, projectId, app) {
+    // Stop first if running
+    if (isAppRunning(projectId, app.name)) {
+        const stopResult = await stopApp(projectId, app.name, app);
+        if (!stopResult.success) {
+            return stopResult;
+        }
+        // Wait a bit before restarting
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    // Start
+    return startApp(projectPath, projectId, app);
+}
+/**
+ * Check if an app is running
+ */
+export function isAppRunning(projectId, appName) {
+    const projectApps = runningApps.get(projectId);
+    if (!projectApps)
+        return false;
+    const app = projectApps.get(appName);
+    if (!app)
+        return false;
+    // Check if process is still alive
+    try {
+        process.kill(app.pid, 0); // Signal 0 just checks if process exists
+        return true;
+    }
+    catch {
+        // Process doesn't exist, clean up
+        removeAppFromRunning(projectId, appName);
+        return false;
+    }
+}
+/**
+ * Get running app info
+ */
+export function getRunningApp(projectId, appName) {
+    const projectApps = runningApps.get(projectId);
+    if (!projectApps)
+        return null;
+    const app = projectApps.get(appName);
+    if (!app)
+        return null;
+    // Verify process is still alive
+    if (!isAppRunning(projectId, appName)) {
+        return null;
+    }
+    return app;
+}
+/**
+ * Get status of all apps for a project
+ */
+export function getAppStatuses(projectId, apps) {
+    return apps.map(app => {
+        const running = getRunningApp(projectId, app.name);
+        return {
+            name: app.name,
+            running: !!running,
+            processId: running ? `${projectId}-${app.name}` : undefined,
+            pid: running?.pid,
+        };
+    });
+}
+/**
+ * Get logs for an app
+ */
+export async function getAppLogs(projectId, appName, lines = 100) {
+    try {
+        const logFile = getLogFilePath(projectId, appName);
+        try {
+            await fs.access(logFile);
+        }
+        catch {
+            return {
+                success: true,
+                logs: 'No logs available yet'
+            };
+        }
+        const content = await fs.readFile(logFile, 'utf-8');
+        const logLines = content.split('\n');
+        const recentLogs = logLines.slice(-lines).join('\n');
+        return {
+            success: true,
+            logs: recentLogs || 'No logs available'
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to read logs'
+        };
+    }
+}
+/**
+ * Get stats for a running app
+ */
+export function getAppStats(projectId, appName) {
+    const running = getRunningApp(projectId, appName);
+    if (!running) {
+        return null;
+    }
+    return running.runner.getStats();
+}

package/dist/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);
+                    const stopProcess = 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);
+}