@gokiteam/goki-dev 0.2.0

package/cli/PubSubManager.js

@@ -0,0 +1,129 @@
+import http from 'http'
+
+export class PubSubManager {
+  constructor (config) {
+    this.host = config.host || 'localhost'
+    this.port = config.port || 8085
+    this.projectId = config.projectId || 'tipi-development'
+  }
+
+  async request (method, path, body = null) {
+    return new Promise((resolve, reject) => {
+      const options = {
+        hostname: this.host,
+        port: this.port,
+        path: `/v1/projects/${this.projectId}${path}`,
+        method,
+        headers: { 'Content-Type': 'application/json' }
+      }
+      const req = http.request(options, (res) => {
+        let data = ''
+        res.on('data', chunk => { data += chunk })
+        res.on('end', () => {
+          try {
+            resolve({ status: res.statusCode, data: data ? JSON.parse(data) : {} })
+          } catch {
+            resolve({ status: res.statusCode, data })
+          }
+        })
+      })
+      req.on('error', reject)
+      if (body) req.write(JSON.stringify(body))
+      req.end()
+    })
+  }
+
+  async isReachable () {
+    try {
+      const { status } = await this.request('GET', '/topics')
+      return status === 200
+    } catch {
+      return false
+    }
+  }
+
+  async topicExists (topicName) {
+    const { status } = await this.request('GET', `/topics/${topicName}`)
+    return status === 200
+  }
+
+  async subscriptionExists (subscriptionName) {
+    const { status } = await this.request('GET', `/subscriptions/${subscriptionName}`)
+    return status === 200
+  }
+
+  async createTopic (topicName) {
+    const { status, data } = await this.request('PUT', `/topics/${topicName}`)
+    if (status !== 200 && status !== 409) {
+      throw new Error(`Failed to create topic ${topicName}: ${JSON.stringify(data)}`)
+    }
+    return status === 200 ? 'created' : 'exists'
+  }
+
+  async createSubscription (subscriptionName, topicName) {
+    const { status, data } = await this.request('PUT', `/subscriptions/${subscriptionName}`, {
+      topic: `projects/${this.projectId}/topics/${topicName}`
+    })
+    if (status !== 200 && status !== 409) {
+      throw new Error(`Failed to create subscription ${subscriptionName}: ${JSON.stringify(data)}`)
+    }
+    return status === 200 ? 'created' : 'exists'
+  }
+
+  async initializeAll (topics = []) {
+    const results = { topics: [], subscriptions: [] }
+    const normalized = topics.map(t => typeof t === 'string' ? { name: t } : t)
+    for (const entry of normalized) {
+      const result = await this.createTopic(entry.name)
+      results.topics.push({ name: entry.name, result })
+    }
+    for (const entry of normalized) {
+      if (!entry.subscription) continue
+      const result = await this.createSubscription(entry.subscription, entry.name)
+      results.subscriptions.push({ name: entry.subscription, topic: entry.name, result })
+    }
+    return results
+  }
+
+  /**
+   * Register topics with dev-tools persistent registry for auto-recovery.
+   * Fire-and-forget — silently fails if dev-tools backend is unavailable.
+   */
+  async registerWithDevTools (topics, projectName) {
+    try {
+      const body = JSON.stringify({ projectName, topics })
+      return new Promise((resolve) => {
+        const options = {
+          hostname: 'localhost',
+          port: 9000,
+          path: '/v1/pubsub/registry/register',
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(body)
+          }
+        }
+        const req = http.request(options, (res) => {
+          let data = ''
+          res.on('data', chunk => { data += chunk })
+          res.on('end', () => {
+            try {
+              resolve(JSON.parse(data))
+            } catch {
+              resolve(null)
+            }
+          })
+        })
+        req.on('error', () => resolve(null))
+        req.setTimeout(5000, () => {
+          req.destroy()
+          resolve(null)
+        })
+        req.write(body)
+        req.end()
+      })
+    } catch {
+      return null
+    }
+  }
+}

package/cli/SnapshotManager.js

