dotdo 0.0.2 → 0.1.0

package/cli/runtime/miniflare-adapter.ts

@@ -0,0 +1,162 @@
+/**
+ * Miniflare Adapter
+ *
+ * Wraps Miniflare for local DO runtime with full feature support.
+ * Provides DO isolation, SQLite storage, and RPC bridging.
+ */
+
+import type { Miniflare, MiniflareOptions, DurableObjectNamespace } from 'miniflare'
+import { Logger, createLogger } from '../utils/logger'
+import { loadConfig, type DotdoConfig } from '../utils/config'
+import { DORegistry } from './do-registry'
+import { EmbeddedDB } from './embedded-db'
+
+export interface MiniflareAdapterOptions {
+  port?: number
+  config?: DotdoConfig
+  logger?: Logger
+  modules?: boolean
+  persist?: boolean | string
+  durableObjects?: Record<string, { className: string; scriptName?: string }>
+}
+
+export interface RunningInstance {
+  miniflare: Miniflare
+  port: number
+  url: string
+  stop: () => Promise<void>
+}
+
+/**
+ * Creates and configures Miniflare for local DO development
+ */
+export class MiniflareAdapter {
+  private miniflare: Miniflare | null = null
+  private logger: Logger
+  private config: DotdoConfig
+  private registry: DORegistry
+  private db: EmbeddedDB
+
+  constructor(options: MiniflareAdapterOptions = {}) {
+    this.logger = options.logger ?? createLogger('miniflare')
+    this.config = options.config ?? loadConfig()
+    this.registry = new DORegistry({ logger: this.logger })
+    this.db = new EmbeddedDB({ logger: this.logger, persist: options.persist })
+  }
+
+  /**
+   * Discover Durable Object classes from the project
+   */
+  async discoverDOs(): Promise<Record<string, { className: string }>> {
+    return this.registry.discover(this.config.srcDir ?? '.')
+  }
+
+  /**
+   * Build Miniflare options from config and discovered DOs
+   */
+  async buildOptions(overrides: Partial<MiniflareOptions> = {}): Promise<MiniflareOptions> {
+    const durableObjects = await this.discoverDOs()
+
+    const baseOptions: MiniflareOptions = {
+      modules: true,
+      script: this.config.entryPoint ?? 'index.ts',
+      port: this.config.port ?? 8787,
+
+      // Durable Object configuration
+      durableObjects,
+
+      // SQLite-backed DO storage
+      d1Databases: {
+        DB: this.db.getPath(),
+      },
+
+      // R2 for blob storage (local filesystem)
+      r2Buckets: ['BUCKET'],
+
+      // KV for simple key-value
+      kvNamespaces: ['KV'],
+
+      // Compatibility flags
+      compatibilityDate: this.config.compatibilityDate ?? '2024-01-01',
+      compatibilityFlags: this.config.compatibilityFlags ?? ['nodejs_compat'],
+
+      // Live reload on file changes
+      live: true,
+    }
+
+    return { ...baseOptions, ...overrides }
+  }
+
+  /**
+   * Start the Miniflare runtime
+   */
+  async start(options: Partial<MiniflareOptions> = {}): Promise<RunningInstance> {
+    if (this.miniflare) {
+      throw new Error('Miniflare already running')
+    }
+
+    // Dynamic import to avoid bundling issues
+    const { Miniflare } = await import('miniflare')
+
+    const mfOptions = await this.buildOptions(options)
+    this.logger.info('Starting Miniflare...', { port: mfOptions.port })
+
+    this.miniflare = new Miniflare(mfOptions)
+    await this.miniflare.ready
+
+    const port = mfOptions.port as number
+    const url = `http://localhost:${port}`
+
+    this.logger.success(`Miniflare running at ${url}`)
+
+    return {
+      miniflare: this.miniflare,
+      port,
+      url,
+      stop: () => this.stop(),
+    }
+  }
+
+  /**
+   * Stop the Miniflare runtime
+   */
+  async stop(): Promise<void> {
+    if (this.miniflare) {
+      this.logger.info('Stopping Miniflare...')
+      await this.miniflare.dispose()
+      this.miniflare = null
+      this.logger.success('Miniflare stopped')
+    }
+  }
+
+  /**
+   * Get a Durable Object namespace from the running instance
+   */
+  async getNamespace(name: string): Promise<DurableObjectNamespace | null> {
+    if (!this.miniflare) {
+      throw new Error('Miniflare not running')
+    }
+    return this.miniflare.getDurableObjectNamespace(name)
+  }
+
+  /**
+   * Get direct access to embedded DB for DO operations
+   */
+  getDB(): EmbeddedDB {
+    return this.db
+  }
+
+  /**
+   * Get the DO registry
+   */
+  getRegistry(): DORegistry {
+    return this.registry
+  }
+}
+
+/**
+ * Create a new Miniflare adapter instance
+ */
+export function createAdapter(options?: MiniflareAdapterOptions): MiniflareAdapter {
+  return new MiniflareAdapter(options)
+}

