@exreve/exk 1.0.0

package/appManager.ts

@@ -0,0 +1,275 @@
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import type { ProjectApp } from './shared/types'
+import { createRunner, BaseRunner, RunnerOutput, RunnerStats } from './appRunner'
+
+type RunningApp = {
+  runner: BaseRunner
+  pid: number
+  startTime: number
+  logFile: string
+}
+
+// Store running app runners: projectId -> appName -> runner
+const runningApps = new Map<string, Map<string, RunningApp>>()
+
+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: string, appName: string): void => {
+  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: string, appName: string): string {
+  return path.join(LOGS_DIR, `${projectId}-${appName}.log`)
+}
+
+/**
+ * Start an app using wrapper runner
+ */
+export async function startApp(
+  projectPath: string,
+  projectId: string,
+  app: ProjectApp
+): Promise<{ success: boolean; processId?: string; pid?: number; error?: string }> {
+  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: RunnerOutput) => {
+        // Logs are handled by the runner itself
+      },
+      onError: (error: string) => {
+        // Errors are logged by runner
+      },
+      onExit: (code: number | null) => {
+        removeAppFromRunning(projectId, app.name)
+      },
+      onStats: (stats: RunnerStats) => {
+        // 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: any) {
+    return {
+      success: false,
+      error: error.message || 'Failed to start app'
+    }
+  }
+}
+
+/**
+ * Stop an app using wrapper runner
+ */
+export async function stopApp(
+  projectId: string,
+  appName: string,
+  app?: ProjectApp
+): Promise<{ success: boolean; error?: string }> {
+  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: any) {
+    return {
+      success: false,
+      error: error.message || 'Failed to stop app'
+    }
+  }
+}
+
+/**
+ * Restart an app
+ */
+export async function restartApp(
+  projectPath: string,
+  projectId: string,
+  app: ProjectApp
+): Promise<{ success: boolean; processId?: string; pid?: number; error?: string }> {
+  // 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: string, appName: string): boolean {
+  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: string, appName: string): RunningApp | null {
+  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: string, apps: ProjectApp[]): Array<{
+  name: string
+  running: boolean
+  processId?: string
+  pid?: number
+}> {
+  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: string,
+  appName: string,
+  lines: number = 100
+): Promise<{ success: boolean; logs?: string; error?: string }> {
+  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: any) {
+    return {
+      success: false,
+      error: error.message || 'Failed to read logs'
+    }
+  }
+}
+
+/**
+ * Get stats for a running app
+ */
+export function getAppStats(projectId: string, appName: string): RunnerStats | null {
+  const running = getRunningApp(projectId, appName)
+  if (!running) {
+    return null
+  }
+  
+  return running.runner.getStats()
+}