@@ -0,0 +1,88 @@
+export class SnapshotManager {
+  constructor (config) {
+    this.config = config
+    this.devToolsUrl = 'http://localhost:9000'
+  }
+
+  async createSnapshot (services = []) {
+    const response = await fetch(`${this.devToolsUrl}/v1/snapshots/create`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ services })
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Failed to create snapshot: ${error}`)
+    }
+    const result = await response.json()
+    if (result.status === 'error') {
+      throw new Error(result.message)
+    }
+    return result
+  }
+
+  async restoreSnapshot (snapshotId, restartServices = true) {
+    const response = await fetch(`${this.devToolsUrl}/v1/snapshots/restore`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ snapshotId, restartServices })
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Failed to restore snapshot: ${error}`)
+    }
+    const result = await response.json()
+    if (result.status === 'error') {
+      throw new Error(result.message)
+    }
+    return result
+  }
+
+  async listSnapshots () {
+    const response = await fetch(`${this.devToolsUrl}/v1/snapshots/list`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({})
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Failed to list snapshots: ${error}`)
+    }
+    const result = await response.json()
+    return result
+  }
+
+  async getSnapshotDetails (snapshotId) {
+    const response = await fetch(`${this.devToolsUrl}/v1/snapshots/details`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ snapshotId })
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Failed to get snapshot details: ${error}`)
+    }
+    const result = await response.json()
+    if (result.status === 'error') {
+      throw new Error(result.message)
+    }
+    return result
+  }
+
+  async cleanupSnapshot (snapshotId = null) {
+    const response = await fetch(`${this.devToolsUrl}/v1/snapshots/delete`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(snapshotId ? { snapshotId } : {})
+    })
+    if (!response.ok) {
+      const error = await response.text()
+      throw new Error(`Failed to delete snapshot: ${error}`)
+    }
+    const result = await response.json()
+    if (result.status === 'error') {
+      throw new Error(result.message)
+    }
+    return result
+  }
+}

package/cli/UiFormatter.js

