@exreve/exk 1.0.7 → 1.0.8

package/appRunner.ts

@@ -1,475 +0,0 @@
-import { spawn, ChildProcess } from 'child_process'
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-import type { ProjectApp } from './shared/types.js'
-
-/** Cross-platform: run a shell command (sh -c on Unix, cmd /c on Windows) */
-function shellSpawnOpts(command: string): { shell: string; args: string[] } {
-  if (process.platform === 'win32') {
-    return { shell: process.env.COMSPEC || 'cmd.exe', args: ['/c', command] }
-  }
-  return { shell: 'sh', args: ['-c', command] }
-}
-import Fastify, { FastifyInstance } from 'fastify'
-import fastifyStatic from '@fastify/static'
-
-// ============ Types ============
-
-export interface RunnerStats {
-  startTime: number
-  requests: number
-  errors: number
-  lastRequestTime?: number
-  memoryUsage?: NodeJS.MemoryUsage
-}
-
-export interface RunnerOutput {
-  type: 'stdout' | 'stderr' | 'system'
-  data: string
-  timestamp: number
-}
-
-export interface RunnerCallbacks {
-  onOutput?: (output: RunnerOutput) => void
-  onError?: (error: string) => void
-  onExit?: (code: number | null) => void
-  onStats?: (stats: RunnerStats) => void
-}
-
-// ============ Base Runner ============
-
-export abstract class BaseRunner {
-  protected app: ProjectApp
-  protected projectPath: string
-  protected projectId: string
-  protected callbacks: RunnerCallbacks
-  protected stats: RunnerStats
-  protected process: ChildProcess | null = null
-  protected logFile: string
-
-  constructor(
-    app: ProjectApp,
-    projectPath: string,
-    projectId: string,
-    callbacks: RunnerCallbacks
-  ) {
-    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`)
-  }
-
-  abstract start(): Promise<{ success: boolean; pid?: number; error?: string }>
-  abstract stop(): Promise<{ success: boolean; error?: string }>
-  abstract getStats(): RunnerStats
-
-  protected async writeLog(type: 'stdout' | 'stderr' | 'system', data: string): Promise<void> {
-    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(),
-    })
-  }
-
-  protected updateStats(): void {
-    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 {
-  private fastify: FastifyInstance | null = null
-  private port: number
-
-  constructor(
-    app: ProjectApp,
-    projectPath: string,
-    projectId: string,
-    callbacks: RunnerCallbacks
-  ) {
-    super(app, projectPath, projectId, callbacks)
-    this.port = app.port || 3000
-  }
-
-  async start(): Promise<{ success: boolean; pid?: number; error?: string }> {
-    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: unknown, 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?: NodeJS.Signals) => {
-          this.stop()
-        },
-      } as ChildProcess
-
-      return {
-        success: true,
-        pid: process.pid,
-      }
-    } catch (error: any) {
-      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(): Promise<{ success: boolean; error?: string }> {
-    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: any) {
-      await this.writeLog('stderr', `Error stopping static server: ${error.message}`)
-      return {
-        success: false,
-        error: error.message || 'Failed to stop static server'
-      }
-    }
-  }
-
-  getStats(): RunnerStats {
-    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(): Promise<{ success: boolean; pid?: number; error?: string }> {
-    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: Buffer) => {
-        const output = data.toString()
-        await this.writeLog('stdout', output)
-      })
-
-      // Capture stderr
-      this.process.stderr?.on('data', async (data: Buffer) => {
-        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: any) {
-      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(): Promise<{ success: boolean; error?: string }> {
-    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: any) {
-      await this.writeLog('stderr', `Error stopping backend: ${error.message}`)
-      return {
-        success: false,
-        error: error.message || 'Failed to stop backend'
-      }
-    }
-  }
-
-  getStats(): RunnerStats {
-    return {
-      ...this.stats,
-      memoryUsage: this.process ? process.memoryUsage() : undefined,
-    }
-  }
-}
-
-// ============ Runner Factory ============
-
-export function createRunner(
-  app: ProjectApp,
-  projectPath: string,
-  projectId: string,
-  callbacks: RunnerCallbacks
-): BaseRunner {
-  // 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)
-}