package/cli/sandbox.ts

@@ -0,0 +1,82 @@
+/**
+ * Miniflare Code Sandbox (TDD Stub - Not Yet Implemented)
+ *
+ * This module provides code execution in an isolated Miniflare sandbox.
+ * Currently exports stubs for TDD RED phase testing.
+ *
+ * @see cli/tests/sandbox.test.ts for test specifications
+ */
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+
+export type FileType = 'js' | 'ts' | 'jsx' | 'tsx' | 'mdx' | 'md'
+
+export interface SandboxConfig {
+  timeout?: number
+  memoryLimit?: number
+}
+
+export interface SandboxResult {
+  success: boolean
+  value?: unknown
+  error?: string
+  logs: Array<{
+    level: 'log' | 'error' | 'warn' | 'info' | 'debug'
+    args: unknown[]
+  }>
+  executionTime?: number
+}
+
+export interface Sandbox {
+  run(code: string, fileType?: FileType): Promise<SandboxResult>
+  dispose(): Promise<void>
+}
+
+// ============================================================================
+// Stub Implementations (RED Phase - Not Yet Implemented)
+// ============================================================================
+
+/**
+ * Execute code in a Miniflare sandbox
+ * @stub Not yet implemented - will fail tests
+ */
+export async function runInSandbox(
+  _code: string,
+  _fileType: FileType = 'ts',
+  _config?: SandboxConfig
+): Promise<SandboxResult> {
+  // Stub implementation - returns failure for all tests
+  throw new Error('runInSandbox not implemented yet - TDD RED phase')
+}
+
+/**
+ * Create a reusable sandbox instance
+ * @stub Not yet implemented - will fail tests
+ */
+export async function createSandbox(_config?: SandboxConfig): Promise<Sandbox> {
+  // Stub implementation - returns failure for all tests
+  throw new Error('createSandbox not implemented yet - TDD RED phase')
+}
+
+/**
+ * Transform code from TypeScript/JSX/TSX to JavaScript
+ * @stub Not yet implemented - will fail tests
+ */
+export async function transformCode(
+  _code: string,
+  _fileType: FileType
+): Promise<string> {
+  // Stub implementation - returns failure for all tests
+  throw new Error('transformCode not implemented yet - TDD RED phase')
+}
+
+/**
+ * Detect file type from file path
+ * @stub Not yet implemented - will fail tests
+ */
+export function detectFileType(_filePath: string): FileType {
+  // Stub implementation - returns failure for all tests
+  throw new Error('detectFileType not implemented yet - TDD RED phase')
+}

package/cli/src/args.ts