@@ -0,0 +1,292 @@
+/**
+ * UI/UX formatting utilities for CLI output
+ * Provides color, clickable links, and visual hierarchy
+ */
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  gray: '\x1b[90m'
+}
+
+/**
+ * Creates a clickable link in terminal (supported by most modern terminals)
+ * Format: \x1b]8;;URL\x1b\\TEXT\x1b]8;;\x1b\\
+ */
+export function link (url, text = url) {
+  return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`
+}
+
+/**
+ * Color text
+ */
+export function color (text, colorName) {
+  return `${colors[colorName] || ''}${text}${colors.reset}`
+}
+
+/**
+ * Dim/muted text
+ */
+export function dim (text) {
+  return color(text, 'dim')
+}
+
+/**
+ * Bright/bold text
+ */
+export function bright (text) {
+  return color(text, 'bright')
+}
+
+/**
+ * Format a section header
+ */
+export function section (title) {
+  return `\n${color('━━━', 'dim')} ${bright(title)}`
+}
+
+/**
+ * Format a service line with optional link
+ */
+export function service (icon, label, url, meta = null) {
+  const labelPart = `${icon}  ${bright(label)}`
+  const urlPart = url ? link(url, color(url, 'cyan')) : ''
+  const metaPart = meta ? dim(` ${meta}`) : ''
+  return `  ${labelPart}${urlPart ? `\n     ${urlPart}` : ''}${metaPart}`
+}
+
+/**
+ * Format a compact service line (label + URL on same line)
+ */
+export function compactService (icon, label, url, meta = null) {
+  const labelPart = `${icon}  ${label.padEnd(16)}`
+  const urlPart = url ? link(url, color(url, 'cyan')) : ''
+  const metaPart = meta ? dim(` ${meta}`) : ''
+  return `  ${labelPart}${urlPart}${metaPart}`
+}
+
+/**
+ * Format a sub-item (indented)
+ */
+export function subItem (label, value, highlighted = false) {
+  const valueColor = highlighted ? 'green' : 'cyan'
+  return `     ${dim('•')} ${label}: ${color(value, valueColor)}`
+}
+
+/**
+ * Format a command
+ */
+export function command (cmd, description) {
+  return `  ${color(cmd.padEnd(20), 'yellow')} ${dim(description)}`
+}
+
+/**
+ * Create a visual separator
+ */
+export function separator () {
+  return color('  ─'.repeat(35), 'dim')
+}
+
+/**
+ * Format a tip/hint
+ */
+export function tip (text) {
+  return `\n  ${dim('💡 Tip:')} ${text}\n`
+}
+
+/**
+ * Format a warning
+ */
+export function warning (text) {
+  return `  ${color('⚠️  Warning:', 'yellow')} ${text}`
+}
+
+/**
+ * Format success message
+ */
+export function success (text) {
+  return `\n${color('✨ ' + text, 'green')}\n`
+}
+
+/**
+ * Create a box around text
+ */
+export function box (lines) {
+  const maxLen = Math.max(...lines.map(l => stripAnsi(l).length))
+  const top = `┌${'─'.repeat(maxLen + 2)}┐`
+  const bottom = `└${'─'.repeat(maxLen + 2)}┘`
+  const content = lines.map(line => {
+    const padding = maxLen - stripAnsi(line).length
+    return `│ ${line}${' '.repeat(padding)} │`
+  })
+  return [top, ...content, bottom].join('\n')
+}
+
+/**
+ * Strip ANSI codes for length calculation
+ */
+function stripAnsi (str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b]8;;.*?\x1b\\/g, '')
+}
+
+/**
+ * Create a simple table with aligned columns
+ */
+export function table (rows, options = {}) {
+  if (rows.length === 0) return ''
+  const { indent = '  ', separator = '  ' } = options
+  // Calculate column widths
+  const colCount = rows[0].length
+  const widths = Array(colCount).fill(0)
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      const len = stripAnsi(row[i]).length
+      if (len > widths[i]) widths[i] = len
+    }
+  }
+  // Format rows
+  const lines = []
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i]
+    const cells = row.map((cell, j) => {
+      const padding = widths[j] - stripAnsi(cell).length
+      return cell + ' '.repeat(padding)
+    })
+    const line = indent + cells.join(separator)
+    lines.push(line)
+    // Add separator after header (first row)
+    if (i === 0 && rows.length > 1) {
+      const sepLine = indent + widths.map(w => dim('─'.repeat(w))).join(separator)
+      lines.push(sepLine)
+    }
+  }
+  return lines.join('\n')
+}
+
+/**
+ * Format the startup success output with all service URLs and info
+ */
+export function formatStartupOutput (options) {
+  const {
+    projectName,
+    appPort,
+    webhookResult,
+    webhookUrlResult,
+    proxyResult,
+    overrideResult,
+    mcpResult
+  } = options
+
+  const lines = []
+
+  // Success header
+  lines.push(success(`${projectName} is ready!`))
+
+  // Main services section
+  lines.push(section('Services'))
+  const serviceRows = [
+    [dim('Service'), dim('URL')]
+  ]
+  if (appPort) {
+    serviceRows.push([
+      '🌐  Application',
+      link(`http://localhost:${appPort}`, color(`http://localhost:${appPort}`, 'cyan'))
+    ])
+  }
+  serviceRows.push([
+    '🎛️  Dev Tools',
+    link('http://localhost:9001', color('http://localhost:9001', 'cyan'))
+  ])
+  lines.push(table(serviceRows, { indent: '  ' }))
+
+  // Webhook tunnel section
+  if (webhookResult?.tunnelUrl) {
+    lines.push(section('Webhook Tunnel'))
+    const pidInfo = webhookResult.pid ? dim(` (PID ${webhookResult.pid})`) : ''
+    const tunnelUrl = link(webhookResult.tunnelUrl, color(webhookResult.tunnelUrl, 'cyan'))
+    lines.push(`  🔗  ${tunnelUrl}${pidInfo}`)
+
+    if (webhookResult.routes?.length > 0) {
+      lines.push('')
+      const routeRows = [
+        [dim('Route'), dim('Webhook URL')]
+      ]
+      for (const prefix of webhookResult.routes) {
+        const url = `${webhookResult.tunnelUrl}/v1/webhooks/proxy/${prefix}`
+        routeRows.push([
+          color(prefix, 'yellow'),
+          link(url, color(url, 'cyan'))
+        ])
+      }
+      lines.push(table(routeRows, { indent: '  ' }))
+      lines.push(`  ${dim('Stop with:')} ${color('goki-dev ngrok stop', 'yellow')}`)
+    }
+  } else if (webhookResult?.routes?.length > 0) {
+    lines.push(section('Webhook Tunnel'))
+    lines.push(warning('Tunnel not available — install ngrok for external access'))
+  }
+
+  // HTTP proxy section
+  if (proxyResult && proxyResult.rewrites?.length > 0) {
+    lines.push(section('HTTP Traffic Monitoring'))
+    lines.push(`  ${color(proxyResult.rewrites.length, 'green')} URL(s) proxied through dev-tools`)
+
+    // Build table rows
+    const tableRows = [
+      [dim('Variable'), dim('Original URL'), dim('Status')]
+    ]
+    for (const r of proxyResult.rewrites) {
+      tableRows.push([
+        color(r.key, 'yellow'),
+        dim(r.original),
+        color('✓ proxied', 'green')
+      ])
+    }
+    if (proxyResult.skipped?.length > 0) {
+      for (const s of proxyResult.skipped) {
+        tableRows.push([
+          color(s.key, 'gray'),
+          dim(s.original),
+          dim('○ skipped')
+        ])
+      }
+    }
+
+    lines.push(table(tableRows, { indent: '  ' }))
+  }
+
+  // Webhook URL Substitution section
+  if (webhookUrlResult && webhookUrlResult.rewrites?.length > 0) {
+    lines.push(section('Webhook URL Substitution'))
+    lines.push(`  ${color(webhookUrlResult.rewrites.length, 'green')} placeholder(s) replaced`)
+    lines.push('')
+
+    const tableRows = [
+      [dim('Variable'), dim('Substituted URL')]
+    ]
+    for (const r of webhookUrlResult.rewrites) {
+      tableRows.push([
+        color(r.key, 'yellow'),
+        dim(r.substituted)
+      ])
+    }
+
+    lines.push(table(tableRows, { indent: '  ' }))
+  }
+
+  // MCP config info
+  if (mcpResult && !mcpResult.skipped) {
+    const action = mcpResult.created ? 'Created' : 'Updated'
+    lines.push(`  ${dim('🤖')} ${action} ${color('.mcp.json', 'cyan')} ${dim('— Claude Code ready')}`)
+  }
+
+  lines.push('')
+  return lines.join('\n')
+}

