@exreve/exk 1.0.0

package/projectManager.ts

@@ -0,0 +1,111 @@
+import fs from 'fs/promises'
+import path from 'path'
+
+const toAbsolutePath = (p: string) => path.isAbsolute(p) ? p : path.resolve(p)
+
+interface ProjectCreateRequest {
+  projectId: string
+  name: string
+  path: string
+  sourcePath?: string
+}
+
+interface ProjectInfo {
+  projectId: string
+  name: string
+  path: string
+  sourcePath?: string
+  exists: boolean
+}
+
+export async function createProject(request: ProjectCreateRequest): Promise<{ success: boolean; error?: string; actualPath?: string }> {
+  try {
+    const { projectId, name, path: projectPath, sourcePath } = request
+    const absolutePath = toAbsolutePath(projectPath)
+
+    // Check if source path exists (if linking)
+    if (sourcePath) {
+      const absoluteSourcePath = toAbsolutePath(sourcePath)
+      try {
+        const sourceStat = await fs.stat(absoluteSourcePath)
+        if (!sourceStat.isDirectory()) {
+          return { success: false, error: 'Source path is not a directory' }
+        }
+      } catch {
+        return { success: false, error: 'Source path does not exist' }
+      }
+    }
+
+    // Check if project directory already exists
+    try {
+      const stat = await fs.stat(absolutePath)
+      if (!stat.isDirectory()) {
+        return { success: false, error: 'Path exists but is not a directory' }
+      }
+    } catch {
+      // Directory doesn't exist, create it
+      try {
+        await fs.mkdir(absolutePath, { recursive: true })
+      } catch (error: any) {
+        return { success: false, error: `Failed to create directory: ${error.message}` }
+      }
+    }
+
+    // If linking to source, create symlink or copy (for now, just validate)
+    // In a real implementation, you might want to create a symlink or copy files
+    if (sourcePath) {
+      // For now, we just validate that both paths exist
+      // The actual linking can be done by the application logic
+    }
+
+    return { success: true, actualPath: absolutePath }
+  } catch (error: any) {
+    return { success: false, error: error.message }
+  }
+}
+
+export async function deleteProject(projectPath: string): Promise<{ success: boolean; error?: string }> {
+  try {
+    const absolutePath = toAbsolutePath(projectPath)
+
+    try {
+      const stat = await fs.stat(absolutePath)
+      if (!stat.isDirectory()) {
+        return { success: false, error: 'Path is not a directory' }
+      }
+    } catch {
+      // Directory doesn't exist, consider it deleted
+      return { success: true }
+    }
+
+    // Don't delete the directory on device - just succeed
+    // The directory will remain on the filesystem
+    return { success: true }
+  } catch (error: any) {
+    return { success: false, error: error.message }
+  }
+}
+
+export async function getProjectInfo(projectPath: string): Promise<ProjectInfo | null> {
+  try {
+    const absolutePath = toAbsolutePath(projectPath)
+
+    try {
+      const stat = await fs.stat(absolutePath)
+      if (!stat.isDirectory()) {
+        return null
+      }
+
+      return {
+        projectId: '', // Will be set by caller
+        name: path.basename(absolutePath),
+        path: absolutePath,
+        exists: true
+      }
+    } catch {
+      return null
+    }
+  } catch {
+    return null
+  }
+}

package/runnerGenerator.ts

