@o/cli 0.16.18 → 0.16.19-canary.1790191946359

package/src/tko/utils/env-categories.ts

@@ -0,0 +1,246 @@
+import pc from 'picocolors'
+
+import type { EnvVariable, EnvCategory } from '../types'
+
+export const envCategories: EnvCategory[] = [
+  {
+    id: 'core',
+    name: 'Core Configuration',
+    description: 'Essential configuration for your production deployment',
+    required: true,
+    variables: [
+      {
+        key: 'BETTER_AUTH_SECRET',
+        label: 'Authentication Secret',
+        description: 'Secret key for session encryption and JWT signing',
+        instructions: `Generate a secure random key:\n${pc.cyan('openssl rand -hex 32')}`,
+        required: true,
+        type: 'secret',
+        generator: () => {
+          const crypto = require('node:crypto')
+          return crypto.randomBytes(32).toString('hex')
+        },
+      },
+      {
+        key: 'BETTER_AUTH_URL',
+        label: 'Authentication URL',
+        description: 'The public URL where your app will be hosted',
+        instructions: 'Enter your production domain (e.g., https://your-app.com)',
+        required: true,
+        type: 'text',
+        placeholder: 'https://your-app.com',
+      },
+      {
+        key: 'ONE_SERVER_URL',
+        label: 'Server URL',
+        description: 'The URL for your main server',
+        instructions: 'Usually the same as your authentication URL',
+        required: true,
+        type: 'text',
+        placeholder: 'https://your-app.com',
+      },
+      {
+        key: 'VITE_ZERO_HOSTNAME',
+        label: 'Zero Sync Server Host',
+        description: 'Hostname for real-time sync server',
+        instructions:
+          'Just the hostname, e.g., zero.your-app.com (https:// assumed in production)',
+        required: true,
+        type: 'text',
+        placeholder: 'zero.your-app.com',
+      },
+    ],
+  },
+  {
+    id: 'database',
+    name: 'Database (PostgreSQL)',
+    description:
+      'Production database configuration - set by deployment platform (SST/uncloud)',
+    required: false,
+    variables: [
+      // Note: ZERO_UPSTREAM_DB, ZERO_CVR_DB, and ZERO_CHANGE_DB are set dynamically
+      // by the deployment platform (SST or uncloud) and should NOT be configured here
+    ],
+  },
+  {
+    id: 'storage',
+    name: 'File Storage (S3/R2)',
+    description: 'Object storage for user uploads and media files',
+    required: false,
+    variables: [
+      {
+        key: 'CLOUDFLARE_R2_ENDPOINT',
+        label: 'Storage Endpoint',
+        description: 'S3-compatible storage endpoint',
+        instructions: `Options:\n${pc.cyan('Cloudflare R2')}: https://[account-id].r2.cloudflarestorage.com\n${pc.cyan('AWS S3')}: https://s3.[region].amazonaws.com\n${pc.cyan('DigitalOcean Spaces')}: https://[region].digitaloceanspaces.com`,
+        required: false,
+        type: 'text',
+        placeholder: 'https://account-id.r2.cloudflarestorage.com',
+      },
+      {
+        key: 'CLOUDFLARE_R2_ACCESS_KEY',
+        label: 'Storage Access Key',
+        description: 'Access key ID for your storage service',
+        instructions: 'Get this from your storage provider dashboard',
+        required: false,
+        type: 'text',
+      },
+      {
+        key: 'CLOUDFLARE_R2_SECRET_KEY',
+        label: 'Storage Secret Key',
+        description: 'Secret access key for your storage service',
+        instructions: 'Keep this secure - it provides full access to your storage',
+        required: false,
+        type: 'secret',
+      },
+      {
+        key: 'CLOUDFLARE_R2_PUBLIC_URL',
+        label: 'Public Storage URL',
+        description: 'Public URL for serving stored files',
+        instructions: 'Usually a CDN URL or custom domain pointing to your bucket',
+        required: false,
+        type: 'text',
+        placeholder: 'https://cdn.your-app.com',
+      },
+    ],
+  },
+  {
+    id: 'apple',
+    name: 'Apple App Store',
+    description: 'Configuration for iOS app and push notifications',
+    required: false,
+    variables: [
+      {
+        key: 'APNS_TEAM_ID',
+        label: 'Apple Team ID',
+        description: 'Your Apple Developer Team ID',
+        instructions: `Find in Apple Developer Portal:\n1. Go to ${pc.cyan('https://developer.apple.com/account')}\n2. Look for "Team ID" in Membership Details`,
+        required: false,
+        type: 'text',
+        placeholder: 'XXXXXXXXXX',
+      },
+      {
+        key: 'APNS_KEY_ID',
+        label: 'APNs Key ID',
+        description: 'Push notification authentication key ID',
+        instructions: `Create in Apple Developer Portal:\n1. Go to Certificates, Identifiers & Profiles\n2. Keys → Create a Key\n3. Check "Apple Push Notifications service (APNs)"\n4. Download the .p8 file and note the Key ID`,
+        required: false,
+        type: 'text',
+        placeholder: 'XXXXXXXXXX',
+      },
+      {
+        key: 'APNS_KEY',
+        label: 'APNs Key Content',
+        description: 'Contents of your APNs .p8 key file',
+        instructions: 'Paste the entire contents of the .p8 file you downloaded',
+        required: false,
+        type: 'multiline',
+      },
+      {
+        key: 'APNS_ENDPOINT',
+        label: 'APNs Endpoint',
+        description: 'Apple Push Notification service endpoint',
+        instructions: `Production: ${pc.green('https://api.push.apple.com')}\nSandbox: ${pc.yellow('https://api.sandbox.push.apple.com')}`,
+        required: false,
+        type: 'text',
+        default: 'https://api.push.apple.com',
+      },
+    ],
+  },
+  {
+    id: 'email',
+    name: 'Email Service',
+    description: 'Transactional email configuration',
+    required: false,
+    variables: [
+      {
+        key: 'POSTMARK_SERVER_TOKEN',
+        label: 'Postmark Server Token',
+        description: 'API token for sending emails via Postmark',
+        instructions: `Get your token:\n1. Sign up at ${pc.cyan('https://postmarkapp.com')}\n2. Create a Server\n3. Go to Servers → API Tokens\n4. Copy your Server API Token\n\n${pc.yellow('Note: Free tier includes 100 emails/month')}`,
+        required: false,
+        type: 'text',
+      },
+    ],
+  },
+  {
+    id: 'github',
+    name: 'GitHub OAuth',
+    description: 'Enable GitHub sign-in for your app',
+    required: false,
+    variables: [
+      {
+        key: 'ONECHAT_GITHUB_CLIENT_ID',
+        label: 'GitHub OAuth Client ID',
+        description: 'Client ID for GitHub OAuth application',
+        instructions: `Create GitHub OAuth App:\n1. Go to ${pc.cyan('https://github.com/settings/developers')}\n2. New OAuth App\n3. Set Authorization callback URL:\n   ${pc.green('https://your-app.com/api/auth/callback/github')}\n4. Copy the Client ID`,
+        required: false,
+        type: 'text',
+      },
+      {
+        key: 'ONECHAT_GITHUB_CLIENT_SECRET',
+        label: 'GitHub OAuth Client Secret',
+        description: 'Client secret for GitHub OAuth application',
+        instructions: 'Copy the Client Secret from your GitHub OAuth App settings',
+        required: false,
+        type: 'secret',
+      },
+    ],
+  },
+  {
+    id: 'aws',
+    name: 'AWS Deployment',
+    description: 'AWS credentials for SST deployment',
+    required: false,
+    setupTime: '~30 minutes',
+    variables: [
+      {
+        key: 'AWS_ACCESS_KEY_ID',
+        label: 'AWS Access Key ID',
+        description: 'Access key for AWS deployment',
+        instructions: `${pc.yellow('⚠️  Setting up AWS takes about 30 minutes')}\n\nFollow the SST guide for AWS setup:\n${pc.cyan('https://sst.dev/docs/aws-accounts/')}\n\nQuick steps:\n1. Create AWS account or use existing\n2. Create IAM user with AdministratorAccess\n3. Generate access keys\n4. Copy Access Key ID`,
+        required: false,
+        type: 'text',
+      },
+      {
+        key: 'AWS_SECRET_ACCESS_KEY',
+        label: 'AWS Secret Access Key',
+        description: 'Secret key for AWS deployment',
+        instructions: 'Copy the Secret Access Key from IAM user creation',
+        required: false,
+        type: 'secret',
+      },
+      {
+        key: 'AWS_REGION',
+        label: 'AWS Region',
+        description: 'AWS region for deployment',
+        instructions:
+          'Choose a region close to your users (e.g., us-west-1, us-east-1, eu-west-1)',
+        required: false,
+        type: 'text',
+        default: 'us-west-1',
+        placeholder: 'us-west-1',
+      },
+    ],
+  },
+]
+
+export function getCategoryById(id: string): EnvCategory | undefined {
+  return envCategories.find((cat) => cat.id === id)
+}
+
+export function getRequiredCategories(): EnvCategory[] {
+  return envCategories.filter((cat) => cat.required)
+}
+
+export function getOptionalCategories(): EnvCategory[] {
+  return envCategories.filter((cat) => !cat.required)
+}
+
+export function getAllVariables(): EnvVariable[] {
+  return envCategories.flatMap((cat) => cat.variables)
+}
+
+export function getVariableByKey(key: string): EnvVariable | undefined {
+  return getAllVariables().find((v) => v.key === key)
+}

