bod-cli 0.3.1

package/src/commands/init/init.ts

@@ -0,0 +1,277 @@
+import { defineCommand } from 'citty'
+import { select, input, confirm } from '@inquirer/prompts'
+import chalk from 'chalk'
+import { existsSync, mkdirSync, writeFileSync, readdirSync } from 'fs'
+import { basename, join } from 'path'
+import { loadConfig, getResolvedInstance, configExists } from '../../config'
+import { BodClient } from '../../client'
+import { TEMPLATES, type TemplateId } from './templates'
+
+type AppType = 'caab' | 'static' | 'server' | 'mixed' | 'unknown'
+
+function detectAppType(dir: string): AppType {
+  if (existsSync(join(dir, 'api.ts'))) return 'caab'
+  if (existsSync(join(dir, 'packages'))) return 'mixed'
+  if (existsSync(join(dir, 'dist')) || existsSync(join(dir, 'public'))) return 'static'
+  if (existsSync(join(dir, 'server.ts')) || existsSync(join(dir, 'index.ts'))) return 'server'
+  return 'unknown'
+}
+
+function isEmpty(dir: string): boolean {
+  const entries = readdirSync(dir).filter(e => !e.startsWith('.'))
+  return entries.length === 0
+}
+
+function generateBodifyYaml(name: string, opts: { database?: boolean; repo?: string } = {}): string {
+  const lines = [`name: ${name}`]
+  if (opts.repo) lines.push(`repo: ${opts.repo}`)
+  if (opts.database) lines.push(`database: true`)
+  return lines.join('\n') + '\n'
+}
+
+function generateClaudeMd(appName: string, type: string, opts: { database?: boolean } = {}): string {
+  let md = `# ${appName}
+
+Deployed on Bodify. Type: \`${type}\`.
+
+## Commands
+- \`bod deploy\` — deploy current branch
+- \`bod logs ${appName} -f\` — tail logs
+- \`bod apps status ${appName}\` — status + instances
+- \`bod env set ${appName} KEY=VALUE\` — set env var
+- \`bod rollback ${appName}\` — rollback to previous deployment
+
+## MCP Integration
+This project has a Bodify MCP server configured in \`.claude/mcp_servers.json\`.
+Set the \`BODIFY_API_KEY\` env var to authenticate.
+`
+
+  if (type === 'caab' || type === 'caab-db') {
+    md += `
+## CaaB Convention
+- Methods become REST endpoints: \`get()\` → GET, \`post(body)\` → POST, etc.
+- Class name = route segment (kebab-cased): \`UserProfile\` → \`/user-profile\`
+- Primitive args = path params: \`getById(id)\` → \`GET /by-id/:id\`
+- Object args = JSON body: \`post(body: {...})\` → POST with body
+- Extend \`Resource\` base class (symbol-based marker)
+- Return plain objects for JSON, \`new Response()\` for custom status codes
+`
+  }
+
+  if (type === 'caab-db' || opts.database) {
+    md += `
+## BodDB
+\`\`\`typescript
+import { BodDB } from '@bod.ee/db';
+const db = new BodDB({ path: process.env.BODDB_PATH ?? ':memory:' });
+
+await db.push('/items', { title: 'Hello', createdAt: Date.now() }); // create
+await db.get('/items/id');                                           // read
+await db.query('/items').order('createdAt', 'desc').get();          // query
+await db.update('/items/id', { title: 'Updated' });                 // update
+await db.delete('/items/id');                                        // delete
+\`\`\`
+`
+  }
+
+  if (type === 'server') {
+    md += `
+## Server Requirements
+- Read port from \`process.env.PORT\`
+- Expose \`GET /healthz\` returning JSON (Bodify health-checks this)
+`
+  }
+
+  if (type === 'static') {
+    md += `
+## Static Site
+- Bodify runs \`bun install\` + \`bun run build\` (if build script exists)
+- Serves \`dist/\` with SPA fallback
+`
+  }
+
+  return md
+}
+
+function generateMcpConfig(url: string): string {
+  return JSON.stringify({
+    bodify: {
+      type: 'http',
+      url: `${url}/api/mcp`,
+      headers: { Authorization: 'Bearer ${BODIFY_API_KEY}' },
+    },
+  }, null, 2)
+}
+
+function generateGitignore(): string {
+  return `node_modules/
+dist/
+.env
+.env.local
+*.log
+`
+}
+
+export default defineCommand({
+  meta: { name: 'init', description: 'Initialize a Bodify project' },
+  async run() {
+    const cwd = process.cwd()
+    const folderName = basename(cwd)
+    const empty = isEmpty(cwd)
+
+    if (!configExists()) {
+      console.log(chalk.yellow('No Bodify instance configured. Run "bod login <url>" first.'))
+      process.exit(1)
+    }
+    const config = loadConfig()
+    const { url, apiKey, instance } = getResolvedInstance(config)
+    const client = new BodClient(url, apiKey)
+
+    if (empty) {
+      // ── Empty folder flow ────────────────────────────────────────
+      const templateId = await select<TemplateId>({
+        message: 'Project template:',
+        choices: TEMPLATES.map(t => ({ value: t.id, name: `${t.label} — ${t.description}` })),
+      })
+      const template = TEMPLATES.find(t => t.id === templateId)!
+
+      const appName = await input({ message: 'App name:', default: folderName })
+      const useDb = templateId === 'caab-db' || (templateId === 'caab' && await confirm({ message: 'Enable database?', default: false }))
+
+      // Write template files
+      for (const [path, content] of Object.entries(template.files)) {
+        const fullPath = join(cwd, path)
+        mkdirSync(join(fullPath, '..'), { recursive: true })
+        writeFileSync(fullPath, content)
+      }
+
+      // package.json
+      const pkg: any = {
+        name: appName,
+        version: '0.1.0',
+        type: 'module',
+        private: true,
+        scripts: template.scripts ?? {},
+        dependencies: template.deps ?? {},
+        devDependencies: template.devDeps ?? {},
+      }
+      writeFileSync(join(cwd, 'package.json'), JSON.stringify(pkg, null, 2))
+
+      // tsconfig.json
+      writeFileSync(join(cwd, 'tsconfig.json'), JSON.stringify({
+        compilerOptions: {
+          target: 'ESNext', module: 'ESNext', moduleResolution: 'bundler',
+          strict: true, esModuleInterop: true, skipLibCheck: true,
+          jsx: template.deps?.react ? 'react-jsx' : undefined,
+        },
+        include: ['src', '.'],
+      }, null, 2))
+
+      // bodify.yaml
+      writeFileSync(join(cwd, 'bodify.yaml'), generateBodifyYaml(appName, { database: useDb }))
+
+      // .claude/
+      mkdirSync(join(cwd, '.claude'), { recursive: true })
+      writeFileSync(join(cwd, '.claude', 'CLAUDE.md'), generateClaudeMd(appName, templateId, { database: useDb }))
+      writeFileSync(join(cwd, '.claude', 'mcp_servers.json'), generateMcpConfig(url))
+
+      // .gitignore
+      writeFileSync(join(cwd, '.gitignore'), generateGitignore())
+
+      // git init
+      Bun.spawnSync(['git', 'init'], { cwd, stdio: ['ignore', 'ignore', 'ignore'] })
+      Bun.spawnSync(['git', 'add', '.'], { cwd, stdio: ['ignore', 'ignore', 'ignore'] })
+      Bun.spawnSync(['git', 'commit', '-m', 'Initial commit (bod init)'], { cwd, stdio: ['ignore', 'ignore', 'ignore'] })
+
+      // Detect git remote (may exist if user pre-configured)
+      let repo = ''
+      try {
+        const proc = Bun.spawnSync(['git', 'remote', 'get-url', 'origin'], { cwd })
+        repo = proc.exitCode === 0 ? proc.stdout.toString().trim() : ''
+      } catch { /* no remote */ }
+
+      // Register with bodify
+      console.log(chalk.dim('Registering app with Bodify...'))
+      try {
+        const app = await client.post<any>('/apps', {
+          name: appName,
+          repo,
+          database: useDb,
+        })
+        console.log(chalk.green(`✓ App registered (id: ${app.id})`))
+        if (app.domain) console.log(chalk.dim(`  Domain: ${app.domain}`))
+      } catch (e) {
+        console.warn(chalk.yellow(`Warning: Could not register app: ${(e as Error).message}`))
+      }
+
+      // .npmrc for registry (scoped to @bod.ee only)
+      if (instance.capabilities.registryEnabled) {
+        writeFileSync(join(cwd, '.npmrc'), `@bod.ee:registry=${url}/api/registry/\n`)
+        console.log(chalk.dim('Created .npmrc with Bodify registry'))
+      }
+
+      // Install deps
+      console.log(chalk.dim('Installing dependencies...'))
+      Bun.spawnSync(['bun', 'install'], { cwd, stdio: ['inherit', 'inherit', 'inherit'] })
+
+      console.log(chalk.green(`\n✓ Project "${appName}" initialized!`))
+      console.log(chalk.dim('  Set BODIFY_API_KEY env var for MCP integration.'))
+      console.log(chalk.dim(`  bod deploy`))
+
+    } else {
+      // ── Existing folder flow ─────────────────────────────────────
+      const detected = detectAppType(cwd)
+      console.log(chalk.dim(`Detected type: ${detected}`))
+
+      const appName = await input({ message: 'App name:', default: folderName })
+
+      // Detect git remote
+      let repo = ''
+      try {
+        const proc = Bun.spawnSync(['git', 'remote', 'get-url', 'origin'], { cwd })
+        repo = proc.stdout.toString().trim()
+      } catch { /* no git remote */ }
+
+      // bodify.yaml
+      if (existsSync(join(cwd, 'bodify.yaml'))) {
+        console.log(chalk.dim('bodify.yaml already exists, skipping'))
+      } else {
+        const useDb = detected === 'caab' && await confirm({ message: 'Enable database?', default: false })
+        writeFileSync(join(cwd, 'bodify.yaml'), generateBodifyYaml(appName, { database: useDb, repo }))
+        console.log(chalk.green('✓ Created bodify.yaml'))
+      }
+
+      // Register
+      console.log(chalk.dim('Registering app with Bodify...'))
+      try {
+        const app = await client.post<any>('/apps', {
+          name: appName,
+          repo,
+          database: detected === 'caab',
+        })
+        console.log(chalk.green(`✓ App registered (id: ${app.id})`))
+        if (app.domain) console.log(chalk.dim(`  Domain: ${app.domain}`))
+      } catch (e) {
+        console.warn(chalk.yellow(`Warning: Could not register: ${(e as Error).message}`))
+      }
+
+      // .npmrc (scoped to @bod.ee only)
+      if (instance.capabilities.registryEnabled && !existsSync(join(cwd, '.npmrc'))) {
+        writeFileSync(join(cwd, '.npmrc'), `@bod.ee:registry=${url}/api/registry/\n`)
+        console.log(chalk.dim('Created .npmrc with Bodify registry'))
+      }
+
+      // .claude/ files
+      if (!existsSync(join(cwd, '.claude', 'CLAUDE.md'))) {
+        mkdirSync(join(cwd, '.claude'), { recursive: true })
+        writeFileSync(join(cwd, '.claude', 'CLAUDE.md'), generateClaudeMd(appName, detected))
+        writeFileSync(join(cwd, '.claude', 'mcp_servers.json'), generateMcpConfig(url))
+        console.log(chalk.green('✓ Created .claude/ config'))
+      }
+
+      console.log(chalk.green(`\n✓ Project "${appName}" connected to Bodify!`))
+      console.log(chalk.dim('  Set BODIFY_API_KEY env var for MCP integration.'))
+      console.log(chalk.dim(`  bod deploy`))
+    }
+  },
+})

