dotdo 0.0.1 → 0.1.0

package/cli/commands/deploy-multi.ts

@@ -0,0 +1,245 @@
+/**
+ * Deploy Command
+ *
+ * Deploys to multiple targets:
+ * - Cloudflare Workers (default)
+ * - Vercel Edge Functions
+ * - Fly.io
+ */
+
+import { Command } from 'commander'
+import { createLogger } from '../utils/logger'
+import { loadConfigAsync, findProjectRoot } from '../utils/config'
+import { spawn } from 'child_process'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const logger = createLogger('deploy')
+
+type DeployTarget = 'cloudflare' | 'vercel' | 'fly'
+
+interface DeployResult {
+  success: boolean
+  url?: string
+  error?: string
+}
+
+/**
+ * Deploy to Cloudflare Workers
+ */
+async function deployCloudflare(): Promise<DeployResult> {
+  logger.info('Deploying to Cloudflare Workers...')
+
+  return new Promise((resolve) => {
+    const proc = spawn('bunx', ['wrangler', 'deploy'], {
+      stdio: 'inherit',
+      env: process.env,
+    })
+
+    proc.on('exit', (code) => {
+      if (code === 0) {
+        resolve({ success: true })
+      } else {
+        resolve({ success: false, error: `wrangler exited with code ${code}` })
+      }
+    })
+
+    proc.on('error', (error) => {
+      resolve({ success: false, error: error.message })
+    })
+  })
+}
+
+/**
+ * Generate Vercel configuration
+ */
+function generateVercelConfig(projectRoot: string): void {
+  const vercelConfig = {
+    buildCommand: 'bun run build',
+    outputDirectory: 'dist',
+    framework: null,
+    functions: {
+      'api/**/*.ts': {
+        runtime: 'edge',
+      },
+    },
+  }
+
+  const configPath = path.join(projectRoot, 'vercel.json')
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, JSON.stringify(vercelConfig, null, 2))
+    logger.info('Created vercel.json')
+  }
+}
+
+/**
+ * Deploy to Vercel
+ */
+async function deployVercel(): Promise<DeployResult> {
+  logger.info('Deploying to Vercel...')
+
+  const projectRoot = findProjectRoot()
+  generateVercelConfig(projectRoot)
+
+  return new Promise((resolve) => {
+    const proc = spawn('bunx', ['vercel', '--prod'], {
+      stdio: 'inherit',
+      env: process.env,
+    })
+
+    proc.on('exit', (code) => {
+      if (code === 0) {
+        resolve({ success: true })
+      } else {
+        resolve({ success: false, error: `vercel exited with code ${code}` })
+      }
+    })
+
+    proc.on('error', (error) => {
+      resolve({ success: false, error: error.message })
+    })
+  })
+}
+
+/**
+ * Generate Fly.io configuration
+ */
+function generateFlyConfig(projectRoot: string, appName: string): void {
+  const flyConfig = `
+# fly.toml - Fly.io configuration
+# Generated by dotdo CLI
+
+app = "${appName}"
+primary_region = "iad"
+
+[build]
+  builder = "paketobuildpacks/builder:base"
+
+[env]
+  NODE_ENV = "production"
+
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+
+[[vm]]
+  cpu_kind = "shared"
+  cpus = 1
+  memory_mb = 256
+`.trim()
+
+  const configPath = path.join(projectRoot, 'fly.toml')
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, flyConfig)
+    logger.info('Created fly.toml')
+  }
+}
+
+/**
+ * Deploy to Fly.io
+ */
+async function deployFly(appName?: string): Promise<DeployResult> {
+  logger.info('Deploying to Fly.io...')
+
+  const projectRoot = findProjectRoot()
+  const name = appName ?? path.basename(projectRoot)
+  generateFlyConfig(projectRoot, name)
+
+  return new Promise((resolve) => {
+    const proc = spawn('flyctl', ['deploy'], {
+      stdio: 'inherit',
+      env: process.env,
+    })
+
+    proc.on('exit', (code) => {
+      if (code === 0) {
+        resolve({ success: true })
+      } else {
+        resolve({ success: false, error: `flyctl exited with code ${code}` })
+      }
+    })
+
+    proc.on('error', (error) => {
+      resolve({ success: false, error: error.message })
+    })
+  })
+}
+
+export const deployCommand = new Command('deploy')
+  .description('Deploy to production')
+  .option('-t, --target <target>', 'Deploy target (cloudflare, vercel, fly)', 'cloudflare')
+  .option('--all', 'Deploy to all configured targets')
+  .option('--dry-run', 'Show what would be deployed')
+  .option('-n, --name <name>', 'App name (for fly.io)')
+  .action(async (options) => {
+    const config = await loadConfigAsync()
+
+    // Determine targets
+    let targets: DeployTarget[] = []
+
+    if (options.all) {
+      // Deploy to all configured targets
+      if (config.deploy?.cloudflare !== false) targets.push('cloudflare')
+      if (config.deploy?.vercel) targets.push('vercel')
+      if (config.deploy?.fly) targets.push('fly')
+    } else {
+      targets = [options.target as DeployTarget]
+    }
+
+    if (targets.length === 0) {
+      targets = ['cloudflare'] // Default
+    }
+
+    logger.info(`Deploying to: ${targets.join(', ')}`)
+
+    if (options.dryRun) {
+      logger.info('Dry run - no actual deployment')
+      return
+    }
+
+    const results: Record<DeployTarget, DeployResult> = {} as Record<DeployTarget, DeployResult>
+
+    for (const target of targets) {
+      switch (target) {
+        case 'cloudflare':
+          results[target] = await deployCloudflare()
+          break
+        case 'vercel':
+          results[target] = await deployVercel()
+          break
+        case 'fly':
+          results[target] = await deployFly(options.name)
+          break
+        default:
+          logger.error(`Unknown target: ${target}`)
+          results[target] = { success: false, error: `Unknown target: ${target}` }
+      }
+    }
+
+    // Summary
+    console.log()
+    console.log('Deployment Summary')
+    console.log('─'.repeat(40))
+
+    let allSuccess = true
+    for (const [target, result] of Object.entries(results)) {
+      if (result.success) {
+        logger.success(`${target}: Deployed successfully`)
+        if (result.url) {
+          console.log(`  URL: ${result.url}`)
+        }
+      } else {
+        logger.error(`${target}: Failed - ${result.error}`)
+        allSuccess = false
+      }
+    }
+
+    if (!allSuccess) {
+      process.exit(1)
+    }
+  })
+
+export default deployCommand

