dotdo 0.0.2 → 0.1.0

package/cli/README.md

@@ -0,0 +1,238 @@
+# dotdo CLI
+
+Self-contained CLI for Durable Objects development. Single binary that includes the full DO runtime for local development.
+
+## Installation
+
+### Quick Install (Recommended)
+
+Download the pre-built binary for your platform:
+
+```bash
+# macOS (Apple Silicon)
+curl -fsSL https://dotdo.dev/cli/dotdo-darwin-arm64 -o /usr/local/bin/dotdo
+chmod +x /usr/local/bin/dotdo
+
+# macOS (Intel)
+curl -fsSL https://dotdo.dev/cli/dotdo-darwin-x64 -o /usr/local/bin/dotdo
+chmod +x /usr/local/bin/dotdo
+
+# Linux (x64)
+curl -fsSL https://dotdo.dev/cli/dotdo-linux-x64 -o /usr/local/bin/dotdo
+chmod +x /usr/local/bin/dotdo
+
+# Linux (ARM)
+curl -fsSL https://dotdo.dev/cli/dotdo-linux-arm64 -o /usr/local/bin/dotdo
+chmod +x /usr/local/bin/dotdo
+```
+
+### Build from Source
+
+Requires [Bun](https://bun.sh) >= 1.1.0:
+
+```bash
+cd cli
+bun install
+bun run build:local
+./dotdo --help
+```
+
+Build for all platforms:
+
+```bash
+bun run build:all
+# Outputs to cli/dist/
+```
+
+## Usage
+
+### Development
+
+```bash
+# Start local development server
+dotdo dev
+
+# Custom port
+dotdo dev --port 3000
+
+# With Cloudflare Tunnel (public URL)
+dotdo dev --tunnel
+
+# Without state persistence
+dotdo dev --no-persist
+```
+
+### Durable Object Operations
+
+```bash
+# List all DO instances
+dotdo do list
+
+# Show DO state
+dotdo do show <id>
+
+# Show with storage data
+dotdo do show <id> --storage
+
+# Create snapshot
+dotdo do save <id>
+dotdo do save <id> --label "before-migration"
+
+# List snapshots
+dotdo do snapshots <id>
+
+# Restore from snapshot
+dotdo do restore <id> <snapshot-id> --force
+
+# Clone DO
+dotdo do clone <source-id> <target-id>
+
+# Delete DO
+dotdo do delete <id> --force
+```
+
+### Deployment
+
+```bash
+# Deploy to Cloudflare Workers (default)
+dotdo deploy
+
+# Deploy to Vercel
+dotdo deploy --target vercel
+
+# Deploy to Fly.io
+dotdo deploy --target fly
+
+# Deploy to all configured targets
+dotdo deploy --all
+
+# Dry run
+dotdo deploy --dry-run
+```
+
+### Tunnel
+
+```bash
+# Start tunnel only (without dev server)
+dotdo tunnel
+
+# Custom port
+dotdo tunnel --port 3000
+
+# Named tunnel (requires CF auth)
+dotdo tunnel --name myapp
+```
+
+### Other Commands
+
+```bash
+# Initialize new project
+dotdo init
+
+# Build project
+dotdo build
+
+# Stream production logs
+dotdo logs
+```
+
+## Configuration
+
+The CLI reads configuration from multiple sources (in order of priority):
+
+1. Environment variables
+2. `dotdo.config.ts`
+3. `package.json` `dotdo` field
+4. `wrangler.toml` / `wrangler.jsonc`
+
+### dotdo.config.ts
+
+```typescript
+import type { DotdoConfig } from 'dotdo/cli'
+
+export default {
+  // Project settings
+  name: 'my-app',
+  entryPoint: 'index.ts',
+  port: 8787,
+
+  // Cloudflare settings
+  compatibilityDate: '2024-01-01',
+  compatibilityFlags: ['nodejs_compat'],
+
+  // Persistence
+  persist: true, // or path: '.dotdo/data'
+
+  // Deploy targets
+  deploy: {
+    cloudflare: true,
+    vercel: false,
+    fly: false,
+  },
+} satisfies DotdoConfig
+```
+
+### Environment Variables
+
+```bash
+DOTDO_PORT=8787
+DOTDO_HOST=localhost
+CLOUDFLARE_ACCOUNT_ID=...
+```
+
+## Directory Structure
+
+```
+cli/
+├── main.ts               # Entry point
+├── build.ts              # Build script
+├── package.json          # Dependencies
+├── commands/
+│   ├── dev-local.ts      # dotdo dev
+│   ├── do-ops.ts         # dotdo do:*
+│   ├── tunnel.ts         # dotdo tunnel
+│   └── deploy-multi.ts   # dotdo deploy
+├── runtime/
+│   ├── miniflare-adapter.ts
+│   ├── do-registry.ts
+│   └── embedded-db.ts
+└── utils/
+    ├── config.ts
+    └── logger.ts
+```
+
+## Requirements
+
+- Bun >= 1.1.0 (for development/building)
+- The compiled binary runs standalone (no Bun required)
+
+### Binary Size
+
+The self-contained binary is approximately 55-60 MB depending on the platform. This includes the embedded Bun runtime which enables standalone execution without requiring Bun to be installed on the target system.
+
+## Platform Support
+
+| Platform       | Architecture | Status |
+| -------------- | ------------ | ------ |
+| macOS          | ARM64 (M1+)  | ✅     |
+| macOS          | x64          | ✅     |
+| Linux          | x64          | ✅     |
+| Linux          | ARM64        | ✅     |
+| Windows        | x64          | ✅     |
+
+## Development
+
+```bash
+# Run CLI in development
+bun run main.ts dev
+
+# Run tests
+bun test
+
+# Type check
+bun run typecheck
+```
+
+## License
+
+MIT

package/cli/agent.ts

@@ -0,0 +1,72 @@
+/**
+ * AI Agent with MCP Integration
+ *
+ * Provides AI SDK 6 ToolLoopAgent integration for CLI natural language processing.
+ * Connects to Durable Object's MCP endpoint via HTTP transport.
+ *
+ * @see https://ai-sdk.dev/docs/agents/tool-loop-agent
+ * @see https://modelcontextprotocol.io/docs/concepts/transports
+ *
+ * TODO: Implement in GREEN phase (see dotdo-i2fn)
+ */
+
+/**
+ * Configuration options for the AI agent
+ */
+export interface AgentConfig {
+  /** Maximum number of tool execution steps (default: 10) */
+  maxSteps?: number
+  /** Model identifier for Cloudflare Workers AI (default: 'llama-3.3-70b-instruct-fp8-fast') */
+  model?: string
+  /** Custom system instructions for the agent */
+  instructions?: string
+}
+
+/**
+ * Run the AI agent with MCP tools from a Durable Object
+ *
+ * @param input - Natural language input from user
+ * @param doUrl - URL of the Durable Object with MCP endpoint
+ * @param config - Optional agent configuration
+ * @returns Agent response text
+ *
+ * @example
+ * ```typescript
+ * const result = await runAgent('create a user named John', 'https://my-app.do.dev')
+ * // result: 'Created user John with ID 123'
+ * ```
+ */
+export async function runAgent(
+  _input: string,
+  _doUrl: string,
+  _config?: AgentConfig
+): Promise<string> {
+  // TODO: Implement in GREEN phase
+  throw new Error('Not implemented: runAgent')
+}
+
+/**
+ * Create a reusable agent instance with MCP connection
+ *
+ * @param doUrl - URL of the Durable Object with MCP endpoint
+ * @param config - Optional agent configuration
+ * @returns Agent instance with generate and close methods
+ *
+ * @example
+ * ```typescript
+ * const agent = await createAgentWithMCP('https://my-app.do.dev')
+ * const result1 = await agent.generate({ prompt: 'list users' })
+ * const result2 = await agent.generate({ prompt: 'create user' })
+ * await agent.close()
+ * ```
+ */
+export async function createAgentWithMCP(
+  _doUrl: string,
+  _config?: AgentConfig
+): Promise<{
+  generate: (options: { prompt: string }) => Promise<{ text: string }>
+  close: () => Promise<void>
+}> {
+  // TODO: Implement in GREEN phase
+  throw new Error('Not implemented: createAgentWithMCP')
+}

package/cli/bin.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * CLI Entry Point (Node.js wrapper)
+ *
+ * Spawns bun to run the TypeScript CLI.
+ * Bun is installed as a dependency, so it's available in node_modules/.bin/bun
+ */
+
+import { spawn } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const bunPath = join(__dirname, '..', 'node_modules', '.bin', 'bun')
+const mainTs = join(__dirname, 'main.ts')
+
+// Spawn bun with the TypeScript entry point
+const child = spawn(bunPath, [mainTs, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env,
+})
+
+child.on('close', (code) => {
+  process.exit(code ?? 0)
+})
+
+child.on('error', (err) => {
+  // Fallback: try global bun if local not found
+  if (err.code === 'ENOENT') {
+    const fallback = spawn('bun', [mainTs, ...process.argv.slice(2)], {
+      stdio: 'inherit',
+      env: process.env,
+    })
+
+    fallback.on('close', (code) => process.exit(code ?? 0))
+    fallback.on('error', () => {
+      console.error('Error: Could not find bun. Please run: npm install')
+      process.exit(1)
+    })
+  } else {
+    console.error('Error:', err.message)
+    process.exit(1)
+  }
+})

package/cli/bin.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env bun
+/**
+ * CLI Entry Point (Direct Bun execution)
+ *
+ * This file is for direct bun execution (bunx dotdo).
+ * For npm/npx, use bin.js which spawns bun.
+ */
+
+import { route, parseArgv, helpText, version } from './index'
+import { commands } from './commands/index'
+import { fallback } from './fallback'
+
+/**
+ * Main CLI function
+ */
+export async function main(argv: string[]): Promise<void> {
+  const result = route(argv)
+
+  switch (result.type) {
+    case 'help':
+      console.log(helpText)
+      break
+    case 'version':
+      console.log(version)
+      break
+    case 'command':
+      await commands[result.name].run(result.args)
+      break
+    case 'fallback':
+      await fallback(result.input)
+      break
+  }
+}
+
+// Run if executed directly
+if (import.meta.main) {
+  main(parseArgv(Bun.argv))
+}

package/cli/build.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env bun
+/**
+ * Build Script
+ *
+ * Compiles the CLI into a self-contained binary using Bun.
+ * The binary includes all dependencies and works without Bun installed.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+
+interface BuildOptions {
+  target?: 'bun-darwin-arm64' | 'bun-darwin-x64' | 'bun-linux-arm64' | 'bun-linux-x64' | 'bun-windows-x64'
+  outfile?: string
+  minify?: boolean
+  sourcemap?: boolean
+}
+
+const defaultTargets: BuildOptions['target'][] = [
+  'bun-darwin-arm64',
+  'bun-darwin-x64',
+  'bun-linux-arm64',
+  'bun-linux-x64',
+]
+
+async function build(options: BuildOptions = {}): Promise<void> {
+  const cliDir = path.dirname(new URL(import.meta.url).pathname)
+  const entryPoint = path.join(cliDir, 'main.ts')
+  const outDir = path.join(cliDir, 'dist')
+
+  // Ensure output directory exists
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true })
+  }
+
+  // Determine targets
+  const targets = options.target ? [options.target] : defaultTargets
+
+  console.log('Building dotdo CLI...')
+  console.log()
+
+  for (const target of targets) {
+    const [, platform, arch] = target.split('-')
+    const ext = platform === 'windows' ? '.exe' : ''
+    const outfile = options.outfile ?? path.join(outDir, `dotdo-${platform}-${arch}${ext}`)
+
+    console.log(`  Target: ${target}`)
+    console.log(`  Output: ${outfile}`)
+
+    try {
+      const startTime = Date.now()
+
+      const result = await Bun.build({
+        entrypoints: [entryPoint],
+        outdir: outDir,
+        target,
+        minify: options.minify ?? true,
+        sourcemap: options.sourcemap ? 'external' : 'none',
+        external: [
+          // These need to be external for native modules
+          'better-sqlite3',
+        ],
+        define: {
+          'process.env.NODE_ENV': '"production"',
+        },
+      })
+
+      if (!result.success) {
+        console.error('Build failed:')
+        for (const log of result.logs) {
+          console.error(log)
+        }
+        process.exit(1)
+      }
+
+      // Compile to binary
+      const proc = Bun.spawn(['bun', 'build', entryPoint, '--compile', '--target', target, '--outfile', outfile], {
+        cwd: cliDir,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      })
+
+      const exitCode = await proc.exited
+
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text()
+        console.error(`  Error: ${stderr}`)
+        continue
+      }
+
+      const duration = Date.now() - startTime
+      const stats = fs.statSync(outfile)
+      const sizeMB = (stats.size / 1024 / 1024).toFixed(2)
+
+      console.log(`  Size:   ${sizeMB} MB`)
+      console.log(`  Time:   ${duration}ms`)
+      console.log()
+    } catch (error) {
+      console.error(`  Error: ${error instanceof Error ? error.message : String(error)}`)
+      console.log()
+    }
+  }
+
+  console.log('Build complete!')
+}
+
+// CLI interface
+async function main(): Promise<void> {
+  const args = process.argv.slice(2)
+  const options: BuildOptions = {}
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+
+    if (arg === '--target' && args[i + 1]) {
+      options.target = args[++i] as BuildOptions['target']
+    } else if (arg === '--outfile' && args[i + 1]) {
+      options.outfile = args[++i]
+    } else if (arg === '--no-minify') {
+      options.minify = false
+    } else if (arg === '--sourcemap') {
+      options.sourcemap = true
+    } else if (arg === '--help' || arg === '-h') {
+      console.log(`
+dotdo CLI Build Script
+
+Usage: bun run build.ts [options]
+
+Options:
+  --target <target>   Build for specific target
+                      (bun-darwin-arm64, bun-darwin-x64, bun-linux-arm64, bun-linux-x64, bun-windows-x64)
+  --outfile <path>    Output file path
+  --no-minify         Disable minification
+  --sourcemap         Include source maps
+  -h, --help          Show this help
+
+Examples:
+  bun run build.ts                    # Build for all targets
+  bun run build.ts --target bun-darwin-arm64  # macOS ARM only
+  bun run build.ts --outfile ./dotdo  # Custom output path
+`)
+      process.exit(0)
+    }
+  }
+
+  await build(options)
+}
+
+// Run if executed directly
+if (import.meta.main) {
+  main().catch((error) => {
+    console.error('Build failed:', error)
+    process.exit(1)
+  })
+}
+
+export { build, type BuildOptions }

package/cli/commands/auth/login.ts

@@ -0,0 +1,14 @@
+import { ensureLoggedIn } from 'oauth.do/node'
+
+export async function run() {
+  const { token, isNewLogin } = await ensureLoggedIn({
+    openBrowser: true,
+    print: console.log,
+  })
+
+  if (isNewLogin) {
+    console.log('Logged in successfully')
+  } else {
+    console.log('Already logged in')
+  }
+}

package/cli/commands/auth/logout.ts

@@ -0,0 +1,6 @@
+import { ensureLoggedOut } from 'oauth.do/node'
+
+export async function run() {
+  await ensureLoggedOut({ print: console.log })
+  console.log('Logged out')
+}

package/cli/commands/auth/whoami.ts

@@ -0,0 +1,16 @@
+import { getToken, getUser } from 'oauth.do/node'
+
+export async function run() {
+  const token = await getToken()
+  if (!token) {
+    console.log('Not logged in. Run: do login')
+    return
+  }
+
+  const { user } = await getUser(token)
+  if (user) {
+    console.log(`Logged in as: ${user.email}`)
+  } else {
+    console.log('Session expired. Run: do login')
+  }
+}