package/src/commands/init/templates.ts

@@ -0,0 +1,171 @@
+export type TemplateId = 'caab' | 'caab-db' | 'static' | 'server'
+
+export interface Template {
+  id: TemplateId
+  label: string
+  description: string
+  files: Record<string, string>
+  deps?: Record<string, string>
+  devDeps?: Record<string, string>
+  scripts?: Record<string, string>
+}
+
+const RESOURCE_BASE = `abstract class Resource {
+  static readonly [Symbol.for('bodify.Resource')] = true;
+}
+`
+
+export const TEMPLATES: Template[] = [
+  {
+    id: 'caab',
+    label: 'CaaB (Class-as-a-Backend)',
+    description: 'API backend — methods become REST endpoints',
+    files: {
+      'api.ts': `${RESOURCE_BASE}
+class Items extends Resource {
+  private items = [
+    { id: '1', title: 'Hello from Bodify', createdAt: Date.now() },
+  ];
+
+  async get() { return this.items; }
+  async getById(id: string) {
+    const item = this.items.find(i => i.id === id);
+    if (!item) return new Response('Not found', { status: 404 });
+    return item;
+  }
+  async post(body: { title: string }) {
+    if (!body?.title) return new Response('title required', { status: 400 });
+    const item = { id: String(Date.now()), title: body.title, createdAt: Date.now() };
+    this.items.push(item);
+    return item;
+  }
+  async delete(id: string) {
+    this.items = this.items.filter(i => i.id !== id);
+    return { deleted: true, id };
+  }
+}
+
+export default class Api extends Resource {
+  items = new Items();
+
+  async getHealthz() {
+    return { status: 'ok', branch: process.env.BODIFY_BRANCH ?? 'dev', ts: Date.now() };
+  }
+}
+`,
+    },
+    scripts: { dev: 'echo "Deploy with: bod deploy"' },
+  },
+  {
+    id: 'caab-db',
+    label: 'CaaB + BodDB',
+    description: 'API backend with embedded database',
+    files: {
+      'api.ts': `import { BodDB } from '@bod.ee/db';
+
+const db = new BodDB({ path: process.env.BODDB_PATH ?? ':memory:' });
+
+${RESOURCE_BASE}
+class Items extends Resource {
+  async get() {
+    return (await db.query('/items').order('createdAt', 'desc').get()) ?? [];
+  }
+  async getById(id: string) {
+    const item = await db.get(\`/items/\${id}\`);
+    if (!item) return new Response('Not found', { status: 404 });
+    return item;
+  }
+  async post(body: { title: string }) {
+    if (!body?.title) return new Response('title required', { status: 400 });
+    const id = await db.push('/items', { title: body.title, createdAt: Date.now() });
+    return db.get(\`/items/\${id}\`);
+  }
+  async delete(id: string) {
+    const existed = !!(await db.get(\`/items/\${id}\`));
+    await db.delete(\`/items/\${id}\`);
+    return { deleted: existed, id };
+  }
+}
+
+export default class Api extends Resource {
+  items = new Items();
+
+  async getHealthz() {
+    const items = (await db.query('/items').get()) as unknown[] | null;
+    return {
+      status: 'ok',
+      branch: process.env.BODIFY_BRANCH ?? 'dev',
+      ts: Date.now(),
+      itemCount: items?.length ?? 0,
+    };
+  }
+}
+`,
+    },
+    deps: { '@bod.ee/db': '*' },
+    scripts: { dev: 'echo "Deploy with: bod deploy"' },
+  },
+  {
+    id: 'static',
+    label: 'Static Site (React + Vite)',
+    description: 'SPA with Vite build',
+    files: {
+      'src/App.tsx': `export default function App() {
+  return (
+    <div style={{ padding: '2rem', fontFamily: 'system-ui' }}>
+      <h1>Hello from Bodify!</h1>
+      <p>Edit src/App.tsx to get started.</p>
+    </div>
+  );
+}
+`,
+      'src/main.tsx': `import { createRoot } from 'react-dom/client';
+import App from './App';
+
+createRoot(document.getElementById('root')!).render(<App />);
+`,
+      'index.html': `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>App</title></head>
+<body><div id="root"></div><script type="module" src="/src/main.tsx"></script></body>
+</html>`,
+      'vite.config.ts': `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+});
+`,
+    },
+    deps: { react: '^19', 'react-dom': '^19' },
+    devDeps: { vite: '^6', '@vitejs/plugin-react': '^4', '@types/react': '^19', '@types/react-dom': '^19' },
+    scripts: { dev: 'vite', build: 'vite build', preview: 'vite preview' },
+  },
+  {
+    id: 'server',
+    label: 'Bun Server',
+    description: 'Custom Bun.serve() server',
+    files: {
+      'server.ts': `const port = Number(process.env.PORT ?? 3000);
+
+Bun.serve({
+  port,
+  fetch(req) {
+    const url = new URL(req.url);
+    if (url.pathname === '/healthz') {
+      return Response.json({
+        status: 'ok',
+        branch: process.env.BODIFY_BRANCH ?? 'dev',
+        ts: Date.now(),
+      });
+    }
+    return Response.json({ hello: 'world' });
+  },
+});
+
+console.log(\`Server running on :\${port}\`);
+`,
+    },
+    scripts: { dev: 'bun --watch server.ts', start: 'bun server.ts' },
+  },
+]