package/src/tko/utils/env-setup.ts

@@ -0,0 +1,335 @@
+import { writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import * as clack from '@clack/prompts'
+import pc from 'picocolors'
+
+import { copyEnvFile, envFileExists, readEnvVariable, updateEnvVariable } from './env'
+import { envCategories } from './env-categories'
+
+import type { EnvCategory, EnvVariable } from '../types'
+
+interface SetupOptions {
+  skipOptional?: boolean
+  envFile?: string
+  onlyCategory?: string
+  interactive?: boolean
+}
+
+export async function setupProductionEnv(
+  cwd: string,
+  options: SetupOptions = {}
+): Promise<boolean> {
+  const envFile = options.envFile || '.env.production'
+  const fullPath = resolve(cwd, envFile)
+
+  // set up interrupt handler
+  const cleanup = () => {
+    console.info('\n' + pc.yellow('Setup interrupted. You can resume anytime with:'))
+    console.info(pc.cyan('  bun takeout env:setup'))
+    console.info(
+      pc.gray('\nNote: All environment variables are optional for local development.')
+    )
+    process.exit(0)
+  }
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+
+  try {
+    clack.intro(pc.bgCyan(pc.black(' Production Environment Setup ')))
+
+    console.info(pc.gray('All environment variables are optional.'))
+    console.info(pc.gray('You can skip any section or re-run this setup anytime.\n'))
+
+    // check if .env.production exists, if not create from example
+    if (!envFileExists(cwd, envFile)) {
+      const createFile = await clack.confirm({
+        message: `${envFile} doesn't exist. Create it from example?`,
+        initialValue: true,
+      })
+
+      if (clack.isCancel(createFile) || !createFile) {
+        clack.cancel('Setup cancelled')
+        process.removeListener('SIGINT', cleanup)
+        process.removeListener('SIGTERM', cleanup)
+        return false
+      }
+
+      const exampleFile = '.env.production.example'
+      if (envFileExists(cwd, exampleFile)) {
+        copyEnvFile(cwd, exampleFile, envFile)
+        console.info(pc.green(`✓ Created ${envFile} from example\n`))
+      } else {
+        // create empty file
+        writeFileSync(fullPath, '# Production Environment Variables\n')
+        console.info(pc.green(`✓ Created empty ${envFile}\n`))
+      }
+    }
+
+    // filter categories if specific one requested
+    let categoriesToSetup = options.onlyCategory
+      ? envCategories.filter((cat) => cat.id === options.onlyCategory)
+      : envCategories
+
+    if (categoriesToSetup.length === 0) {
+      clack.cancel(`Category "${options.onlyCategory}" not found`)
+      process.removeListener('SIGINT', cleanup)
+      process.removeListener('SIGTERM', cleanup)
+      return false
+    }
+
+    // ask about setting up production env
+    if (options.interactive !== false && !options.onlyCategory) {
+      const setupProd = await clack.confirm({
+        message: 'Do you want to set up production environment variables?',
+        initialValue: false,
+      })
+
+      if (clack.isCancel(setupProd) || !setupProd) {
+        clack.note(
+          `You can set up production environment later with:\n${pc.cyan('bun takeout env:setup')}`,
+          pc.yellow('Skipping production setup')
+        )
+        process.removeListener('SIGINT', cleanup)
+        process.removeListener('SIGTERM', cleanup)
+        return true
+      }
+    }
+
+    // process each category
+    for (const category of categoriesToSetup) {
+      const shouldSetup = await setupCategory(category, envFile, cwd, options)
+      if (!shouldSetup) {
+        continue
+      }
+    }
+
+    // summary
+    const configuredVars: string[] = []
+    const skippedVars: string[] = []
+
+    for (const category of categoriesToSetup) {
+      for (const variable of category.variables) {
+        const value = readEnvVariable(cwd, variable.key, envFile)
+        if (value && value !== '' && !value.includes('your-')) {
+          configuredVars.push(variable.key)
+        } else if (variable.required) {
+          skippedVars.push(variable.key)
+        }
+      }
+    }
+
+    if (configuredVars.length > 0) {
+      clack.outro(pc.green('✓ Environment setup complete!'))
+      console.info(
+        pc.gray(`\nConfigured ${configuredVars.length} variables in ${envFile}`)
+      )
+
+      if (skippedVars.length > 0) {
+        console.info(
+          pc.yellow(
+            `\nNote: Some required variables were skipped. You'll need to configure these before deploying:`
+          )
+        )
+        skippedVars.forEach((v) => console.info(pc.gray(`  - ${v}`)))
+      }
+
+      console.info(pc.cyan('\nYou can re-run this setup anytime with:'))
+      console.info(pc.gray('  bun takeout env:setup'))
+      console.info(pc.cyan('\nOr set up specific categories:'))
+      console.info(pc.gray('  bun takeout env:setup --category aws'))
+      console.info(pc.gray('  bun takeout env:setup --category apple'))
+    } else {
+      clack.outro(pc.yellow('No variables configured'))
+      console.info(pc.gray('\nYou can re-run this setup anytime with:'))
+      console.info(pc.gray('  bun takeout env:setup'))
+    }
+
+    process.removeListener('SIGINT', cleanup)
+    process.removeListener('SIGTERM', cleanup)
+    return true
+  } catch (error) {
+    process.removeListener('SIGINT', cleanup)
+    process.removeListener('SIGTERM', cleanup)
+    if (error instanceof Error && error.message.includes('cancelled')) {
+      return false
+    }
+    throw error
+  }
+}
+
+async function setupCategory(
+  category: EnvCategory,
+  envFile: string,
+  cwd: string,
+  options: SetupOptions
+): Promise<boolean> {
+  const spinner = clack.spinner()
+
+  // build category prompt message
+  let message = `Set up ${pc.bold(category.name)}?`
+  if (!category.required) {
+    message += pc.gray(' (optional)')
+  }
+  if (category.setupTime) {
+    message += pc.yellow(` ${category.setupTime}`)
+  }
+
+  console.info('') // add spacing
+  const setupCategory = await clack.confirm({
+    message,
+    initialValue: category.required,
+  })
+
+  if (clack.isCancel(setupCategory) || !setupCategory) {
+    console.info(pc.gray(`  Skipping ${category.name}`))
+    return false
+  }
+
+  console.info(pc.gray(`\n${category.description}\n`))
+
+  // process each variable in the category
+  for (const variable of category.variables) {
+    await setupVariable(variable, envFile, cwd)
+  }
+
+  return true
+}
+
+async function setupVariable(
+  variable: EnvVariable,
+  envFile: string,
+  cwd: string
+): Promise<void> {
+  // check if already configured
+  const existingValue = readEnvVariable(cwd, variable.key, envFile)
+  const hasValue =
+    existingValue && existingValue !== '' && !existingValue.includes('your-')
+
+  console.info('') // spacing
+  console.info(pc.bold(variable.label))
+  console.info(pc.gray(variable.description))
+
+  if (hasValue) {
+    const update = await clack.confirm({
+      message: `${pc.green('✓')} Already configured. Update?`,
+      initialValue: false,
+    })
+
+    if (clack.isCancel(update) || !update) {
+      return
+    }
+  }
+
+  // show instructions
+  console.info('')
+  console.info(pc.cyan('Instructions:'))
+  variable.instructions.split('\n').forEach((line) => {
+    console.info(pc.gray(`  ${line}`))
+  })
+  console.info('')
+
+  // handle different input types
+  let value: string | undefined
+
+  if (variable.generator) {
+    const generate = await clack.confirm({
+      message: `Generate ${variable.label} automatically?`,
+      initialValue: true,
+    })
+
+    if (!clack.isCancel(generate) && generate) {
+      value = variable.generator()
+      console.info(pc.green(`✓ Generated ${variable.label}`))
+    }
+  }
+
+  if (!value) {
+    if (variable.type === 'multiline') {
+      console.info(pc.gray('Paste content (press Enter twice when done):'))
+      value = await readMultilineInput()
+    } else if (variable.type === 'secret') {
+      const result = await clack.password({
+        message: `Enter ${variable.label}:`,
+        mask: '*',
+      })
+      if (!clack.isCancel(result)) {
+        value = result
+      }
+    } else {
+      const result = await clack.text({
+        message: `Enter ${variable.label}:`,
+        placeholder: variable.placeholder,
+        defaultValue: variable.default,
+        validate: (val) => {
+          if (variable.required && !val) {
+            return 'This field is required'
+          }
+          return undefined
+        },
+      })
+      if (!clack.isCancel(result)) {
+        value = result
+      }
+    }
+  }
+
+  if (value && !clack.isCancel(value)) {
+    updateEnvVariable(cwd, variable.key, value, envFile)
+    console.info(pc.green(`✓ Saved ${variable.key}`))
+  } else if (variable.required) {
+    console.info(pc.yellow(`⚠ Skipped required variable: ${variable.key}`))
+  } else {
+    console.info(pc.gray(`  Skipped ${variable.key}`))
+  }
+}
+
+async function readMultilineInput(): Promise<string> {
+  return new Promise((resolve) => {
+    const lines: string[] = []
+    let emptyLineCount = 0
+
+    const reader = process.stdin
+    reader.setEncoding('utf8')
+
+    const onData = (chunk: string) => {
+      const chunkLines = chunk.split('\n')
+      for (const line of chunkLines) {
+        if (line === '') {
+          emptyLineCount++
+          if (emptyLineCount >= 2) {
+            reader.removeListener('data', onData)
+            resolve(lines.join('\n'))
+            return
+          }
+        } else {
+          if (emptyLineCount === 1) {
+            lines.push('') // add the single empty line
+          }
+          emptyLineCount = 0
+          lines.push(line)
+        }
+      }
+    }
+
+    reader.on('data', onData)
+  })
+}
+
+export function listCategories(): void {
+  console.info(pc.bold('\nAvailable environment categories:\n'))
+
+  for (const category of envCategories) {
+    const status = category.required ? pc.red('required') : pc.gray('optional')
+    console.info(`  ${pc.cyan(category.id.padEnd(12))} - ${category.name} ${status}`)
+    console.info(`  ${pc.gray(category.description)}`)
+    if (category.setupTime) {
+      console.info(`  ${pc.yellow(category.setupTime)}`)
+    }
+    console.info('')
+  }
+
+  console.info(pc.gray('Run setup for a specific category:'))
+  console.info(pc.cyan('  bun takeout env:setup --category <id>\n'))
+}

package/src/tko/utils/env.ts

@@ -0,0 +1,127 @@
+/**
+ * Environment file operations
+ */
+
+import { randomBytes } from 'node:crypto'
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export function generateSecret(length = 32): string {
+  return randomBytes(length).toString('hex')
+}
+
+export function envFileExists(cwd: string, filename = '.env'): boolean {
+  return existsSync(join(cwd, filename))
+}
+
+export function copyEnvFile(
+  cwd: string,
+  source: string,
+  target: string
+): { success: boolean; error?: string } {
+  const sourcePath = join(cwd, source)
+  const targetPath = join(cwd, target)
+
+  if (!existsSync(sourcePath)) {
+    return { success: false, error: `Source file ${source} not found` }
+  }
+
+  if (existsSync(targetPath)) {
+    return { success: false, error: `Target file ${target} already exists` }
+  }
+
+  try {
+    copyFileSync(sourcePath, targetPath)
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+export function updateEnvVariable(
+  cwd: string,
+  key: string,
+  value: string,
+  filename = '.env'
+): { success: boolean; error?: string } {
+  const envPath = join(cwd, filename)
+
+  if (!existsSync(envPath)) {
+    return { success: false, error: `${filename} not found` }
+  }
+
+  try {
+    let content = readFileSync(envPath, 'utf-8')
+
+    // Check if key exists
+    const keyRegex = new RegExp(`^${key}=.*$`, 'm')
+
+    if (keyRegex.test(content)) {
+      // Replace existing value
+      content = content.replace(keyRegex, `${key}=${value}`)
+    } else {
+      // Append new key-value
+      content = content.trimEnd() + `\n${key}=${value}\n`
+    }
+
+    writeFileSync(envPath, content, 'utf-8')
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+export function createEnvLocal(cwd: string): { success: boolean; error?: string } {
+  const envLocalPath = join(cwd, '.env.local')
+
+  if (existsSync(envLocalPath)) {
+    return { success: true } // Already exists, that's fine
+  }
+
+  const template = `# Local environment overrides
+# This file is gitignored and never committed
+# Add your personal secrets and local configuration here
+# These values override .env
+
+# Example:
+# BETTER_AUTH_SECRET=your-secret-here
+# AWS_ACCESS_KEY_ID=your-key-here
+`
+
+  try {
+    writeFileSync(envLocalPath, template, 'utf-8')
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+export function readEnvVariable(
+  cwd: string,
+  key: string,
+  filename = '.env'
+): string | null {
+  const envPath = join(cwd, filename)
+
+  if (!existsSync(envPath)) {
+    return null
+  }
+
+  try {
+    const content = readFileSync(envPath, 'utf-8')
+    const keyRegex = new RegExp(`^${key}=(.*)$`, 'm')
+    const match = content.match(keyRegex)
+    return match?.[1]?.trim().replace(/^["']|["']$/g, '') || null
+  } catch {
+    return null
+  }
+}