@gokiteam/goki-dev 0.2.0

package/cli/DevToolsManager.js

@@ -0,0 +1,451 @@
+import { execa } from 'execa'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { DockerManager } from './DockerManager.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+// Default service configuration
+// Services without profiles (redis, pubsub) always start
+// Services with profiles need to be explicitly enabled
+const DEFAULT_SERVICES = {
+  redis: true, // Always on (no profile)
+  pubsub: true, // Always on (no profile)
+  postgres: false, // Has profile, opt-in
+  firestore: false, // Has profile, opt-in
+  'redis-logs': false, // Has profile, opt-in
+  elasticsearch: false, // Has profile, opt-in
+  kibana: false // Has profile, opt-in
+}
+
+// Mapping from service config keys to Docker container names
+const SERVICE_CONTAINERS = {
+  redis: 'goki-redis',
+  pubsub: 'goki-pubsub-emulator',
+  postgres: 'goki-postgres',
+  firestore: 'goki-firestore-emulator',
+  'redis-logs': 'goki-redis-logs',
+  elasticsearch: 'goki-elasticsearch',
+  kibana: 'goki-kibana'
+}
+
+export class DevToolsManager {
+  // Package root is one level up from cli/
+  static DEV_TOOLS_PATH = path.resolve(__dirname, '..')
+  static HEALTH_URL = 'http://localhost:9000/v1/health/readiness'
+  static SERVICES_COMPOSE_FILE = 'docker-compose.services.yml'
+  static DEV_COMPOSE_FILE = 'docker-compose.dev.yml'
+
+  static async isRunning () {
+    try {
+      const response = await fetch(this.HEALTH_URL)
+      return response.ok
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Build profile arguments based on services configuration
+   * @param {Object} services - Service configuration from cli.config.js
+   * @returns {string[]} Array of --profile arguments
+   */
+  static buildProfileArgs (services = {}) {
+    const merged = { ...DEFAULT_SERVICES, ...services }
+    const profiles = []
+    // Only add profile args for services that have profiles and are enabled
+    const profiledServices = ['postgres', 'firestore', 'redis-logs', 'elasticsearch', 'kibana']
+    for (const service of profiledServices) {
+      if (merged[service]) {
+        profiles.push('--profile', service)
+      }
+    }
+    return profiles
+  }
+
+  /**
+   * Get list of enabled services for display
+   * @param {Object} services - Service configuration
+   * @returns {string[]} List of enabled service names
+   */
+  static getEnabledServices (services = {}) {
+    const merged = { ...DEFAULT_SERVICES, ...services }
+    return Object.entries(merged)
+      .filter(([_, enabled]) => enabled)
+      .map(([name]) => name)
+  }
+
+  /**
+   * Wait for all enabled infrastructure services to become healthy.
+   * Uses Docker healthcheck status via docker inspect for each container.
+   * Each service has its own timeout based on typical startup time.
+   * @param {Object} services - Service configuration from cli.config.js
+   * @returns {Promise<Object>} Results per service { serviceName: 'healthy'|'timeout' }
+   */
+  static async waitForServices (services = {}) {
+    const SERVICE_TIMEOUTS = {
+      postgres: 60000,      // 60s for PostgreSQL (slow initial startup)
+      elasticsearch: 90000, // 90s for Elasticsearch (very slow)
+      firestore: 45000,     // 45s for Firestore
+      redis: 15000,         // 15s for Redis (fast)
+      pubsub: 15000,        // 15s for Pub/Sub
+      kibana: 60000,        // 60s for Kibana (waits for ES)
+      'redis-logs': 15000   // 15s for Redis
+    }
+    const merged = { ...DEFAULT_SERVICES, ...services }
+    const enabled = Object.entries(merged)
+      .filter(([_, isEnabled]) => isEnabled)
+      .map(([name]) => name)
+    if (enabled.length === 0) return {}
+    const results = {}
+    await Promise.all(enabled.map(async (serviceName) => {
+      const containerName = SERVICE_CONTAINERS[serviceName]
+      if (!containerName) {
+        results[serviceName] = 'unknown'
+        return
+      }
+      try {
+        const timeout = SERVICE_TIMEOUTS[serviceName] || 30000
+        await DockerManager.waitForHealthy(containerName, timeout)
+        results[serviceName] = 'healthy'
+      } catch {
+        results[serviceName] = 'timeout'
+      }
+    }))
+    return results
+  }
+
+  /**
+   * Parse orphan container names from docker-compose error output
+   * @param {string} output - Error output from docker-compose
+   * @returns {string[]} Array of orphan container names
+   */
+  static parseOrphanContainers (output) {
+    const orphanMatch = output.match(/Found orphan containers \(([^)]+)\)/)
+    if (orphanMatch) {
+      return orphanMatch[1]
+        .replace(/[[\]]/g, '')
+        .split(',')
+        .map(name => name.trim())
+        .filter(name => name)
+    }
+    return []
+  }
+
+  /**
+   * Remove orphaned containers
+   * @param {string} composeFile - Path to compose file
+   * @param {string[]} profileArgs - Profile arguments
+   * @param {string} targetPath - Working directory
+   */
+  static async removeOrphans (composeFile, profileArgs, targetPath) {
+    const args = ['-f', composeFile, ...profileArgs, 'down', '--remove-orphans']
+    await execa('docker-compose', args, {
+      cwd: targetPath,
+      stdio: 'inherit'
+    })
+  }
+
+  /**
+   * Handle orphaned containers with user confirmation
+   * @param {string[]} orphanNames - Names of orphaned containers
+   * @param {string} composeFile - Path to compose file
+   * @param {string[]} profileArgs - Profile arguments
+   * @param {string} targetPath - Working directory
+   * @returns {Promise<boolean>} True if user wants to continue
+   */
+  static async handleOrphanedContainers (orphanNames, composeFile, profileArgs, targetPath) {
+    console.log('\n⚠️  Found orphaned containers from previous runs:\n')
+    for (const name of orphanNames) {
+      console.log(`  - ${name}`)
+    }
+    console.log('\nThese containers may conflict with the new setup.')
+    const inquirer = await import('inquirer')
+    const { action } = await inquirer.default.prompt([{
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Remove orphaned containers and continue', value: 'remove' },
+        { name: 'Cancel startup', value: 'cancel' }
+      ],
+      default: 'remove'
+    }])
+    if (action === 'cancel') {
+      return false
+    }
+    console.log('\n🧹 Removing orphaned containers...')
+    await this.removeOrphans(composeFile, profileArgs, targetPath)
+    console.log('✓ Orphaned containers removed\n')
+    return true
+  }
+
+  static async startServices (devToolsPath = null, services = {}) {
+    const targetPath = devToolsPath || this.DEV_TOOLS_PATH
+    const composeFile = path.join(targetPath, this.SERVICES_COMPOSE_FILE)
+    const profileArgs = this.buildProfileArgs(services)
+    const args = ['-f', composeFile, ...profileArgs, 'up', '-d']
+    try {
+      await execa('docker-compose', args, {
+        cwd: targetPath,
+        stdio: 'pipe',
+        all: true
+      })
+    } catch (error) {
+      const output = error.all || error.stderr || error.message
+      // Check for orphan containers warning
+      if (output.includes('orphan containers')) {
+        const orphanNames = this.parseOrphanContainers(output)
+        if (orphanNames.length > 0) {
+          const shouldContinue = await this.handleOrphanedContainers(
+            orphanNames,
+            composeFile,
+            profileArgs,
+            targetPath
+          )
+          if (!shouldContinue) {
+            throw new Error('Startup cancelled by user')
+          }
+          // Retry after cleanup
+          await execa('docker-compose', args, {
+            cwd: targetPath,
+            stdio: 'pipe'
+          })
+          return
+        }
+      }
+      // Check for container name conflict
+      if (output.includes('is already in use')) {
+        const containerMatch = output.match(/name "\/([^"]+)"/)
+        const conflictingName = containerMatch ? containerMatch[1] : 'unknown'
+        console.log(`\n⚠️  Container name conflict detected: ${conflictingName}\n`)
+        const inquirer = await import('inquirer')
+        const { action } = await inquirer.default.prompt([{
+          type: 'list',
+          name: 'action',
+          message: 'What would you like to do?',
+          choices: [
+            { name: 'Remove conflicting containers and continue', value: 'remove' },
+            { name: 'Cancel startup', value: 'cancel' }
+          ],
+          default: 'remove'
+        }])
+        if (action === 'cancel') {
+          throw new Error('Startup cancelled by user')
+        }
+        console.log('\n🧹 Removing conflicting containers...')
+        await this.removeOrphans(composeFile, profileArgs, targetPath)
+        console.log('✓ Conflicting containers removed\n')
+        // Retry after cleanup
+        await execa('docker-compose', args, {
+          cwd: targetPath,
+          stdio: 'pipe'
+        })
+        return
+      }
+      // Other error, rethrow
+      throw error
+    }
+  }
+
+  static async startDevTools (devToolsPath = null, services = {}) {
+    const targetPath = devToolsPath || this.DEV_TOOLS_PATH
+    const composeFile = path.join(targetPath, this.DEV_COMPOSE_FILE)
+    const profileArgs = this.buildProfileArgs(services)
+    const args = ['-f', composeFile, ...profileArgs, 'up', '-d']
+    try {
+      await execa('docker-compose', args, {
+        cwd: targetPath,
+        stdio: 'pipe',
+        all: true
+      })
+    } catch (error) {
+      const output = error.all || error.stderr || error.message
+      // Check for orphan containers warning
+      if (output.includes('orphan containers')) {
+        const orphanNames = this.parseOrphanContainers(output)
+        if (orphanNames.length > 0) {
+          const shouldContinue = await this.handleOrphanedContainers(
+            orphanNames,
+            composeFile,
+            profileArgs,
+            targetPath
+          )
+          if (!shouldContinue) {
+            throw new Error('Startup cancelled by user')
+          }
+          // Retry after cleanup
+          await execa('docker-compose', args, {
+            cwd: targetPath,
+            stdio: 'pipe'
+          })
+          return
+        }
+      }
+      // Check for container name conflict
+      if (output.includes('is already in use')) {
+        const containerMatch = output.match(/name "\/([^"]+)"/)
+        const conflictingName = containerMatch ? containerMatch[1] : 'unknown'
+        console.log(`\n⚠️  Container name conflict detected: ${conflictingName}\n`)
+        const inquirer = await import('inquirer')
+        const { action } = await inquirer.default.prompt([{
+          type: 'list',
+          name: 'action',
+          message: 'What would you like to do?',
+          choices: [
+            { name: 'Remove conflicting containers and continue', value: 'remove' },
+            { name: 'Cancel startup', value: 'cancel' }
+          ],
+          default: 'remove'
+        }])
+        if (action === 'cancel') {
+          throw new Error('Startup cancelled by user')
+        }
+        console.log('\n🧹 Removing conflicting containers...')
+        await this.removeOrphans(composeFile, profileArgs, targetPath)
+        console.log('✓ Conflicting containers removed\n')
+        // Retry after cleanup
+        await execa('docker-compose', args, {
+          cwd: targetPath,
+          stdio: 'pipe'
+        })
+        return
+      }
+      // Other error, rethrow
+      throw error
+    }
+  }
+
+  static async start (devToolsPath = null, services = {}) {
+    await this.startServices(devToolsPath, services)
+    await this.waitForServices(services)
+    await this.startDevTools(devToolsPath, services)
+  }
+
+  static async stopServices (devToolsPath = null) {
+    const targetPath = devToolsPath || this.DEV_TOOLS_PATH
+    const composeFile = path.join(targetPath, this.SERVICES_COMPOSE_FILE)
+    // Use all profiles when stopping to ensure all containers are stopped
+    const allProfiles = ['--profile', 'postgres', '--profile', 'firestore', '--profile', 'redis-logs', '--profile', 'elasticsearch', '--profile', 'kibana']
+    // Get list of running containers
+    const containers = await this.getRunningContainers(composeFile, allProfiles, targetPath)
+    if (containers.length > 0) {
+      console.log(`  Stopping ${containers.length} service container(s)...`)
+      for (const container of containers) {
+        console.log(`    Stopping ${container}...`)
+      }
+    }
+    await execa('docker-compose', ['-f', composeFile, ...allProfiles, 'stop'], {
+      cwd: targetPath,
+      stdio: 'inherit'
+    })
+  }
+
+  static async stopDevTools (devToolsPath = null) {
+    const targetPath = devToolsPath || this.DEV_TOOLS_PATH
+    const composeFile = path.join(targetPath, this.DEV_COMPOSE_FILE)
+    const allProfiles = ['--profile', 'postgres', '--profile', 'firestore', '--profile', 'elasticsearch', '--profile', 'kibana']
+    // Get list of running containers
+    const containers = await this.getRunningContainers(composeFile, allProfiles, targetPath)
+    if (containers.length > 0) {
+      console.log(`  Stopping ${containers.length} dev-tools container(s)...`)
+      for (const container of containers) {
+        console.log(`    Stopping ${container}...`)
+      }
+    }
+    await execa('docker-compose', ['-f', composeFile, ...allProfiles, 'stop'], {
+      cwd: targetPath,
+      stdio: 'inherit'
+    })
+  }
+
+  /**
+   * Get list of running containers for a compose file
+   * @param {string} composeFile - Path to compose file
+   * @param {string[]} profiles - Profile arguments
+   * @param {string} cwd - Working directory
+   * @returns {Promise<string[]>} Array of container names
+   */
+  static async getRunningContainers (composeFile, profiles, cwd) {
+    try {
+      const args = ['-f', composeFile, ...profiles, 'ps', '-q']
+      const result = await execa('docker-compose', args, { cwd })
+      const containerIds = result.stdout.split('\n').filter(id => id.trim())
+      if (containerIds.length === 0) return []
+      // Get container names from IDs
+      const names = []
+      for (const id of containerIds) {
+        const inspectResult = await execa('docker', ['inspect', '--format', '{{.Name}}', id])
+        names.push(inspectResult.stdout.replace(/^\//, ''))
+      }
+      return names
+    } catch {
+      return []
+    }
+  }
+
+  static async stop (devToolsPath = null) {
+    await this.stopDevTools(devToolsPath)
+    await this.stopServices(devToolsPath)
+  }
+
+  static async waitForReady (timeout = 60000) {
+    const startTime = Date.now()
+    while (Date.now() - startTime < timeout) {
+      if (await this.isRunning()) {
+        return true
+      }
+      await new Promise(resolve => setTimeout(resolve, 1000))
+    }
+    throw new Error(`Dev-tools did not become ready within ${timeout / 1000}s`)
+  }
+
+  static async ensureRunning (devToolsPath = null, services = {}) {
+    if (await this.isRunning()) {
+      return { started: false, message: 'Dev-tools already running' }
+    }
+    await this.start(devToolsPath, services)
+    await this.waitForReady()
+    return { started: true, message: 'Dev-tools started successfully' }
+  }
+
+  /**
+   * Start a specific service by name (for individual service control)
+   * @param {string} serviceName - Name of the service to start
+   * @param {string} devToolsPath - Path to dev-tools
+   */
+  static async startService (serviceName, devToolsPath = null) {
+    const targetPath = devToolsPath || this.DEV_TOOLS_PATH
+    const composeFile = path.join(targetPath, this.SERVICES_COMPOSE_FILE)
+    const profiledServices = ['postgres', 'firestore', 'redis-logs', 'elasticsearch', 'kibana']
+    const args = ['-f', composeFile]
+    if (profiledServices.includes(serviceName)) {
+      args.push('--profile', serviceName)
+    }
+    args.push('up', '-d', serviceName === 'pubsub' ? 'pubsub-emulator' : serviceName === 'firestore' ? 'firestore-emulator' : serviceName)
+    await execa('docker-compose', args, {
+      cwd: targetPath,
+      stdio: 'pipe'
+    })
+  }
+
+  /**
+   * Stop a specific service by name
+   * @param {string} serviceName - Name of the service to stop
+   * @param {string} devToolsPath - Path to dev-tools
+   */
+  static async stopService (serviceName, devToolsPath = null) {
+    const targetPath = devToolsPath || this.DEV_TOOLS_PATH
+    const composeFile = path.join(targetPath, this.SERVICES_COMPOSE_FILE)
+    const profiledServices = ['postgres', 'firestore', 'redis-logs', 'elasticsearch', 'kibana']
+    const args = ['-f', composeFile]
+    if (profiledServices.includes(serviceName)) {
+      args.push('--profile', serviceName)
+    }
+    args.push('stop', serviceName === 'pubsub' ? 'pubsub-emulator' : serviceName === 'firestore' ? 'firestore-emulator' : serviceName)
+    await execa('docker-compose', args, {
+      cwd: targetPath,
+      stdio: 'pipe'
+    })
+  }
+}

package/cli/DockerManager.js

@@ -0,0 +1,138 @@
+import { execa } from 'execa'
+import { Logger } from './Logger.js'
+import os from 'os'
+
+export class DockerManager {
+  static async isRunning () {
+    try {
+      await execa('docker', ['info'], { timeout: 5000 })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  static async startDockerDesktop () {
+    const platform = os.platform()
+    if (platform === 'darwin') {
+      await execa('open', ['-a', 'Docker'])
+    } else if (platform === 'win32') {
+      await execa('powershell', ['-Command', 'Start-Process', 'Docker Desktop'])
+    } else {
+      throw new Error('Auto-starting Docker is only supported on macOS and Windows')
+    }
+  }
+
+  static async waitForDockerReady (timeout = 60000) {
+    const startTime = Date.now()
+    while (Date.now() - startTime < timeout) {
+      if (await this.isRunning()) {
+        return true
+      }
+      await new Promise(resolve => setTimeout(resolve, 2000))
+    }
+    throw new Error(`Docker did not start within ${timeout / 1000}s`)
+  }
+
+  static async ensureRunning () {
+    if (await this.isRunning()) {
+      return { wasStarted: false }
+    }
+    Logger.info('Docker is not running. Starting Docker Desktop...')
+    try {
+      await this.startDockerDesktop()
+      Logger.info('Waiting for Docker to be ready (this may take 10-30 seconds)...')
+      await this.waitForDockerReady()
+      Logger.success('Docker Desktop started successfully!')
+      return { wasStarted: true }
+    } catch (error) {
+      if (error.message.includes('Auto-starting Docker is only supported')) {
+        throw new Error('Docker is not running. Please start Docker Desktop manually.')
+      }
+      throw error
+    }
+  }
+
+  static async ensureNetwork (name) {
+    try {
+      await execa('docker', ['network', 'inspect', name])
+    } catch {
+      await execa('docker', ['network', 'create', name])
+    }
+  }
+
+  /**
+   * Build the -f args array for docker-compose commands
+   * Always includes baseFile, adds overrideFile if provided
+   */
+  static buildComposeFileArgs (baseFile, overrideFile) {
+    const args = ['-f', baseFile]
+    if (overrideFile) {
+      args.push('-f', overrideFile)
+    }
+    return args
+  }
+
+  static async composeUp (baseFile, overrideFile, options = {}) {
+    const args = this.buildComposeFileArgs(baseFile, overrideFile)
+    args.push('up', '-d', '--remove-orphans')
+    const execaOpts = { stdio: 'inherit' }
+    if (options.env) {
+      execaOpts.env = { ...process.env, ...options.env }
+    }
+    await execa('docker-compose', args, execaOpts)
+  }
+
+  static async composeStop (baseFile, overrideFile) {
+    const args = this.buildComposeFileArgs(baseFile, overrideFile)
+    args.push('stop')
+    await execa('docker-compose', args, {
+      stdio: 'inherit'
+    })
+  }
+
+  static async composeDown (baseFile, overrideFile) {
+    const args = this.buildComposeFileArgs(baseFile, overrideFile)
+    args.push('down')
+    await execa('docker-compose', args, {
+      stdio: 'inherit'
+    })
+  }
+
+  static async composePs (baseFile, overrideFile) {
+    const args = this.buildComposeFileArgs(baseFile, overrideFile)
+    args.push('ps')
+    await execa('docker-compose', args, {
+      stdio: 'inherit'
+    })
+  }
+
+  static async composeLogs (baseFile, overrideFile, follow = false) {
+    const args = this.buildComposeFileArgs(baseFile, overrideFile)
+    args.push('logs')
+    if (follow) args.push('-f')
+    await execa('docker-compose', args, { stdio: 'inherit' })
+  }
+
+  static async waitForHealthy (containerName, timeout = 30000) {
+    const startTime = Date.now()
+    while (Date.now() - startTime < timeout) {
+      try {
+        const { stdout } = await execa('docker', [
+          'inspect',
+          '--format={{.State.Status}}||{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}',
+          containerName
+        ])
+        const [status, health] = stdout.trim().split('||')
+        // No health check defined — running is good enough
+        if (health === 'none' && status === 'running') return
+        // Health check defined — wait for healthy
+        if (health === 'healthy') return
+      } catch {
+        // Container might not exist yet
+      }
+      await new Promise(resolve => setTimeout(resolve, 1000))
+    }
+    throw new Error(`Container ${containerName} did not become healthy within ${timeout}ms`)
+  }
+}

package/cli/FunctionManager.js

@@ -0,0 +1,95 @@
+import path from 'path'
+import fs from 'fs'
+
+export class FunctionManager {
+  constructor (devToolsUrl = 'http://localhost:9000') {
+    this.devToolsUrl = devToolsUrl
+  }
+
+  async isReachable () {
+    try {
+      const response = await fetch(`${this.devToolsUrl}/v1/functions/list`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+        signal: AbortSignal.timeout(3000)
+      })
+      return response.ok
+    } catch {
+      return false
+    }
+  }
+
+  async registerFunctions (functionsConfig, projectDir) {
+    const { sourcePath, list } = functionsConfig
+    if (!list || list.length === 0) return { registered: [], errors: [] }
+    const resolvedSourcePath = sourcePath
+      ? path.resolve(projectDir, sourcePath)
+      : path.resolve(projectDir, '.dev-tools', 'functions')
+    // Check if source path exists
+    if (!fs.existsSync(resolvedSourcePath)) {
+      return {
+        registered: [],
+        errors: [{ message: `Functions source path not found: ${resolvedSourcePath}` }]
+      }
+    }
+    // Install dependencies if needed
+    await this.installDependencies(resolvedSourcePath)
+    const registered = []
+    const errors = []
+    for (const fn of list) {
+      try {
+        const result = await this.registerFunction(fn, resolvedSourcePath)
+        registered.push({ name: fn.name, ...result })
+      } catch (error) {
+        errors.push({ name: fn.name, error: error.message })
+      }
+    }
+    return { registered, errors }
+  }
+
+  async registerFunction (fn, sourcePath) {
+    const body = {
+      name: fn.name,
+      source: fn.source,
+      sourcePath,
+      entryPoint: fn.entryPoint || fn.name,
+      triggerType: fn.triggerType,
+      triggerConfig: fn.triggerConfig || {},
+      signatureType: fn.signatureType || 'cloudevent',
+      runtime: fn.runtime || 'nodejs20',
+      timeoutSeconds: fn.timeoutSeconds || 60,
+      description: fn.description || 'Auto-registered from config'
+    }
+    if (fn.env) {
+      body.environmentVariables = fn.env
+    }
+    const response = await fetch(`${this.devToolsUrl}/v1/functions/create`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30000)
+    })
+    const result = await response.json()
+    if (!result.success && result.success !== undefined) {
+      throw new Error(result.message || 'Failed to register function')
+    }
+    return result
+  }
+
+  async installDependencies (sourcePath) {
+    const packageJsonPath = path.join(sourcePath, 'package.json')
+    const nodeModulesPath = path.join(sourcePath, 'node_modules')
+    if (fs.existsSync(packageJsonPath) && !fs.existsSync(nodeModulesPath)) {
+      const { execa } = await import('execa')
+      try {
+        await execa('npm', ['install'], { cwd: sourcePath, timeout: 120000 })
+        return true
+      } catch (error) {
+        // Non-fatal — warn but continue
+        return false
+      }
+    }
+    return true
+  }
+}