package/src/commands/login.ts

@@ -0,0 +1,60 @@
+import { defineCommand } from 'citty'
+import { password as promptPassword } from '@inquirer/prompts'
+import chalk from 'chalk'
+import { loadConfig, writeConfig, configExists, type Config } from '../config'
+import { BodClient } from '../client'
+import { printKv } from '../utils/output'
+
+export default defineCommand({
+  meta: { name: 'login', description: 'Authenticate with a Bodify instance' },
+  args: {
+    url: { type: 'positional', description: 'Bodify instance URL (e.g. https://bodify.example.com)', required: true },
+    key: { type: 'string', description: 'API key (or will prompt)' },
+    name: { type: 'string', description: 'Instance alias (defaults to hostname)' },
+  },
+  async run({ args }) {
+    const url = args.url.replace(/\/+$/, '')
+    const alias = args.name || new URL(url).hostname
+
+    const apiKey = args.key || await promptPassword({ message: 'API key:' })
+    if (!apiKey) { console.error(chalk.red('API key required.')); process.exit(1) }
+
+    // Verify connectivity
+    const client = new BodClient(url, apiKey)
+    console.log(chalk.dim('Verifying connection...'))
+
+    try {
+      await client.get<{ status: string }>('/healthz')
+    } catch (e) {
+      console.error(chalk.red(`Cannot reach ${url}: ${(e as Error).message}`))
+      process.exit(1)
+    }
+
+    // Fetch capabilities
+    let capabilities = { registryEnabled: false, baseDomain: null as string | null, githubConfigured: false }
+    try {
+      capabilities = await client.get<typeof capabilities>('/config/public')
+    } catch { /* older instances may not have this endpoint */ }
+
+    // Save config
+    let config: Config
+    if (configExists()) {
+      config = loadConfig()
+    } else {
+      config = { instances: {}, defaultInstance: null }
+    }
+
+    config.instances[alias] = { url, apiKey, capabilities }
+    config.defaultInstance = alias
+    writeConfig(config)
+
+    console.log(chalk.green(`\n✓ Logged in to ${alias}`))
+    printKv({
+      URL: url,
+      Alias: alias,
+      Registry: capabilities.registryEnabled ? 'enabled' : 'disabled',
+      'Base Domain': capabilities.baseDomain ?? '(none)',
+      GitHub: capabilities.githubConfigured ? 'configured' : 'not configured',
+    })
+  },
+})