@@ -0,0 +1,174 @@
+/**
+ * CLI Argument Parsing
+ *
+ * Simple argument parser for CLI commands.
+ */
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ParsedArgs {
+  /** Positional arguments */
+  positional: string[]
+  /** Flag arguments (--flag or --flag=value) */
+  flags: Record<string, string | boolean>
+}
+
+// ============================================================================
+// Parsing
+// ============================================================================
+
+/**
+ * Parse command arguments into positional and flag arguments
+ */
+export function parseArgs(args: string[]): ParsedArgs {
+  const positional: string[] = []
+  const flags: Record<string, string | boolean> = {}
+
+  let i = 0
+  while (i < args.length) {
+    const arg = args[i]
+
+    if (arg.startsWith('--')) {
+      const rest = arg.slice(2)
+
+      // Handle --flag=value
+      if (rest.includes('=')) {
+        const [key, ...valueParts] = rest.split('=')
+        flags[key] = valueParts.join('=')
+      }
+      // Handle --no-flag (boolean negation)
+      else if (rest.startsWith('no-')) {
+        flags[rest.slice(3)] = false
+      }
+      // Handle --flag value or --flag (boolean)
+      else {
+        const nextArg = args[i + 1]
+        if (nextArg && !nextArg.startsWith('-')) {
+          flags[rest] = nextArg
+          i++
+        } else {
+          flags[rest] = true
+        }
+      }
+    }
+    // Handle -f value
+    else if (arg.startsWith('-') && arg.length === 2) {
+      const key = arg.slice(1)
+      const nextArg = args[i + 1]
+      if (nextArg && !nextArg.startsWith('-')) {
+        flags[key] = nextArg
+        i++
+      } else {
+        flags[key] = true
+      }
+    }
+    // Positional argument
+    else {
+      positional.push(arg)
+    }
+
+    i++
+  }
+
+  return { positional, flags }
+}
+
+/**
+ * Get a required positional argument or throw
+ */
+export function requirePositional(
+  args: ParsedArgs,
+  index: number,
+  name: string
+): string {
+  const value = args.positional[index]
+  if (!value) {
+    throw new Error(`Missing required argument: ${name}`)
+  }
+  return value
+}
+
+/**
+ * Get a required flag value or throw
+ */
+export function requireFlag(
+  args: ParsedArgs,
+  name: string,
+  description?: string
+): string {
+  const value = args.flags[name]
+  if (value === undefined || typeof value !== 'string') {
+    throw new Error(`Missing required flag: --${name}${description ? ` (${description})` : ''}`)
+  }
+  return value
+}
+
+/**
+ * Get a flag value as string (or undefined)
+ */
+export function getStringFlag(args: ParsedArgs, name: string): string | undefined {
+  const value = args.flags[name]
+  if (typeof value === 'string') {
+    return value
+  }
+  // Handle case where flag exists but has no value
+  if (value === true) {
+    return undefined
+  }
+  return undefined
+}
+
+/**
+ * Get a flag value as boolean
+ */
+export function getBooleanFlag(args: ParsedArgs, name: string, defaultValue = false): boolean {
+  const value = args.flags[name]
+  if (value === undefined) {
+    return defaultValue
+  }
+  if (typeof value === 'boolean') {
+    return value
+  }
+  return value.toLowerCase() === 'true'
+}
+
+/**
+ * Get a flag value as number (or undefined)
+ */
+export function getNumberFlag(args: ParsedArgs, name: string): number | undefined {
+  const value = args.flags[name]
+  if (typeof value === 'string') {
+    const num = Number(value)
+    if (!isNaN(num)) {
+      return num
+    }
+  }
+  return undefined
+}
+
+// ============================================================================
+// Validation
+// ============================================================================
+
+/**
+ * Validate phone number format (E.164)
+ */
+export function isValidPhoneNumber(phone: string): boolean {
+  return /^\+[1-9]\d{1,14}$/.test(phone)
+}
+
+/**
+ * Validate email address format
+ */
+export function isValidEmail(email: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)
+}
+
+/**
+ * Validate positive integer
+ */
+export function isPositiveInteger(value: number): boolean {
+  return Number.isInteger(value) && value > 0
+}

package/cli/src/auth.ts

@@ -0,0 +1,55 @@
+/**
+ * CLI Authentication
+ *
+ * Handles authentication for CLI service commands.
+ * Uses tokens stored by device-auth.ts (via oauth.do)
+ */
+
+import { getStoredToken } from '../device-auth'
+
+export class AuthError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'AuthError'
+  }
+}
+
+/**
+ * Get the current access token or throw if not logged in
+ */
+export async function getAccessToken(): Promise<string> {
+  const token = await getStoredToken()
+
+  if (!token) {
+    throw new AuthError('Not logged in. Run `do login` first.')
+  }
+
+  // Check if token is expired (without refresh token)
+  if (token.expires_at && token.expires_at < Date.now() && !token.refresh_token) {
+    throw new AuthError('Session expired. Run `do login` to re-authenticate.')
+  }
+
+  return token.access_token
+}
+
+/**
+ * Get authorization headers for API requests
+ */
+export async function getAuthHeaders(): Promise<Record<string, string>> {
+  const token = await getAccessToken()
+  return {
+    Authorization: `Bearer ${token}`,
+  }
+}
+
+/**
+ * Check if user is logged in (without throwing)
+ */
+export async function isLoggedIn(): Promise<boolean> {
+  try {
+    await getAccessToken()
+    return true
+  } catch {
+    return false
+  }
+}

package/cli/src/commands/call.ts

