@exreve/exk 1.0.0

package/appRunner.ts

@@ -0,0 +1,475 @@
+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'
+
+/** 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)
+}

package/bin/exk

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// exk CLI - entry point for npm global install
+// Runs the TypeScript CLI via tsx
+
+const { resolve, dirname } = require('path')
+const { spawn } = require('child_process')
+const fs = require('fs')
+
+const cliDir = dirname(__filename)
+const pkgDir = resolve(cliDir, '..')
+const entryPoint = resolve(pkgDir, 'index.ts')
+
+// Find tsx binary
+let tsxBin = resolve(pkgDir, 'node_modules', '.bin', 'tsx')
+if (!fs.existsSync(tsxBin)) {
+  // Walk up to find tsx in parent node_modules (npm global structure)
+  let dir = pkgDir
+  for (let i = 0; i < 10; i++) {
+    const candidate = resolve(dir, 'node_modules', '.bin', 'tsx')
+    if (fs.existsSync(candidate)) {
+      tsxBin = candidate
+      break
+    }
+    const parent = resolve(dir, '..')
+    if (parent === dir) break
+    dir = parent
+  }
+}
+
+const args = process.argv.slice(2)
+
+const child = spawn(tsxBin, [entryPoint, ...args], {
+  stdio: 'inherit',
+  env: { ...process.env },
+  cwd: pkgDir
+})
+
+child.on('exit', (code) => {
+  process.exit(code || 0)
+})
+
+child.on('error', (err) => {
+  console.error('Failed to start exk:', err.message)
+  process.exit(1)
+})

package/container-entrypoint.sh

@@ -0,0 +1,177 @@
+#!/bin/sh
+# Don't use set -e, we want to handle errors gracefully
+
+# Container entrypoint script for TTC CLI
+# This script runs the TTC CLI daemon inside a container
+
+echo "=== TTC Container Entrypoint ==="
+
+# Check required environment variables
+if [ -z "$TTC_AUTH_TOKEN" ]; then
+  echo "ERROR: TTC_AUTH_TOKEN environment variable is required"
+  exit 1
+fi
+
+if [ -z "$TTC_SERVER_URL" ]; then
+  echo "ERROR: TTC_SERVER_URL environment variable is required"
+  exit 1
+fi
+
+# Check for Node.js
+if ! command -v node >/dev/null 2>&1; then
+  echo "ERROR: Node.js is required but not found. Please use a base image with Node.js (e.g., node:20-slim)"
+  exit 1
+fi
+
+echo "Node.js version: $(node --version)"
+
+# TTC CLI directory (mounted from host)
+TTC_DIR="/opt/ttc"
+
+# Check if CLI is mounted - look for index.js in root or dist directory
+CLI_FILE=""
+if [ -f "$TTC_DIR/index.js" ]; then
+  CLI_FILE="$TTC_DIR/index.js"
+elif [ -f "$TTC_DIR/dist/index.js" ]; then
+  CLI_FILE="$TTC_DIR/dist/index.js"
+elif [ -f "$TTC_DIR/dist/cli/index.js" ]; then
+  CLI_FILE="$TTC_DIR/dist/cli/index.js"
+elif [ -f "$TTC_DIR/index.ts" ]; then
+  echo "WARNING: Found TypeScript source file. CLI needs to be built first."
+  echo "Please build the CLI before mounting: cd cli && npm run build"
+  exit 1
+else
+  echo "ERROR: TTC CLI not found at $TTC_DIR"
+  echo "The CLI directory must be mounted into the container."
+  echo "Expected files: $TTC_DIR/index.js, $TTC_DIR/dist/index.js, or $TTC_DIR/dist/cli/index.js"
+  echo "Example: docker run -v /path/to/cli:$TTC_DIR:ro ..."
+  echo ""
+  echo "Contents of $TTC_DIR:"
+  ls -la "$TTC_DIR/" 2>/dev/null || echo "Directory not accessible"
+  exit 1
+fi
+
+echo "TTC CLI found at $CLI_FILE"
+
+# Determine config directory based on current user
+# Try common locations for non-root users
+CURRENT_USER=$(id -u)
+CURRENT_HOME=$(eval echo ~$(id -un 2>/dev/null || echo "user"))
+
+# Use HOME if available, otherwise try common locations
+# NOTE: CLI uses '.talk-to-code' directory, not '.ttc'
+if [ -n "$HOME" ] && [ -d "$HOME" ]; then
+  CONFIG_DIR="$HOME/.talk-to-code"
+elif [ "$CURRENT_USER" = "1000" ] && [ -d "/home/node" ]; then
+  CONFIG_DIR="/home/node/.talk-to-code"
+elif [ -d "$CURRENT_HOME" ]; then
+  CONFIG_DIR="$CURRENT_HOME/.talk-to-code"
+else
+  # Fallback to /tmp if no home directory
+  CONFIG_DIR="/tmp/.talk-to-code"
+fi
+
+echo "Using config directory: $CONFIG_DIR"
+mkdir -p "$CONFIG_DIR" || {
+  echo "WARNING: Could not create $CONFIG_DIR, trying /tmp/.talk-to-code"
+  CONFIG_DIR="/tmp/.talk-to-code"
+  mkdir -p "$CONFIG_DIR"
+}
+
+# Configure API URL
+echo "{\"apiUrl\":\"$TTC_SERVER_URL\"}" > "$CONFIG_DIR/config.json" || {
+  echo "ERROR: Could not write config file"
+  exit 1
+}
+
+# Generate unique deviceId for this container (if not provided)
+DEVICE_ID_FILE="$CONFIG_DIR/device-id.json"
+if [ ! -f "$DEVICE_ID_FILE" ]; then
+  # Generate UUID using Node.js
+  DEVICE_ID=$(node -e "const {randomUUID}=require('crypto');console.log(randomUUID())" 2>/dev/null) || {
+    echo "ERROR: Could not generate device ID"
+    exit 1
+  }
+  echo "{\"deviceId\":\"$DEVICE_ID\"}" > "$DEVICE_ID_FILE" || {
+    echo "ERROR: Could not write device ID file"
+    exit 1
+  }
+  echo "Generated device ID: $DEVICE_ID"
+else
+  DEVICE_ID=$(node -e "console.log(require('$DEVICE_ID_FILE').deviceId)" 2>/dev/null) || {
+    echo "ERROR: Could not read device ID file"
+    exit 1
+  }
+  echo "Using existing device ID: $DEVICE_ID"
+fi
+
+# Set container name from environment (if provided)
+CONTAINER_NAME="${CONTAINER_NAME:-container}"
+HOSTNAME="${HOSTNAME:-$CONTAINER_NAME}"
+
+echo "Container name: $CONTAINER_NAME"
+echo "Hostname: $HOSTNAME"
+echo "Server URL: $TTC_SERVER_URL"
+echo "Device ID: $DEVICE_ID"
+echo ""
+
+# Ensure common project directories exist
+# This prevents ENOENT errors when SDK tries to spawn with these as cwd
+# Create directories that work regardless of user (under /tmp)
+COMMON_PROJECT_DIRS="/tmp/project /tmp/workspace /tmp/abc"
+for dir in $COMMON_PROJECT_DIRS; do
+  if [ ! -d "$dir" ]; then
+    echo "Creating project directory: $dir"
+    mkdir -p "$dir" 2>/dev/null || echo "WARNING: Could not create $dir"
+  fi
+done
+
+# Create /home/abc if we're root (setup phase)
+# This directory is commonly used as project path in containers
+if [ "$(id -u)" = "0" ]; then
+  if [ ! -d "/home/abc" ]; then
+    echo "Creating /home/abc (as root)"
+    mkdir -p "/home/abc"
+    chown -R node:node "/home/abc"
+    echo "Created /home/abc with node:node ownership"
+  fi
+else
+  # Not root - can't create in /home, but /tmp/abc is already created above
+  echo "Not running as root, /home/abc creation skipped (using /tmp/abc as fallback)"
+fi
+echo ""
+
+# Change to CLI directory (use the directory containing the CLI file)
+CLI_DIR=$(dirname "$CLI_FILE")
+cd "$CLI_DIR" || {
+  echo "ERROR: Could not change to CLI directory: $CLI_DIR"
+  exit 1
+}
+
+# Verify we can read the CLI file
+if [ ! -r "$CLI_FILE" ]; then
+  echo "ERROR: CLI file not readable: $CLI_FILE"
+  ls -la "$CLI_DIR/" || true
+  exit 1
+fi
+
+# Run TTC daemon (non-foreground mode for containers)
+echo "Starting TTC CLI daemon..."
+echo "Working directory: $(pwd)"
+echo "CLI file: $CLI_FILE"
+echo "User: $(id -un) ($(id -u))"
+echo "HOME: $HOME"
+echo "Node version: $(node --version)"
+echo ""
+
+# Execute the CLI daemon
+# Note: exec replaces the shell process, so any code after this won't run
+# If exec fails, the container will exit with the error code
+
+# If running as root, switch to node user for security
+if [ "$(id -u)" = "0" ]; then
+  echo "Switching to node user (UID 1000)..."
+  exec su-exec node:node node "$CLI_FILE" daemon
+else
+  exec node "$CLI_FILE" daemon
+fi