package/src/commands/logs.ts

@@ -0,0 +1,46 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { loadConfig, getResolvedInstance } from '../config'
+import { BodClient } from '../client'
+import { resolveAppId, resolveAppName } from '../utils/resolve'
+
+export default defineCommand({
+  meta: { name: 'logs', description: 'View app logs' },
+  args: {
+    app: { type: 'positional', description: 'App name or ID (or reads from bodify.yaml)', required: false },
+    follow: { type: 'boolean', alias: 'f', description: 'Follow log output' },
+    lines: { type: 'string', default: '100', description: 'Number of lines' },
+  },
+  async run({ args }) {
+    const { url, apiKey } = getResolvedInstance(loadConfig())
+    const client = new BodClient(url, apiKey)
+    const appName = resolveAppName(args.app)
+    const appId = await resolveAppId(client, appName)
+
+    const formatLog = (l: any) => {
+      const time = new Date(l.ts).toISOString().slice(11, 23)
+      const stream = l.stream === 'stderr' ? chalk.red(l.stream) : chalk.dim(l.stream)
+      return `${chalk.dim(time)} [${stream}] ${l.line ?? l.message ?? ''}`
+    }
+
+    if (!args.follow) {
+      const logs = await client.get<any[]>(`/apps/${appId}/logs?limit=${args.lines}`)
+      if (!Array.isArray(logs) || logs.length === 0) { console.log(chalk.dim('No logs.')); return }
+      for (const l of logs.reverse()) console.log(formatLog(l))
+      return
+    }
+
+    console.log(chalk.dim(`Tailing logs for ${appName}... (Ctrl+C to stop)`))
+    let lastTs = Date.now()
+    while (true) {
+      const logs = await client.get<any[]>(`/apps/${appId}/logs?limit=50`)
+      if (!Array.isArray(logs)) { await Bun.sleep(2000); continue }
+      const fresh = logs.filter(l => l.ts > lastTs)
+      if (fresh.length) {
+        lastTs = Math.max(...fresh.map(l => l.ts))
+        for (const l of [...fresh].reverse()) console.log(formatLog(l))
+      }
+      await Bun.sleep(2000)
+    }
+  },
+})