@@ -0,0 +1,84 @@
+/**
+ * Call Command
+ *
+ * Make voice calls via calls.do
+ *
+ * Usage:
+ *   do call +15551234567 "Your appointment is tomorrow"
+ *   do call +15551234567 "Hello" --from +15559876543
+ *   do call +15551234567 "Hello" --voice alice
+ *   do call +15551234567 "Hello" --json
+ */
+
+import { parseArgs, requirePositional, getStringFlag, getBooleanFlag, isValidPhoneNumber } from '../args'
+import { callsRequest } from '../rpc'
+import { formatJson } from '../output'
+import { getConfig } from '../config'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface CallRequest {
+  to: string
+  message: string
+  from?: string
+  voice?: string
+}
+
+interface CallResponse {
+  call_id: string
+  status: string
+}
+
+// ============================================================================
+// Command
+// ============================================================================
+
+export async function run(rawArgs: string[]): Promise<void> {
+  const args = parseArgs(rawArgs)
+
+  // Validate required arguments
+  const to = requirePositional(args, 0, 'phone number')
+  const message = requirePositional(args, 1, 'message')
+
+  if (!isValidPhoneNumber(to)) {
+    throw new Error(`Invalid phone number format. Use E.164 format (e.g., +15551234567)`)
+  }
+
+  // Build request
+  const request: CallRequest = {
+    to,
+    message,
+  }
+
+  const from = getStringFlag(args, 'from')
+  if (from) {
+    if (!isValidPhoneNumber(from)) {
+      throw new Error(`Invalid --from phone number format. Use E.164 format (e.g., +15551234567)`)
+    }
+    request.from = from
+  }
+
+  const voice = getStringFlag(args, 'voice')
+  if (voice) {
+    request.voice = voice
+  }
+
+  // Make request
+  const response = await callsRequest<CallResponse>('/calls', {
+    method: 'POST',
+    body: request,
+  })
+
+  // Output result
+  const config = await getConfig()
+  const jsonOutput = getBooleanFlag(args, 'json') || config.json_output
+
+  if (jsonOutput) {
+    console.log(formatJson(response))
+  } else {
+    console.log(`Call initiated: ${response.call_id}`)
+    console.log(`Status: ${response.status}`)
+  }
+}

package/cli/src/commands/charge.ts

@@ -0,0 +1,96 @@
+/**
+ * Charge Command
+ *
+ * Create charges via payments.do
+ *
+ * Usage:
+ *   do charge cus_123 --amount 9900
+ *   do charge cus_123 --amount 1000 --currency eur
+ *   do charge cus_123 --amount 5000 --description "Monthly subscription"
+ *   do charge cus_123 --amount 1000 --metadata '{"order_id":"ord_123"}'
+ *   do charge cus_123 --amount 1000 --json
+ */
+
+import { parseArgs, requirePositional, requireFlag, getStringFlag, getBooleanFlag, getNumberFlag, isPositiveInteger } from '../args'
+import { paymentsRequest } from '../rpc'
+import { formatJson } from '../output'
+import { getConfig } from '../config'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface ChargeRequest {
+  customer: string
+  amount: number
+  currency: string
+  description?: string
+  metadata?: Record<string, unknown>
+}
+
+interface ChargeResponse {
+  charge_id: string
+  status: string
+  amount: number
+  currency: string
+}
+
+// ============================================================================
+// Command
+// ============================================================================
+
+export async function run(rawArgs: string[]): Promise<void> {
+  const args = parseArgs(rawArgs)
+
+  // Validate required arguments
+  const customer = requirePositional(args, 0, 'customer ID')
+  const amountStr = requireFlag(args, 'amount', 'amount in smallest currency unit (e.g., cents)')
+  const amount = parseInt(amountStr, 10)
+
+  if (isNaN(amount) || !isPositiveInteger(amount)) {
+    throw new Error(`Invalid --amount: must be a positive integer (in smallest currency unit)`)
+  }
+
+  // Build request
+  const config = await getConfig()
+  const request: ChargeRequest = {
+    customer,
+    amount,
+    currency: getStringFlag(args, 'currency') ?? config.default_currency ?? 'usd',
+  }
+
+  const description = getStringFlag(args, 'description')
+  if (description) {
+    request.description = description
+  }
+
+  const metadata = getStringFlag(args, 'metadata')
+  if (metadata) {
+    try {
+      request.metadata = JSON.parse(metadata)
+    } catch {
+      throw new Error(`Invalid --metadata: expected valid JSON`)
+    }
+  }
+
+  // Make request
+  const response = await paymentsRequest<ChargeResponse>('/charges', {
+    method: 'POST',
+    body: request,
+  })
+
+  // Output result
+  const jsonOutput = getBooleanFlag(args, 'json') || config.json_output
+
+  if (jsonOutput) {
+    console.log(formatJson(response))
+  } else {
+    console.log(`Charge created: ${response.charge_id}`)
+    if (response.amount !== undefined && response.currency) {
+      console.log(`Amount: ${(response.amount / 100).toFixed(2)} ${response.currency.toUpperCase()}`)
+    }
+    if (response.status) {
+      console.log(`Status: ${response.status}`)
+    }
+  }
+}