@@ -0,0 +1,218 @@
+import type { ProjectApp } from './shared/types'
+
+/**
+ * Generate TypeScript runner code for an app
+ */
+export function generateRunnerCode(app: ProjectApp, projectPath: string): string {
+  const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_') // Sanitize app name for filename
+  const appType = app.appType || (app.framework?.toLowerCase().includes('react') || 
+                                  app.framework?.toLowerCase().includes('vue') || 
+                                  app.framework?.toLowerCase().includes('angular') ||
+                                  app.framework?.toLowerCase().includes('svelte') ? 'static-frontend' : 'backend')
+  
+  if (appType === 'static-frontend') {
+    return generateStaticFrontendRunner(app, projectPath)
+  } else {
+    return generateBackendRunner(app, projectPath)
+  }
+}
+
+function generateStaticFrontendRunner(app: ProjectApp, projectPath: string): string {
+  const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_') // Sanitize app name for filename
+  const port = app.port || 3000
+  const buildDir = app.buildDir || 'dist'
+  const appDir = app.directory || ''
+  
+  return `import Fastify from 'fastify'
+import fastifyStatic from '@fastify/static'
+import path from 'path'
+import fs from 'fs/promises'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const PORT = ${port}
+const BUILD_DIR = path.join(__dirname, ${appDir ? `'${appDir}', ` : ''}'${buildDir}')
+
+async function start() {
+  // Check if build directory exists
+  try {
+    await fs.access(BUILD_DIR)
+  } catch {
+    console.error(\`✗ Build directory not found: \${BUILD_DIR}\`)
+    console.error('  Please build the project first using: ' + (process.env.BUILD_COMMAND || 'npm run build'))
+    process.exit(1)
+  }
+
+  const fastify = Fastify({
+    logger: {
+      level: 'info',
+      transport: {
+        target: 'pino-pretty',
+        options: {
+          translateTime: 'HH:MM:ss Z',
+          ignore: 'pid,hostname',
+        },
+      },
+    },
+  })
+
+  // Register static file serving
+  await fastify.register(fastifyStatic, {
+    root: BUILD_DIR,
+    prefix: '/',
+  })
+
+  // Request logging
+  fastify.addHook('onRequest', async (request, reply) => {
+    const logLine = \`[\${new Date().toISOString()}] \${request.method} \${request.url} - \${reply.statusCode}\\n\`
+    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
+  })
+
+  // Error handling
+  fastify.setErrorHandler(async (error, request, reply) => {
+    const logLine = \`[\${new Date().toISOString()}] ERROR: \${error.message} - \${request.method} \${request.url}\\n\`
+    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
+    reply.status(500).send({ error: 'Internal Server Error' })
+  })
+
+  try {
+    await fastify.listen({ port: PORT, host: '0.0.0.0' })
+    console.log(\`✓ Static server started on port \${PORT}\`)
+    console.log(\`  Serving from: \${BUILD_DIR}\`)
+  } catch (error: any) {
+    console.error(\`✗ Failed to start server:\`, error.message)
+    process.exit(1)
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGTERM', async () => {
+  console.log('Shutting down...')
+  await fastify.close()
+  process.exit(0)
+})
+
+process.on('SIGINT', async () => {
+  console.log('Shutting down...')
+  await fastify.close()
+  process.exit(0)
+})
+
+start()
+`
+}
+
+function generateBackendRunner(app: ProjectApp, projectPath: string): string {
+  const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_') // Sanitize app name for filename
+  const appDir = app.directory || ''
+  const startCommand = app.startCommand
+  const envVars = app.env || {}
+  
+  const envString = Object.entries(envVars)
+    .map(([key, value]) => `    ${key}: '${value}',`)
+    .join('\n')
+
+  return `import { spawn } from 'child_process'
+import fs from 'fs/promises'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const APP_DIR = path.join(__dirname, ${appDir ? `'${appDir}'` : 'undefined'})
+const START_COMMAND = '${startCommand}'
+
+const env = {
+  ...process.env,
+${envString}
+  NODE_ENV: process.env.NODE_ENV || 'development',
+}
+
+let childProcess: ReturnType<typeof spawn> | null = null
+
+async function start() {
+  const workingDir = APP_DIR || process.cwd()
+  
+  console.log(\`Starting backend app: ${app.name}\`)
+  console.log(\`  Directory: \${workingDir}\`)
+  console.log(\`  Command: \${START_COMMAND}\`)
+
+  const isWin = process.platform === 'win32'
+  const shell = isWin ? (process.env.COMSPEC || 'cmd.exe') : 'sh'
+  const args = isWin ? ['/c', START_COMMAND] : ['-c', START_COMMAND]
+  childProcess = spawn(shell, args, {
+    cwd: workingDir,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+
+  if (!childProcess.pid) {
+    console.error('✗ Failed to spawn process')
+    process.exit(1)
+  }
+
+  console.log(\`✓ Backend started with PID: \${childProcess.pid}\`)
+
+  // Capture stdout
+  childProcess.stdout?.on('data', async (data: Buffer) => {
+    const output = data.toString()
+    const logLine = \`[\${new Date().toISOString()}] [STDOUT] \${output}\`
+    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
+    process.stdout.write(output)
+  })
+
+  // Capture stderr
+  childProcess.stderr?.on('data', async (data: Buffer) => {
+    const output = data.toString()
+    const logLine = \`[\${new Date().toISOString()}] [STDERR] \${output}\`
+    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
+    process.stderr.write(output)
+  })
+
+  // Handle process exit
+  childProcess.on('exit', async (code) => {
+    const logLine = \`[\${new Date().toISOString()}] Process exited with code \${code}\\n\`
+    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
+    console.log(\`Process exited with code \${code}\`)
+    childProcess = null
+  })
+
+  // Handle process errors
+  childProcess.on('error', async (error) => {
+    const logLine = \`[\${new Date().toISOString()}] Process error: \${error.message}\\n\`
+    await fs.appendFile('${appName}_runner.log', logLine, 'utf-8').catch(() => {})
+    console.error(\`Process error: \${error.message}\`)
+  })
+}
+
+// Handle graceful shutdown
+process.on('SIGTERM', async () => {
+  console.log('Shutting down...')
+  if (childProcess) {
+    childProcess.kill('SIGTERM')
+    await new Promise(resolve => setTimeout(resolve, 2000))
+    if (childProcess) {
+      childProcess.kill('SIGKILL')
+    }
+  }
+  process.exit(0)
+})
+
+process.on('SIGINT', async () => {
+  console.log('Shutting down...')
+  if (childProcess) {
+    childProcess.kill('SIGTERM')
+    await new Promise(resolve => setTimeout(resolve, 2000))
+    if (childProcess) {
+      childProcess.kill('SIGKILL')
+    }
+  }
+  process.exit(0)
+})
+
+start()
+`
+}