@take-out/cli 0.0.39

package/src/utils/files.ts

@@ -0,0 +1,302 @@
+/**
+ * File operations for updating project configuration
+ */
+
+import { execSync } from 'node:child_process'
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export function updatePackageJson(
+  cwd: string,
+  updates: { name?: string; description?: string }
+): { success: boolean; error?: string } {
+  const packagePath = join(cwd, 'package.json')
+
+  if (!existsSync(packagePath)) {
+    return { success: false, error: 'package.json not found' }
+  }
+
+  try {
+    const content = readFileSync(packagePath, 'utf-8')
+    const pkg = JSON.parse(content)
+
+    if (updates.name) pkg.name = updates.name
+    if (updates.description) pkg.description = updates.description
+
+    writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8')
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+export function updateAppConfig(
+  cwd: string,
+  updates: { name?: string; slug?: string; bundleId?: string }
+): { success: boolean; error?: string } {
+  const configPath = join(cwd, 'app.config.ts')
+
+  if (!existsSync(configPath)) {
+    return { success: false, error: 'app.config.ts not found' }
+  }
+
+  try {
+    let content = readFileSync(configPath, 'utf-8')
+
+    if (updates.name) {
+      // Update name field
+      content = content.replace(/(name:\s*['"])([^'"]+)(['"])/, `$1${updates.name}$3`)
+    }
+
+    if (updates.slug) {
+      // Update slug field
+      content = content.replace(/(slug:\s*['"])([^'"]+)(['"])/, `$1${updates.slug}$3`)
+    }
+
+    if (updates.bundleId) {
+      // Update iOS bundle identifier
+      content = content.replace(
+        /(bundleIdentifier:\s*['"])([^'"]+)(['"])/,
+        `$1${updates.bundleId}$3`
+      )
+      // Update Android package
+      content = content.replace(
+        /(package:\s*['"])([^'"]+)(['"])/,
+        `$1${updates.bundleId}$3`
+      )
+    }
+
+    writeFileSync(configPath, content, 'utf-8')
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+export function checkOnboarded(cwd: string): boolean {
+  const packagePath = join(cwd, 'package.json')
+  if (!existsSync(packagePath)) return false
+
+  try {
+    const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'))
+    return pkg.takeout?.onboarded === true
+  } catch {
+    return false
+  }
+}
+
+export function markOnboarded(cwd: string): { success: boolean; error?: string } {
+  const packagePath = join(cwd, 'package.json')
+
+  if (!existsSync(packagePath)) {
+    return { success: false, error: 'package.json not found' }
+  }
+
+  try {
+    const content = readFileSync(packagePath, 'utf-8')
+    const pkg = JSON.parse(content)
+
+    if (!pkg.takeout) {
+      pkg.takeout = {}
+    }
+    pkg.takeout.onboarded = true
+
+    writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8')
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+/**
+ * Updates the env section in package.json to remove platform-specific variables
+ */
+export function updatePackageJsonEnv(
+  cwd: string,
+  platform: 'sst' | 'uncloud'
+): { success: boolean; error?: string } {
+  const packagePath = join(cwd, 'package.json')
+
+  if (!existsSync(packagePath)) {
+    return { success: false, error: 'package.json not found' }
+  }
+
+  try {
+    const content = readFileSync(packagePath, 'utf-8')
+    const pkg = JSON.parse(content)
+
+    if (!pkg.env) {
+      return { success: false, error: 'env section not found in package.json' }
+    }
+
+    if (platform === 'sst') {
+      // remove uncloud-specific vars, keep sst vars
+      delete pkg.env.DEPLOY_HOST
+      delete pkg.env.DEPLOY_USER
+      delete pkg.env.DEPLOY_SSH_KEY
+    } else if (platform === 'uncloud') {
+      // remove sst-specific vars, keep uncloud vars
+      delete pkg.env.CLOUDFLARE_API_TOKEN
+      delete pkg.env.AWS_ACCESS_KEY_ID
+      delete pkg.env.AWS_SECRET_ACCESS_KEY
+    }
+
+    writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8')
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+export interface EjectOptions {
+  dryRun?: boolean
+}
+
+export interface EjectResult {
+  success: boolean
+  error?: string
+  packages?: { name: string; version: string }[]
+  warnings?: string[]
+}
+
+/**
+ * Ejects from monorepo setup by removing ./packages and updating workspace:* versions
+ */
+export async function ejectFromMonorepo(
+  cwd: string,
+  options: EjectOptions = {}
+): Promise<EjectResult> {
+  const { dryRun = false } = options
+  const packagePath = join(cwd, 'package.json')
+  const packagesDir = join(cwd, 'packages')
+  const warnings: string[] = []
+
+  if (!existsSync(packagePath)) {
+    return { success: false, error: 'package.json not found' }
+  }
+
+  try {
+    // read package.json
+    const content = readFileSync(packagePath, 'utf-8')
+    const pkg = JSON.parse(content)
+
+    // check if already ejected
+    if (!existsSync(packagesDir)) {
+      return { success: false, error: 'packages directory not found - already ejected?' }
+    }
+
+    if (!pkg.workspaces) {
+      return { success: false, error: 'no workspaces field found - already ejected?' }
+    }
+
+    // dynamically discover workspace packages from ./packages directory
+    const workspacePackages: { name: string; version: string }[] = []
+
+    const entries = readdirSync(packagesDir, { withFileTypes: true })
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const pkgJsonPath = join(packagesDir, entry.name, 'package.json')
+      if (existsSync(pkgJsonPath)) {
+        try {
+          const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'))
+          if (pkgJson.name && pkgJson.version) {
+            workspacePackages.push({ name: pkgJson.name, version: pkgJson.version })
+          } else {
+            warnings.push(`skipped ${entry.name}: missing name or version`)
+          }
+        } catch (e) {
+          warnings.push(`skipped ${entry.name}: invalid package.json`)
+        }
+      }
+    }
+
+    if (workspacePackages.length === 0) {
+      return { success: false, error: 'no valid workspace packages found' }
+    }
+
+    // check for workspace:* references that won't be resolved
+    const unresolvedDeps: string[] = []
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies }
+    for (const [name, version] of Object.entries(allDeps)) {
+      if (version === 'workspace:*') {
+        const found = workspacePackages.find((p) => p.name === name)
+        if (!found) {
+          unresolvedDeps.push(name)
+        }
+      }
+    }
+
+    if (unresolvedDeps.length > 0) {
+      return {
+        success: false,
+        error: `unresolved workspace dependencies: ${unresolvedDeps.join(', ')}`,
+        packages: workspacePackages,
+      }
+    }
+
+    // dry run returns here without making changes
+    if (dryRun) {
+      return {
+        success: true,
+        packages: workspacePackages,
+        warnings: warnings.length > 0 ? warnings : undefined,
+      }
+    }
+
+    // replace workspace:* with actual versions
+    for (const { name, version } of workspacePackages) {
+      if (pkg.dependencies?.[name] === 'workspace:*') {
+        pkg.dependencies[name] = `^${version}`
+      }
+      if (pkg.devDependencies?.[name] === 'workspace:*') {
+        pkg.devDependencies[name] = `^${version}`
+      }
+    }
+
+    // remove workspaces field
+    delete pkg.workspaces
+
+    // write updated package.json
+    writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8')
+
+    // remove packages directory
+    rmSync(packagesDir, { recursive: true, force: true })
+
+    // install the published packages
+    try {
+      execSync('bun install', { cwd, stdio: 'inherit' })
+    } catch {
+      // restore packages directory hint in error
+      return {
+        success: false,
+        error:
+          'failed to install published packages. package.json was modified but install failed. ' +
+          'try running "bun install" manually, or restore from git.',
+        packages: workspacePackages,
+      }
+    }
+
+    return {
+      success: true,
+      packages: workspacePackages,
+      warnings: warnings.length > 0 ? warnings : undefined,
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}

package/src/utils/parallel-runner.ts

@@ -0,0 +1,129 @@
+/**
+ * Utility for running scripts in parallel with color-coded output
+ */
+
+import { spawn } from 'node:child_process'
+import { cpus } from 'node:os'
+
+const colors = [
+  '\x1b[36m', // Cyan
+  '\x1b[35m', // Magenta
+  '\x1b[33m', // Yellow
+  '\x1b[32m', // Green
+  '\x1b[34m', // Blue
+  '\x1b[31m', // Red
+  '\x1b[90m', // Gray
+]
+
+const reset = '\x1b[0m'
+
+interface ScriptToRun {
+  name: string
+  path: string
+  args?: string[]
+}
+
+export async function runScriptsInParallel(
+  scripts: ScriptToRun[],
+  options: {
+    title?: string
+    onError?: 'continue' | 'exit'
+    maxParallelism?: number
+  } = {}
+): Promise<void> {
+  const { title, onError = 'exit', maxParallelism = cpus().length } = options
+
+  if (title) {
+    console.info()
+    console.info(title)
+    console.info()
+  }
+
+  const allPromises: Promise<void>[] = []
+  const executing: Set<Promise<void>> = new Set()
+
+  for (let i = 0; i < scripts.length; i++) {
+    const script = scripts[i]!
+    const scriptPromise = runSingleScript(script, i).finally(() => {
+      executing.delete(scriptPromise)
+    })
+
+    allPromises.push(scriptPromise)
+    executing.add(scriptPromise)
+
+    if (executing.size >= maxParallelism) {
+      await Promise.race(executing)
+    }
+  }
+
+  const settledResults = await Promise.allSettled(allPromises)
+
+  // Check for failures
+  const failures = settledResults.filter((r) => r.status === 'rejected')
+
+  if (failures.length > 0) {
+    console.error(`\n${reset}\x1b[31m✗ ${failures.length} script(s) failed${reset}\n`)
+    if (onError === 'exit') {
+      process.exit(1)
+    }
+  } else {
+    console.info(`\n${reset}\x1b[32m✓ All scripts completed successfully${reset}\n`)
+  }
+}
+
+function runSingleScript(script: ScriptToRun, colorIndex: number): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const color = colors[colorIndex % colors.length]
+    const prefixLabel = script.name
+
+    const proc = spawn('bun', [script.path, ...(script.args || [])], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: false,
+      env: { ...process.env, FORCE_COLOR: '3' } as any,
+      detached: true,
+    })
+
+    let stderrBuffer = ''
+
+    proc.stdout.on('data', (data) => {
+      const lines = data.toString().split('\n')
+      for (const line of lines) {
+        if (line) console.info(`${color}${prefixLabel}${reset} ${line}`)
+      }
+    })
+
+    proc.stderr.on('data', (data) => {
+      const dataStr = data.toString()
+      stderrBuffer += dataStr
+
+      const lines = dataStr.split('\n')
+      for (const line of lines) {
+        if (line) console.error(`${color}${prefixLabel}${reset} ${line}`)
+      }
+    })
+
+    proc.on('error', (error) => {
+      console.error(`${color}${prefixLabel}${reset} Failed to start: ${error.message}`)
+      reject(error)
+    })
+
+    proc.on('close', (code) => {
+      if (code && code !== 0) {
+        console.error(`${color}${prefixLabel}${reset} Process exited with code ${code}`)
+
+        // Show error details
+        if (stderrBuffer.trim()) {
+          console.error(`\n${color}${prefixLabel}${reset} Error output:`)
+          console.error('\x1b[90m' + '─'.repeat(80) + '\x1b[0m')
+          console.error(stderrBuffer)
+          console.error('\x1b[90m' + '─'.repeat(80) + '\x1b[0m\n')
+        }
+
+        reject(new Error(`Script ${prefixLabel} failed with code ${code}`))
+      } else {
+        console.info(`${color}${prefixLabel}${reset} \x1b[32m✓ completed${reset}`)
+        resolve()
+      }
+    })
+  })
+}

package/src/utils/ports.ts

@@ -0,0 +1,77 @@
+/**
+ * Port conflict detection for Takeout services
+ */
+
+import { execSync } from 'node:child_process'
+
+import type { PortCheck } from '../types'
+
+function isPortInUse(port: number): { inUse: boolean; pid?: number } {
+  try {
+    if (process.platform === 'win32') {
+      // windows: use netstat to find processes on the port
+      const output = execSync(`netstat -ano | findstr :${port}`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+      }).trim()
+
+      if (!output) return { inUse: false }
+
+      // extract pid from last column of netstat output
+      const lines = output.split('\n')
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/)
+        // check if this is a LISTENING state on the exact port
+        if (parts[1]?.includes(`:${port}`) && parts[3] === 'LISTENING') {
+          const pid = Number.parseInt(parts[4] || '', 10)
+          return { inUse: true, pid: Number.isNaN(pid) ? undefined : pid }
+        }
+      }
+      return { inUse: false }
+    } else {
+      // unix: use lsof
+      const output = execSync(`lsof -i :${port} -t`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+      }).trim()
+
+      const pid = output ? Number.parseInt(output.split('\n')[0] || '', 10) : undefined
+
+      return { inUse: !!output, pid: Number.isNaN(pid) ? undefined : pid }
+    }
+  } catch {
+    // if command fails, port is likely free
+    return { inUse: false }
+  }
+}
+
+export const TAKEOUT_PORTS = {
+  postgres: 5432,
+  zero: 4848,
+  web: 8081,
+  minio: 9090,
+  minioConsole: 9091,
+} as const
+
+export function checkPort(port: number, name: string): PortCheck {
+  const { inUse, pid } = isPortInUse(port)
+  return { port, name, inUse, pid }
+}
+
+export function checkAllPorts(): PortCheck[] {
+  return [
+    checkPort(TAKEOUT_PORTS.postgres, 'PostgreSQL'),
+    checkPort(TAKEOUT_PORTS.zero, 'Zero Sync'),
+    checkPort(TAKEOUT_PORTS.web, 'Web Server'),
+    checkPort(TAKEOUT_PORTS.minio, 'MinIO (S3)'),
+    checkPort(TAKEOUT_PORTS.minioConsole, 'MinIO Console'),
+  ]
+}
+
+export function hasPortConflicts(checks: PortCheck[]): boolean {
+  return checks.some((c) => c.inUse)
+}
+
+export function getConflictingPorts(checks: PortCheck[]): PortCheck[] {
+  return checks.filter((c) => c.inUse)
+}