package/cli/WebhookUrlRewriter.js

@@ -0,0 +1,32 @@
+import path from 'path'
+import { collectAllEnvVars } from './ComposeParser.js'
+
+const WEBHOOK_PLACEHOLDER = '{DEV_TOOLS_WEBHOOK_BASE_URL}'
+
+/**
+ * Compute webhook URL rewrites as pure data (no file writing)
+ *
+ * @param {object} config - The config object
+ * @param {string} projectDir - Absolute path to project root
+ * @param {string} tunnelUrl - The ngrok tunnel URL
+ * @returns {{ rewrites: Array<{key, original, substituted}>, serviceName: string }} or null
+ */
+export function computeWebhookRewrites (config, projectDir, tunnelUrl) {
+  if (!tunnelUrl) return null
+  const docker = config.docker || {}
+  const composeFile = docker.composeFile || 'docker-compose.yaml'
+  const envFilePath = path.join(projectDir, 'config.development')
+  const composePath = path.join(projectDir, composeFile)
+  const { allVars, serviceName } = collectAllEnvVars(envFilePath, composePath)
+  if (!serviceName) return null
+  const rewrites = []
+  const webhookBaseUrl = `${tunnelUrl}/v1/webhooks/proxy`
+  for (const [key, value] of Object.entries(allVars)) {
+    if (value.includes(WEBHOOK_PLACEHOLDER)) {
+      const substituted = value.replace(WEBHOOK_PLACEHOLDER, webhookBaseUrl)
+      rewrites.push({ key, original: value, substituted })
+    }
+  }
+  if (rewrites.length === 0) return null
+  return { rewrites, serviceName }
+}