package/src/commands/open.ts

@@ -0,0 +1,29 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { loadConfig, getResolvedInstance } from '../config'
+import { BodClient } from '../client'
+import { resolveAppId, resolveAppName } from '../utils/resolve'
+
+export default defineCommand({
+  meta: { name: 'open', description: 'Open app in browser' },
+  args: {
+    app: { type: 'positional', description: 'App name or ID (or reads from bodify.yaml)', required: false },
+  },
+  async run({ args }) {
+    const config = loadConfig()
+    const { url, apiKey, instance } = getResolvedInstance(config)
+    const client = new BodClient(url, apiKey)
+    const appId = await resolveAppId(client, resolveAppName(args.app))
+    const detail = await client.get<any>(`/apps/${appId}`)
+
+    const appUrl = detail.domain
+      ? `https://${detail.domain}`
+      : instance.capabilities.baseDomain
+        ? `https://${detail.name}.${instance.capabilities.baseDomain}`
+        : `${url}` // fallback to instance URL
+
+    console.log(chalk.dim(`Opening ${appUrl}`))
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open'
+    Bun.spawn([cmd, appUrl], { stdio: ['ignore', 'ignore', 'ignore'] })
+  },
+})

package/src/commands/remove.ts

@@ -0,0 +1,16 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+
+export default defineCommand({
+  meta: { name: 'remove', description: 'Remove a package' },
+  args: {
+    pkg: { type: 'positional', description: 'Package name', required: true },
+  },
+  async run({ args }) {
+    const cmd = ['bun', 'remove', args.pkg]
+    console.log(chalk.dim(`$ ${cmd.join(' ')}`))
+    const proc = Bun.spawn(cmd, { stdio: ['inherit', 'inherit', 'inherit'] })
+    const code = await proc.exited
+    process.exit(code)
+  },
+})