package/src/utils/prerequisites.ts

@@ -0,0 +1,137 @@
+/**
+ * Check for required prerequisites (Bun, Node, Docker, Git)
+ */
+
+import { execSync } from 'node:child_process'
+
+import type { PrerequisiteCheck } from '../types'
+
+function execCommand(command: string): string | null {
+  try {
+    return execSync(command, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+    }).trim()
+  } catch {
+    return null
+  }
+}
+
+function getVersion(command: string): string | null {
+  const output = execCommand(command)
+  if (!output) return null
+
+  // Extract version number (e.g., "v1.2.3" or "1.2.3")
+  const match = output.match(/\d+\.\d+\.\d+/)
+  return match ? match[0] : output
+}
+
+function compareVersions(current: string, required: string): boolean {
+  const parseCurrent = current.replace(/^v/, '').split('.').map(Number)
+  const parseRequired = required.replace(/^v/, '').split('.').map(Number)
+
+  for (let i = 0; i < 3; i++) {
+    const curr = parseCurrent[i] || 0
+    const req = parseRequired[i] || 0
+    if (curr > req) return true
+    if (curr < req) return false
+  }
+  return true
+}
+
+export function checkBun(): PrerequisiteCheck {
+  const version = getVersion('bun --version') ?? undefined
+  const requiredVersion = '1.0.0'
+  const hasBunv = !!execCommand('bunv --version')
+
+  let message = version
+    ? compareVersions(version, requiredVersion)
+      ? `Bun ${version} installed`
+      : `Bun ${version} installed (${requiredVersion}+ recommended)`
+    : 'Bun not found'
+
+  if (version && !hasBunv) {
+    message += ' (consider installing bunv for auto version switching)'
+  }
+
+  return {
+    name: 'Bun',
+    required: true,
+    installed: !!version,
+    version,
+    requiredVersion,
+    message,
+    installUrl: 'https://bun.sh',
+    recommendation: !hasBunv
+      ? 'Install bunv to automatically switch bun versions: https://github.com/aklinker1/bunv'
+      : undefined,
+  }
+}
+
+export function checkNode(): PrerequisiteCheck {
+  const version = getVersion('node --version') ?? undefined
+  const requiredVersion = '20.0.0'
+  const hasFnm = !!execCommand('fnm --version')
+
+  let message = version
+    ? compareVersions(version, requiredVersion)
+      ? `Node.js ${version} installed`
+      : `Node.js ${version} installed (${requiredVersion}+ recommended)`
+    : 'Node.js not found (optional)'
+
+  if (version && !hasFnm) {
+    message += ' (consider installing fnm for auto version switching)'
+  }
+
+  return {
+    name: 'Node.js',
+    required: false,
+    installed: !!version,
+    version,
+    requiredVersion,
+    message,
+    installUrl: 'https://nodejs.org',
+    recommendation: !hasFnm
+      ? 'Install fnm to automatically switch node versions: https://github.com/Schniz/fnm'
+      : undefined,
+  }
+}
+
+export function checkDocker(): PrerequisiteCheck {
+  const version = getVersion('docker --version') ?? undefined
+  const isRunning = !!execCommand('docker ps')
+
+  return {
+    name: 'Docker',
+    required: true,
+    installed: !!version,
+    version,
+    message: !version
+      ? 'Docker not found'
+      : !isRunning
+        ? 'Docker installed but not running'
+        : `Docker ${version} running`,
+    installUrl: 'https://docs.docker.com/get-docker/',
+  }
+}
+
+export function checkGit(): PrerequisiteCheck {
+  const version = getVersion('git --version') ?? undefined
+
+  return {
+    name: 'Git',
+    required: true,
+    installed: !!version,
+    version,
+    message: version ? `Git ${version} installed` : 'Git not found',
+    installUrl: 'https://git-scm.com',
+  }
+}
+
+export function checkAllPrerequisites(): PrerequisiteCheck[] {
+  return [checkBun(), checkNode(), checkDocker(), checkGit()]
+}
+
+export function hasRequiredPrerequisites(checks: PrerequisiteCheck[]): boolean {
+  return checks.filter((c) => c.required).every((c) => c.installed)
+}