bod-cli 0.3.1

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "bod-cli",
+  "version": "0.3.1",
+  "type": "module",
+  "bin": {
+    "bod": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts --outdir dist --target node --format esm"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "chalk": "^5.3.0",
+    "citty": "^0.1.6",
+    "cli-table3": "^0.6.5",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,146 @@
+#!/usr/bin/env bun
+import { defineCommand, runMain } from 'citty'
+import { select, input } from '@inquirer/prompts'
+import { configExists, setInstanceOverride } from './config'
+import loginCmd from './commands/login'
+import appsCmd from './commands/apps'
+import deployCmd from './commands/deploy'
+import rollbackCmd from './commands/rollback'
+import logsCmd from './commands/logs'
+import envCmd from './commands/env'
+import initCmd from './commands/init/init'
+import addCmd from './commands/add'
+import removeCmd from './commands/remove'
+import openCmd from './commands/open'
+import serveCmd from './commands/serve'
+import sshCmd from './commands/ssh'
+
+// Parse --instance early so it's set before citty dispatches subcommands
+const instanceFlag = process.argv.find(a => a.startsWith('--instance='))?.split('=').slice(1).join('=')
+if (instanceFlag) setInstanceOverride(instanceFlag)
+
+const subCommands = {
+  login: loginCmd,
+  init: initCmd,
+  deploy: deployCmd,
+  rollback: rollbackCmd,
+  apps: appsCmd,
+  logs: logsCmd,
+  env: envCmd,
+  add: addCmd,
+  remove: removeCmd,
+  open: openCmd,
+  serve: serveCmd,
+  ssh: sshCmd,
+}
+
+const main = defineCommand({
+  meta: {
+    name: 'bod',
+    version: '0.1.0',
+    description: 'Unified CLI for the Bod product family',
+  },
+  args: {
+    instance: { type: 'string', description: 'Bodify instance name (from config)' },
+  },
+  subCommands,
+  async run({ rawArgs }) {
+    // If a subcommand was given, citty already handled it
+    if (process.argv.slice(2).some(a => !a.startsWith('-') && a in subCommands)) return
+
+    const { runCommand } = await import('citty')
+
+    // First-run: redirect to login
+    if (!configExists()) {
+      console.log('Welcome to bod! Let\'s connect to your Bodify instance.\n')
+      const loginArgs = await getInteractiveArgs('login')
+      if (!loginArgs) return
+      await runCommand(subCommands.login, { rawArgs: loginArgs })
+      return
+    }
+
+    // Interactive menu
+    const choices = [
+      { value: 'apps',     name: 'apps      — List & inspect apps' },
+      { value: 'deploy',   name: 'deploy    — Trigger a deployment' },
+      { value: 'rollback', name: 'rollback  — Rollback deployment' },
+      { value: 'logs',     name: 'logs      — View app logs' },
+      { value: 'open',     name: 'open      — Open app in browser' },
+      { value: 'env',      name: 'env       — Manage env vars' },
+      { value: 'serve',    name: 'serve     — Run app locally' },
+      { value: 'ssh',      name: 'ssh       — SSH into Bodify server' },
+      { value: 'init',     name: 'init      — Initialize a project' },
+      { value: 'add',      name: 'add       — Add a package' },
+      { value: 'remove',   name: 'remove    — Remove a package' },
+      { value: 'login',    name: 'login     — Add/switch instance' },
+      { value: 'exit',     name: 'exit      — Exit' },
+    ]
+
+    while (true) {
+      let command: string
+      try {
+        command = await select({ message: 'What would you like to do?', choices })
+      } catch (e) {
+        if ((e as Error).name === 'ExitPromptError') return
+        throw e
+      }
+      if (command === 'exit') return
+      try {
+        // Commands with subcommands need a default, commands with required positionals need prompting
+        const interactiveArgs = await getInteractiveArgs(command)
+        if (interactiveArgs === null) continue // user cancelled
+        await runCommand(subCommands[command as keyof typeof subCommands], { rawArgs: interactiveArgs })
+      } catch (e) {
+        if ((e as Error).name === 'ExitPromptError') continue
+        console.error(`Error: ${(e as Error).message}`)
+      }
+      console.log()
+    }
+  },
+})
+
+/** Build rawArgs for commands that need them in interactive mode */
+async function getInteractiveArgs(command: string): Promise<string[] | null> {
+  try {
+    switch (command) {
+      case 'apps': return ['list']
+      case 'env': {
+        const app = await input({ message: 'App name:' })
+        if (!app) return null
+        return ['list', app]
+      }
+      case 'login': {
+        const url = await input({ message: 'Bodify instance URL:' })
+        if (!url) return null
+        return [url]
+      }
+      case 'logs': {
+        const app = await input({ message: 'App name:' })
+        if (!app) return null
+        return [app, '--follow']
+      }
+      case 'deploy':
+      case 'rollback': {
+        const app = await input({ message: 'App name (or empty for bodify.yaml):' })
+        return app ? [app] : []
+      }
+      case 'open': {
+        const app = await input({ message: 'App name:' })
+        if (!app) return null
+        return [app]
+      }
+      case 'add': return [] // add handles its own interactive prompting
+      case 'remove': {
+        const pkg = await input({ message: 'Package name:' })
+        if (!pkg) return null
+        return [pkg]
+      }
+      default: return []
+    }
+  } catch (e) {
+    if ((e as Error).name === 'ExitPromptError') return null
+    throw e
+  }
+}
+
+runMain(main)

package/src/client.ts

@@ -0,0 +1,42 @@
+export class BodClient {
+  constructor(
+    public url: string,
+    public apiKey: string,
+  ) {}
+
+  async request<T = unknown>(method: string, path: string, body?: unknown): Promise<T> {
+    const res = await fetch(`${this.url}/api${path}`, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    })
+    const text = await res.text()
+    if (!res.ok) {
+      throw new Error(`${method} ${path} → ${res.status}: ${text}`)
+    }
+    try { return JSON.parse(text) as T } catch { return text as T }
+  }
+
+  async upload<T = unknown>(path: string, body: ReadableStream | Uint8Array, headers: Record<string, string> = {}): Promise<T> {
+    const res = await fetch(`${this.url}/api${path}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/gzip',
+        ...(this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}),
+        ...headers,
+      },
+      body,
+    })
+    const text = await res.text()
+    if (!res.ok) throw new Error(`POST ${path} → ${res.status}: ${text}`)
+    try { return JSON.parse(text) as T } catch { return text as T }
+  }
+
+  get<T = unknown>(path: string) { return this.request<T>('GET', path) }
+  post<T = unknown>(path: string, body?: unknown) { return this.request<T>('POST', path, body) }
+  put<T = unknown>(path: string, body?: unknown) { return this.request<T>('PUT', path, body) }
+  del<T = unknown>(path: string) { return this.request<T>('DELETE', path) }
+}

package/src/commands/add.ts

@@ -0,0 +1,79 @@
+import { defineCommand } from 'citty'
+import { search, input, Separator } from '@inquirer/prompts'
+import chalk from 'chalk'
+import { loadConfig, getResolvedInstance, configExists } from '../config'
+import { BodClient } from '../client'
+
+function getRegistry(): { registryUrl: string; client: BodClient } | null {
+  if (!configExists()) return null
+  try {
+    const { url, apiKey, instance } = getResolvedInstance(loadConfig())
+    if (!instance.capabilities.registryEnabled) return null
+    return { registryUrl: `${url}/api/registry`, client: new BodClient(url, apiKey) }
+  } catch { return null }
+}
+
+type SearchResult = { total: number; objects: Array<{ package: { name: string; version: string; description?: string } }> }
+
+export default defineCommand({
+  meta: { name: 'add', description: 'Add a package (registry-aware)' },
+  args: {
+    pkg: { type: 'positional', description: 'Package name', required: false },
+  },
+  async run({ args }) {
+    const registry = getRegistry()
+    let pkg = args.pkg
+
+    // Interactive: show registry packages with search
+    if (!pkg && registry) {
+      try {
+        pkg = await search<string>({
+          message: 'Package name (search registry or type any npm package):',
+          source: async (term) => {
+            const query = term ?? ''
+            const results = await registry.client.get<SearchResult>(
+              `/registry/-/v1/search?text=${encodeURIComponent(query)}&size=20`
+            ).catch(() => ({ total: 0, objects: [] }))
+
+            const choices: Array<{ value: string; name: string; description?: string } | Separator> = results.objects.map(o => ({
+              value: o.package.name,
+              name: `${o.package.name}@${o.package.version}`,
+              description: o.package.description,
+            }))
+
+            // Allow typing an arbitrary package name
+            if (query && !results.objects.some(o => o.package.name === query)) {
+              choices.push(new Separator())
+              choices.push({ value: query, name: `${query} (npm)`, description: 'Install from npm' })
+            }
+
+            return choices
+          },
+        })
+      } catch (e) {
+        if ((e as Error).name === 'ExitPromptError') return
+        throw e
+      }
+    }
+
+    // If still no package (no registry, user didn't pick), prompt plainly
+    if (!pkg) {
+      try {
+        pkg = await input({ message: 'Package name:' })
+      } catch (e) {
+        if ((e as Error).name === 'ExitPromptError') return
+        throw e
+      }
+      if (!pkg) { console.error(chalk.red('Package name required.')); process.exit(1) }
+    }
+
+    const cmd = registry
+      ? ['bun', 'add', pkg, '--registry', registry.registryUrl]
+      : ['bun', 'add', 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/apps.ts

@@ -0,0 +1,71 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { loadConfig, getResolvedInstance } from '../config'
+import { BodClient } from '../client'
+import { printTable, printKv } from '../utils/output'
+import { resolveAppId } from '../utils/resolve'
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List all apps' },
+  async run() {
+    const { url, apiKey } = getResolvedInstance(loadConfig())
+    const client = new BodClient(url, apiKey)
+    const apps = await client.get<any[]>('/apps')
+    printTable(apps.map(a => ({
+      name: a.name,
+      domain: a.domain ?? '',
+      branch: a.productionBranch ?? 'main',
+      type: a.type ?? '',
+      repo: a.repo ?? '',
+    })))
+  },
+})
+
+const statusCmd = defineCommand({
+  meta: { name: 'status', description: 'Show app details' },
+  args: {
+    app: { type: 'positional', description: 'App name or ID', required: true },
+  },
+  async run({ args }) {
+    const { url, apiKey } = getResolvedInstance(loadConfig())
+    const client = new BodClient(url, apiKey)
+    const appId = await resolveAppId(client, args.app)
+    const detail = await client.get<any>(`/apps/${appId}`)
+
+    printKv({
+      Name: detail.name,
+      ID: detail.id,
+      Domain: detail.domain ?? '(none)',
+      Type: detail.type ?? 'auto',
+      Branch: detail.productionBranch ?? 'main',
+      Repo: detail.repo ?? '(none)',
+      Database: detail.database ? 'yes' : 'no',
+      Preview: detail.preview ? 'yes' : 'no',
+    })
+
+    if (detail.instances?.length) {
+      console.log(chalk.bold('\nInstances:'))
+      printTable(detail.instances.map((i: any) => ({
+        id: i.id?.slice(0, 8),
+        branch: i.branch,
+        status: i.status,
+        port: i.port,
+      })))
+    }
+
+    if (detail.deployments?.length) {
+      console.log(chalk.bold('\nRecent Deployments:'))
+      printTable(detail.deployments.map((d: any) => ({
+        id: d.id?.slice(0, 8),
+        branch: d.branch,
+        status: d.status,
+        created: d.createdAt ? new Date(d.createdAt).toLocaleString() : '',
+      })))
+    }
+  },
+})
+
+export default defineCommand({
+  meta: { name: 'apps', description: 'Manage apps' },
+  subCommands: { list: listCmd, status: statusCmd },
+})

package/src/commands/deploy.ts

@@ -0,0 +1,103 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { loadConfig, getResolvedInstance } from '../config'
+import { BodClient } from '../client'
+import { resolveAppId, resolveAppName } from '../utils/resolve'
+
+async function detectBranch(explicit?: string): Promise<string> {
+  if (explicit) return explicit
+  const proc = Bun.spawnSync(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
+  const branch = proc.exitCode === 0 ? proc.stdout.toString().trim() : ''
+  return branch || 'main'
+}
+
+async function uploadDeploy(client: BodClient, appId: string, branch: string) {
+  console.log(chalk.dim('Packing source...'))
+  const tar = Bun.spawn(
+    ['tar', 'cz', '--exclude=node_modules', '--exclude=.git', '--exclude=dist', '.'],
+    { stdout: 'pipe', stderr: 'pipe' },
+  )
+  await client.upload<any>(
+    `/apps/${appId}/deploy/upload`,
+    tar.stdout as ReadableStream,
+    { 'x-branch': branch },
+  )
+  const exitCode = await tar.exited
+  if (exitCode !== 0) {
+    const errText = await new Response(tar.stderr).text().catch(() => '')
+    throw new Error(`tar failed: ${errText}`)
+  }
+}
+
+async function gitDeploy(client: BodClient, appId: string, branch: string) {
+  await client.post<any>(`/apps/${appId}/deploy`, { branch })
+}
+
+async function pollDeploy(client: BodClient, appId: string, since: number) {
+  console.log(chalk.dim('Waiting for deployment...'))
+  let lastStatus = ''
+  for (let i = 0; i < 120; i++) {
+    await Bun.sleep(2000)
+    const detail = await client.get<any>(`/apps/${appId}`)
+    const deps = detail.deployments ?? []
+    // Find the deployment created after we triggered (don't fall back to older ones)
+    const latest = deps.find((d: any) => (d.createdAt ?? 0) >= since)
+    if (!latest) continue
+    const status = latest.status
+    if (status !== lastStatus) {
+      console.log(chalk.dim(`  Status: ${status}`))
+      lastStatus = status
+    }
+    if (status === 'live') {
+      console.log(chalk.green(`✓ Deployment live!`))
+      if (detail.domain) console.log(chalk.dim(`  → https://${detail.domain}`))
+      return
+    }
+    if (status === 'failed') {
+      console.error(chalk.red(`✗ Deployment failed`))
+      process.exit(1)
+    }
+  }
+  console.log(chalk.yellow('Timed out waiting. Check "bod apps status" for updates.'))
+}
+
+export default defineCommand({
+  meta: { name: 'deploy', description: 'Trigger a deployment' },
+  args: {
+    app: { type: 'positional', description: 'App name (or reads from bodify.yaml)', required: false },
+    branch: { type: 'string', description: 'Branch to deploy (default: current git 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 branch = await detectBranch(args.branch)
+    const detail = await client.get<any>(`/apps/${appId}`)
+
+    let hasRepo = !!detail.repo
+    if (!hasRepo) {
+      const proc = Bun.spawnSync(['git', 'remote', 'get-url', 'origin'])
+      const repo = proc.exitCode === 0 ? proc.stdout.toString().trim() : ''
+      if (repo) {
+        await client.put(`/apps/${appId}`, { repo })
+        console.log(chalk.dim(`Linked repo: ${repo}`))
+        hasRepo = true
+      }
+    }
+
+    console.log(chalk.dim(`Deploying ${appName} (branch: ${branch})${hasRepo ? '' : ' via upload'}...`))
+
+    const since = Date.now()
+    if (hasRepo) {
+      await gitDeploy(client, appId, branch)
+    } else {
+      await uploadDeploy(client, appId, branch)
+    }
+
+    console.log(chalk.green(`✓ Deployment queued`))
+    await pollDeploy(client, appId, since)
+  },
+})

package/src/commands/env.ts

@@ -0,0 +1,107 @@
+import { defineCommand } from 'citty'
+import chalk from 'chalk'
+import { loadConfig, getResolvedInstance } from '../config'
+import { BodClient } from '../client'
+import { resolveAppId, resolveAppName } from '../utils/resolve'
+
+const listCmd = defineCommand({
+  meta: { name: 'list', description: 'List env vars' },
+  args: {
+    app: { type: 'positional', description: 'App name (or reads from bodify.yaml)', required: false },
+  },
+  async run({ args }) {
+    const { url, apiKey } = getResolvedInstance(loadConfig())
+    const client = new BodClient(url, apiKey)
+    const appId = await resolveAppId(client, resolveAppName(args.app))
+    const detail = await client.get<any>(`/apps/${appId}`)
+    const env = detail.env ?? {}
+    if (Object.keys(env).length === 0) {
+      console.log(chalk.dim('No environment variables set.'))
+      return
+    }
+    for (const [k, v] of Object.entries(env)) console.log(`${k}=${v}`)
+  },
+})
+
+function parseDotEnv(content: string): Record<string, string> {
+  const env: Record<string, string> = {}
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+    const eqIdx = trimmed.indexOf('=')
+    if (eqIdx === -1) continue
+    const key = trimmed.slice(0, eqIdx).trim()
+    let value = trimmed.slice(eqIdx + 1).trim()
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+      value = value.slice(1, -1)
+    env[key] = value
+  }
+  return env
+}
+
+const setCmd = defineCommand({
+  meta: { name: 'set', description: 'Set env var (KEY=VALUE or --file .env)' },
+  args: {
+    app: { type: 'positional', description: 'App name (or reads from bodify.yaml)', required: false },
+    pair: { type: 'positional', description: 'KEY=VALUE', required: false },
+    file: { type: 'string', alias: 'f', description: 'Path to .env file' },
+  },
+  async run({ args }) {
+    const { url, apiKey } = getResolvedInstance(loadConfig())
+    const client = new BodClient(url, apiKey)
+    const appId = await resolveAppId(client, resolveAppName(args.app))
+    const detail = await client.get<any>(`/apps/${appId}`)
+    const existing = detail.env ?? {}
+
+    if (args.file) {
+      const f = Bun.file(args.file)
+      if (!(await f.exists())) {
+        console.error(chalk.red(`File not found: ${args.file}`))
+        process.exit(1)
+      }
+      const content = await f.text()
+      const parsed = parseDotEnv(content)
+      const keys = Object.keys(parsed)
+      if (keys.length === 0) {
+        console.error(chalk.red('No variables found in file.'))
+        process.exit(1)
+      }
+      await client.put(`/apps/${appId}`, { env: { ...existing, ...parsed } })
+      console.log(chalk.green(`✓ Set ${keys.length} var(s): ${keys.join(', ')}`))
+      return
+    }
+
+    if (!args.pair || !args.pair.includes('=')) {
+      console.error(chalk.red('Format: bod env set <app> KEY=VALUE  or  bod env set <app> -f .env'))
+      process.exit(1)
+    }
+    const [key, ...vals] = args.pair.split('=')
+    const value = vals.join('=')
+    await client.put(`/apps/${appId}`, { env: { ...existing, [key]: value } })
+    console.log(chalk.green(`✓ Set ${key}`))
+  },
+})
+
+const unsetCmd = defineCommand({
+  meta: { name: 'unset', description: 'Remove env var' },
+  args: {
+    app: { type: 'positional', description: 'App name (or reads from bodify.yaml)', required: false },
+    key: { type: 'positional', description: 'Variable name', required: true },
+  },
+  async run({ args }) {
+    const { url, apiKey } = getResolvedInstance(loadConfig())
+    const client = new BodClient(url, apiKey)
+    const appId = await resolveAppId(client, resolveAppName(args.app))
+
+    const detail = await client.get<any>(`/apps/${appId}`)
+    const env = { ...(detail.env ?? {}) }
+    delete env[args.key]
+    await client.put(`/apps/${appId}`, { env })
+    console.log(chalk.green(`✓ Removed ${args.key}`))
+  },
+})
+
+export default defineCommand({
+  meta: { name: 'env', description: 'Manage environment variables' },
+  subCommands: { list: listCmd, set: setCmd, unset: unsetCmd },
+})