package/src/commands/rollback.ts

@@ -0,0 +1,28 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { loadConfig, getResolvedInstance } from '../config'
+import { BodClient } from '../client'
+import { resolveAppId, resolveAppName } from '../utils/resolve'
+
+export default defineCommand({
+  meta: { name: 'rollback', description: 'Rollback to previous deployment' },
+  args: {
+    app: { type: 'positional', description: 'App name (or reads from bodify.yaml)', required: false },
+    branch: { type: 'string', description: 'Branch to rollback (default: production branch)' },
+  },
+  async run({ args }) {
+    const { url, apiKey } = getResolvedInstance(loadConfig())
+    const client = new BodClient(url, apiKey)
+
+    const appName = resolveAppName(args.app)
+
+    const appId = await resolveAppId(client, appName)
+    const body: any = {}
+    if (args.branch) body.branch = args.branch
+
+    console.log(chalk.dim(`Rolling back ${appName}...`))
+    const result = await client.post<any>(`/apps/${appId}/rollback`, body)
+    console.log(chalk.green(`✓ Rollback queued`))
+    if (result.rollingBackTo) console.log(chalk.dim(`  Rolling back to deployment: ${result.rollingBackTo}`))
+  },
+})

package/src/commands/serve.ts

@@ -0,0 +1,36 @@
+import { defineCommand } from 'citty'
+import { join } from 'path'
+import { existsSync } from 'fs'
+
+function resolveBodifyServe(): string {
+  // Sibling directory convention: bod-cli and bodify live side by side
+  const sibling = join(import.meta.dir, '../../../bodify/src/serve.ts')
+  if (existsSync(sibling)) return sibling
+  // Fallback: try global BODIFY_DIR env
+  const envDir = process.env.BODIFY_DIR
+  if (envDir) {
+    const fromEnv = join(envDir, 'src/serve.ts')
+    if (existsSync(fromEnv)) return fromEnv
+  }
+  throw new Error('Could not find bodify/src/serve.ts. Set BODIFY_DIR or ensure bodify is a sibling directory.')
+}
+
+export default defineCommand({
+  meta: { name: 'serve', description: 'Run app locally (auto-detects type)' },
+  args: {
+    dir: { type: 'positional', description: 'Directory to serve (default: .)', required: false },
+    port: { type: 'string', description: 'Port (default: 3000)' },
+    mount: { type: 'string', description: 'API mount path (default: /api)' },
+    'no-build': { type: 'boolean', description: 'Skip build step' },
+  },
+  async run({ args }) {
+    const servePath = resolveBodifyServe()
+    const cmd = ['bun', 'run', servePath, args.dir || '.']
+    if (args.port) cmd.push(`--port=${args.port}`)
+    if (args['no-build']) cmd.push('--no-build')
+    if (args.mount) cmd.push(`--mount=${args.mount}`)
+
+    const proc = Bun.spawn(cmd, { stdout: 'inherit', stderr: 'inherit', stdin: 'inherit' })
+    await proc.exited
+  },
+})