package/cli/secrets/BiometricAuth.js

@@ -0,0 +1,125 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import crypto from 'crypto'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+
+const CONFIG_DIR = '.goki-dev'
+const PREFS_FILE = 'preferences.json'
+
+export class BiometricAuth {
+  constructor (preferences = {}) {
+    this._enabled = preferences.biometric !== false
+    this._passphraseHash = preferences.passphraseHash || null
+  }
+
+  async isAvailable () {
+    if (process.platform !== 'darwin') return false
+    try {
+      const touchid = await import('macos-touchid')
+      return !!touchid.default
+    } catch {
+      return false
+    }
+  }
+
+  async authenticate (reason = 'access secure credentials') {
+    if (this._enabled && await this.isAvailable()) {
+      try {
+        const touchid = (await import('macos-touchid')).default
+        await new Promise((resolve, reject) => {
+          touchid.authenticate(reason, (err) => {
+            if (err) reject(err)
+            else resolve()
+          })
+        })
+        return true
+      } catch (err) {
+        console.log(chalk.yellow('Touch ID failed, falling back to passphrase...'))
+      }
+    }
+    return this._authenticateWithPassphrase()
+  }
+
+  get enabled () {
+    return this._enabled
+  }
+
+  set enabled (value) {
+    this._enabled = value
+  }
+
+  async _authenticateWithPassphrase () {
+    if (!this._passphraseHash) {
+      return this._setupPassphrase()
+    }
+    const { passphrase } = await inquirer.prompt([{
+      type: 'password',
+      name: 'passphrase',
+      message: 'Enter your passphrase:',
+      mask: '*'
+    }])
+    const hash = crypto.createHash('sha256').update(passphrase).digest('hex')
+    if (hash !== this._passphraseHash) {
+      throw new Error('Authentication failed: incorrect passphrase')
+    }
+    return true
+  }
+
+  async _setupPassphrase () {
+    console.log(chalk.blue('Setting up passphrase for the first time...'))
+    const { passphrase } = await inquirer.prompt([{
+      type: 'password',
+      name: 'passphrase',
+      message: 'Create a passphrase:',
+      mask: '*',
+      validate: (input) => input.length >= 4 || 'Passphrase must be at least 4 characters'
+    }])
+    const { confirm } = await inquirer.prompt([{
+      type: 'password',
+      name: 'confirm',
+      message: 'Confirm passphrase:',
+      mask: '*'
+    }])
+    if (passphrase !== confirm) {
+      throw new Error('Passphrases do not match')
+    }
+    this._passphraseHash = crypto.createHash('sha256').update(passphrase).digest('hex')
+    const prefs = BiometricAuth.loadPreferences()
+    prefs.passphraseHash = this._passphraseHash
+    BiometricAuth.savePreferences(prefs)
+    console.log(chalk.green('Passphrase saved.'))
+    return true
+  }
+
+  static loadPreferences () {
+    const prefsPath = path.join(BiometricAuth.getConfigDir(), PREFS_FILE)
+    if (!fs.existsSync(prefsPath)) {
+      return { biometric: true }
+    }
+    try {
+      const content = fs.readFileSync(prefsPath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return { biometric: true }
+    }
+  }
+
+  static savePreferences (prefs) {
+    const configDir = BiometricAuth.getConfigDir()
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true })
+    }
+    const prefsPath = path.join(configDir, PREFS_FILE)
+    fs.writeFileSync(prefsPath, JSON.stringify(prefs, null, 2) + '\n')
+  }
+
+  static getConfigDir () {
+    const dir = path.join(os.homedir(), CONFIG_DIR)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    return dir
+  }
+}