package/cli/commands/dev/deploy.ts

@@ -0,0 +1,100 @@
+/**
+ * Deploy Command
+ *
+ * Deploys to Cloudflare Workers using wrangler deploy.
+ * Authenticates via oauth.do and passes DO_TOKEN to the spawned process.
+ */
+
+import { ensureLoggedIn } from 'oauth.do/node'
+
+export const name = 'deploy'
+export const description = 'Deploy to Cloudflare Workers'
+
+interface SpawnOptions {
+  env?: Record<string, string | undefined>
+  stdio?: ['inherit' | 'pipe', 'inherit' | 'pipe', 'inherit' | 'pipe'] | 'inherit'
+  cwd?: string
+}
+
+interface SpawnedProcess {
+  pid: number
+  exited: Promise<number>
+  kill: (signal?: number) => void
+  stdout?: ReadableStream<Uint8Array>
+  stderr?: ReadableStream<Uint8Array>
+}
+
+type SpawnFn = (command: string[], options?: SpawnOptions) => SpawnedProcess
+
+interface RunOptions {
+  spawn?: SpawnFn
+  apiUrl?: string
+}
+
+interface RunResult {
+  exitCode: number
+  success: boolean
+}
+
+export async function run(args: string[], options: RunOptions = {}): Promise<RunResult> {
+  const spawnFn = options.spawn ?? defaultSpawn
+
+  // Authenticate first
+  let token: string
+  try {
+    const result = await ensureLoggedIn({
+      openBrowser: true,
+      print: console.log,
+    })
+    token = result.token
+
+    if (result.isNewLogin) {
+      console.log('Logged in successfully')
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error('Authentication error:', message)
+    throw new Error(`Authentication failed: ${message}`)
+  }
+
+  console.log('Deploying...')
+
+  // Build environment with token
+  const env: Record<string, string | undefined> = {
+    ...process.env,
+    DO_TOKEN: token,
+  }
+
+  if (options.apiUrl) {
+    env.DO_API_URL = options.apiUrl
+  }
+
+  // Spawn wrangler deploy
+  let proc: SpawnedProcess
+  try {
+    proc = spawnFn(['bunx', 'wrangler', 'deploy', ...args], {
+      env,
+      stdio: ['inherit', 'inherit', 'inherit'],
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error('Failed to start wrangler. Please ensure wrangler is installed.')
+    throw error
+  }
+
+  const exitCode = await proc.exited
+  const success = exitCode === 0
+
+  if (success) {
+    console.log('Deployment completed successfully')
+  } else {
+    console.error('Deployment failed with exit code:', exitCode)
+  }
+
+  return { exitCode, success }
+}
+
+function defaultSpawn(command: string[], options?: SpawnOptions): SpawnedProcess {
+  // This will be replaced by Bun.spawn in production
+  throw new Error('No spawn function provided')
+}

package/cli/commands/dev/dev.ts

@@ -0,0 +1,95 @@
+/**
+ * Dev Command
+ *
+ * Starts local development server using wrangler dev.
+ * Authenticates via oauth.do and passes DO_TOKEN to the spawned process.
+ */
+
+import { ensureLoggedIn } from 'oauth.do/node'
+
+export const name = 'dev'
+export const description = 'Start local development server'
+
+interface SpawnOptions {
+  env?: Record<string, string | undefined>
+  stdio?: ['inherit' | 'pipe', 'inherit' | 'pipe', 'inherit' | 'pipe'] | 'inherit'
+  cwd?: string
+}
+
+interface SpawnedProcess {
+  pid: number
+  exited: Promise<number>
+  kill: (signal?: number) => void
+  stdout?: ReadableStream<Uint8Array>
+  stderr?: ReadableStream<Uint8Array>
+}
+
+type SpawnFn = (command: string[], options?: SpawnOptions) => SpawnedProcess
+
+interface RunOptions {
+  spawn?: SpawnFn
+  apiUrl?: string
+}
+
+interface RunResult {
+  exitCode: number
+}
+
+export async function run(args: string[], options: RunOptions = {}): Promise<RunResult> {
+  const spawnFn = options.spawn ?? defaultSpawn
+
+  // Authenticate first
+  let token: string
+  try {
+    const result = await ensureLoggedIn({
+      openBrowser: true,
+      print: console.log,
+    })
+    token = result.token
+
+    if (result.isNewLogin) {
+      console.log('Logged in successfully')
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    if (message.toLowerCase().includes('network')) {
+      console.error('Network connection error. Please check your internet connection.')
+    } else {
+      console.error('Authentication error:', message)
+    }
+    throw new Error(`Authentication failed: ${message}`)
+  }
+
+  console.log('Starting dev server...')
+
+  // Build environment with token
+  const env: Record<string, string | undefined> = {
+    ...process.env,
+    DO_TOKEN: token,
+  }
+
+  if (options.apiUrl) {
+    env.DO_API_URL = options.apiUrl
+  }
+
+  // Spawn wrangler dev
+  let proc: SpawnedProcess
+  try {
+    proc = spawnFn(['bunx', 'wrangler', 'dev', ...args], {
+      env,
+      stdio: ['inherit', 'inherit', 'inherit'],
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error('Failed to start wrangler. Please ensure wrangler is installed.')
+    throw error
+  }
+
+  const exitCode = await proc.exited
+  return { exitCode }
+}
+
+function defaultSpawn(command: string[], options?: SpawnOptions): SpawnedProcess {
+  // This will be replaced by Bun.spawn in production
+  throw new Error('No spawn function provided')
+}

package/cli/commands/dev/logs.ts

@@ -0,0 +1,91 @@
+/**
+ * Logs Command
+ *
+ * Streams live logs from Cloudflare Workers using wrangler tail.
+ * Authenticates via oauth.do and passes DO_TOKEN to the spawned process.
+ */
+
+import { ensureLoggedIn } from 'oauth.do/node'
+
+export const name = 'logs'
+export const description = 'Stream live logs from Cloudflare Workers'
+
+interface SpawnOptions {
+  env?: Record<string, string | undefined>
+  stdio?: ['inherit' | 'pipe', 'inherit' | 'pipe', 'inherit' | 'pipe'] | 'inherit'
+  cwd?: string
+}
+
+interface SpawnedProcess {
+  pid: number
+  exited: Promise<number>
+  kill: (signal?: number) => void
+  stdout?: ReadableStream<Uint8Array>
+  stderr?: ReadableStream<Uint8Array>
+}
+
+type SpawnFn = (command: string[], options?: SpawnOptions) => SpawnedProcess
+
+interface RunOptions {
+  spawn?: SpawnFn
+  apiUrl?: string
+}
+
+interface RunResult {
+  exitCode: number
+}
+
+export async function run(args: string[], options: RunOptions = {}): Promise<RunResult> {
+  const spawnFn = options.spawn ?? defaultSpawn
+
+  // Authenticate first
+  let token: string
+  try {
+    const result = await ensureLoggedIn({
+      openBrowser: true,
+      print: console.log,
+    })
+    token = result.token
+
+    if (result.isNewLogin) {
+      console.log('Logged in successfully')
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error('Authentication error:', message)
+    throw new Error(`Authentication failed: ${message}`)
+  }
+
+  console.log('Connecting to logs stream...')
+
+  // Build environment with token
+  const env: Record<string, string | undefined> = {
+    ...process.env,
+    DO_TOKEN: token,
+  }
+
+  if (options.apiUrl) {
+    env.DO_API_URL = options.apiUrl
+  }
+
+  // Spawn wrangler tail
+  let proc: SpawnedProcess
+  try {
+    proc = spawnFn(['bunx', 'wrangler', 'tail', ...args], {
+      env,
+      stdio: ['inherit', 'inherit', 'inherit'],
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error('Failed to start wrangler. Please ensure wrangler is installed.')
+    throw error
+  }
+
+  const exitCode = await proc.exited
+  return { exitCode }
+}
+
+function defaultSpawn(command: string[], options?: SpawnOptions): SpawnedProcess {
+  // This will be replaced by Bun.spawn in production
+  throw new Error('No spawn function provided')
+}

package/cli/commands/dev-local.ts

@@ -0,0 +1,88 @@
+/**
+ * Dev Command
+ *
+ * Starts local development server with embedded DO runtime.
+ * Uses Miniflare for full Durable Object support locally.
+ */
+
+import { Command } from 'commander'
+import { createAdapter } from '../runtime/miniflare-adapter'
+import { createLogger } from '../utils/logger'
+import { loadConfigAsync } from '../utils/config'
+import { startTunnel } from './tunnel'
+
+const logger = createLogger('dev')
+
+export const devCommand = new Command('dev')
+  .description('Start local development runtime')
+  .option('-p, --port <port>', 'Port to listen on', '8787')
+  .option('--host <host>', 'Host to bind to', 'localhost')
+  .option('--tunnel', 'Expose via Cloudflare Tunnel')
+  .option('--tunnel-name <name>', 'Custom tunnel name')
+  .option('--no-persist', 'Disable state persistence')
+  .option('--persist <path>', 'Custom persistence path')
+  .option('--inspect', 'Enable V8 inspector')
+  .option('--live-reload', 'Enable live reload on file changes', true)
+  .option('-c, --config <path>', 'Path to config file')
+  .action(async (options) => {
+    const config = await loadConfigAsync()
+
+    const port = parseInt(options.port, 10)
+    const host = options.host
+
+    logger.info(`Starting development server...`)
+    logger.debug('Options:', { port, host, tunnel: options.tunnel, persist: options.persist })
+
+    // Create Miniflare adapter
+    const adapter = createAdapter({
+      logger,
+      config,
+      persist: options.persist === false ? false : options.persist ?? config.persist,
+    })
+
+    try {
+      // Start the runtime
+      const instance = await adapter.start({
+        port,
+        host,
+        live: options.liveReload,
+      })
+
+      console.log()
+      console.log(`  Local:   ${instance.url}`)
+
+      // Start tunnel if requested
+      if (options.tunnel) {
+        const tunnelUrl = await startTunnel({
+          port,
+          name: options.tunnelName,
+          logger,
+        })
+        console.log(`  Tunnel:  ${tunnelUrl}`)
+      }
+
+      console.log()
+      console.log('  Press Ctrl+C to stop')
+      console.log()
+
+      // Handle shutdown
+      const shutdown = async () => {
+        console.log('\nShutting down...')
+        await instance.stop()
+        process.exit(0)
+      }
+
+      process.on('SIGINT', shutdown)
+      process.on('SIGTERM', shutdown)
+
+      // Keep process alive
+      await new Promise(() => {})
+    } catch (error) {
+      logger.error('Failed to start dev server', {
+        error: error instanceof Error ? error.message : String(error),
+      })
+      process.exit(1)
+    }
+  })
+
+export default devCommand