bod-cli 0.3.1

package/src/commands/ssh.ts

@@ -0,0 +1,48 @@
+import { defineCommand } from 'citty'
+import { existsSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import { loadConfig, getResolvedInstance } from '../config'
+
+function resolveKeyPath(explicit?: string): string | undefined {
+  if (explicit && existsSync(explicit)) return explicit
+  if (process.env.SSH_KEY_PATH && existsSync(process.env.SSH_KEY_PATH)) return process.env.SSH_KEY_PATH
+  // Well-known location
+  const wellKnown = join(homedir(), '.bod-cloud/keys/bod-cloud_ed25519')
+  if (existsSync(wellKnown)) return wellKnown
+  return undefined
+}
+
+export default defineCommand({
+  meta: { name: 'ssh', description: 'SSH into the remote Bodify server' },
+  args: {
+    user: { type: 'string', description: 'SSH user (default: root)' },
+    port: { type: 'string', description: 'SSH port (default: 22)' },
+    key: { type: 'string', description: 'SSH private key path' },
+    command: { type: 'string', alias: 'c', description: 'Command to execute on remote host' },
+  },
+  async run({ args, rawArgs }) {
+    const { url } = getResolvedInstance(loadConfig())
+    const host = new URL(url).hostname
+
+    const sshArgs: string[] = []
+    const keyPath = resolveKeyPath(args.key)
+    if (keyPath) sshArgs.push('-i', keyPath)
+    if (args.port) sshArgs.push('-p', args.port)
+    sshArgs.push(args.user ? `${args.user}@${host}` : `root@${host}`)
+
+    // Remote command via -c "cmd" or -- cmd arg1 arg2
+    const dashDashIdx = rawArgs?.indexOf('--') ?? -1
+    const remoteCmd = dashDashIdx >= 0
+      ? rawArgs!.slice(dashDashIdx + 1).join(' ')
+      : args.command
+    if (remoteCmd) sshArgs.push(remoteCmd)
+
+    const proc = Bun.spawn(['ssh', ...sshArgs], {
+      stdout: 'inherit',
+      stderr: 'inherit',
+      stdin: 'inherit',
+    })
+    process.exitCode = await proc.exited
+  },
+})

package/src/config.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod'
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs'
+import { homedir } from 'os'
+import { join, dirname } from 'path'
+
+const InstanceSchema = z.object({
+  url: z.string().url(),
+  apiKey: z.string(),
+  capabilities: z.object({
+    registryEnabled: z.boolean().default(false),
+    baseDomain: z.string().nullable().default(null),
+    githubConfigured: z.boolean().default(false),
+  }).default({}),
+})
+
+const ConfigSchema = z.object({
+  instances: z.record(z.string(), InstanceSchema),
+  defaultInstance: z.string().nullable().default(null),
+})
+
+export type Config = z.infer<typeof ConfigSchema>
+export type Instance = z.infer<typeof InstanceSchema>
+
+export const DEFAULT_CONFIG_PATH = join(homedir(), '.bod', 'config.json')
+
+export function resolveToken(token: string): string {
+  let envKey: string | undefined
+  if (token.startsWith('$')) envKey = token.slice(1)
+  else if (token.startsWith('env:')) envKey = token.slice(4)
+  if (!envKey) return token
+  const value = process.env[envKey]
+  if (!value) throw new Error(`Environment variable "${envKey}" is not set (referenced in config)`)
+  return value
+}
+
+export function configExists(configPath?: string): boolean {
+  return existsSync(configPath ?? DEFAULT_CONFIG_PATH)
+}
+
+export function loadConfig(configPath?: string): Config {
+  const path = configPath ?? DEFAULT_CONFIG_PATH
+  if (!existsSync(path)) {
+    throw new Error(`Config not found: ${path}\nRun "bod login <url>" first.`)
+  }
+  const raw = JSON.parse(readFileSync(path, 'utf-8'))
+  return ConfigSchema.parse(raw)
+}
+
+export function writeConfig(config: Config, configPath?: string): void {
+  const validated = ConfigSchema.parse(config)
+  const path = configPath ?? DEFAULT_CONFIG_PATH
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, JSON.stringify(validated, null, 2), { mode: 0o600 })
+}
+
+export function getDefaultInstance(config: Config): { name: string; instance: Instance } {
+  const name = config.defaultInstance
+  if (!name || !config.instances[name]) {
+    const first = Object.keys(config.instances)[0]
+    if (!first) throw new Error('No instances configured. Run "bod login <url>" first.')
+    return { name: first, instance: config.instances[first] }
+  }
+  return { name, instance: config.instances[name] }
+}
+
+/** Override instance from --instance flag or BOD_INSTANCE env var */
+let instanceOverride: string | undefined
+
+export function setInstanceOverride(name: string | undefined) {
+  instanceOverride = name
+}
+
+export function getResolvedInstance(config: Config): { name: string; url: string; apiKey: string; instance: Instance } {
+  const override = instanceOverride ?? process.env.BOD_INSTANCE
+  if (override) {
+    const inst = config.instances[override]
+    if (!inst) throw new Error(`Instance "${override}" not found in config. Available: ${Object.keys(config.instances).join(', ')}`)
+    return { name: override, url: inst.url, apiKey: resolveToken(inst.apiKey), instance: inst }
+  }
+  const { name, instance } = getDefaultInstance(config)
+  return { name, url: instance.url, apiKey: resolveToken(instance.apiKey), instance }
+}

package/src/utils/logger.ts

@@ -0,0 +1,20 @@
+const DEBUG = process.env.DEBUG ?? ''
+
+function shouldLog(component: string): boolean {
+  if (!DEBUG) return false
+  if (DEBUG === '*') return true
+  return DEBUG.split(',').some(p => p.trim() === component)
+}
+
+function createLogger(component: string) {
+  const prefix = `[${component}]`
+  return {
+    debug: (...args: unknown[]) => shouldLog(component) && console.debug(prefix, ...args),
+    verbose: (...args: unknown[]) => shouldLog(component) && console.log(prefix, ...args),
+    info: (...args: unknown[]) => console.log(prefix, ...args),
+    warn: (...args: unknown[]) => console.warn(prefix, ...args),
+    error: (...args: unknown[]) => console.error(prefix, ...args),
+  }
+}
+
+export const logger = { forComponent: createLogger }

package/src/utils/output.ts

@@ -0,0 +1,26 @@
+import Table from 'cli-table3'
+import chalk from 'chalk'
+
+export function printTable(rows: Record<string, unknown>[], columns?: string[]) {
+  if (rows.length === 0) { console.log(chalk.dim('(none)')); return }
+  const keys = columns ?? Object.keys(rows[0])
+  const table = new Table({
+    head: keys.map(k => chalk.bold(k)),
+    style: { head: [], border: [] },
+  })
+  for (const row of rows) {
+    table.push(keys.map(k => String(row[k] ?? '')))
+  }
+  console.log(table.toString())
+}
+
+export function printJson(data: unknown) {
+  console.log(JSON.stringify(data, null, 2))
+}
+
+export function printKv(entries: Record<string, unknown>) {
+  const maxKey = Math.max(...Object.keys(entries).map(k => k.length))
+  for (const [k, v] of Object.entries(entries)) {
+    console.log(`${chalk.bold(k.padEnd(maxKey))}  ${v}`)
+  }
+}

package/src/utils/resolve.ts

@@ -0,0 +1,32 @@
+import chalk from 'chalk'
+import { readFileSync } from 'fs'
+import { BodClient } from '../client'
+
+export async function resolveAppId(client: BodClient, nameOrId: string): Promise<string> {
+  const apps = await client.get<any[]>('/apps')
+  const match = apps.find(a => a.name === nameOrId || a.id === nameOrId)
+  if (!match) {
+    console.error(chalk.red(`App not found: ${nameOrId}`))
+    process.exit(1)
+  }
+  return match.id
+}
+
+export function readAppNameFromYaml(): string | undefined {
+  try {
+    const yaml = readFileSync('bodify.yaml', 'utf-8')
+    return yaml.match(/name:\s*(.+)/)?.[1]?.trim()
+  } catch { return undefined }
+}
+
+/** Resolve app name from explicit arg or bodify.yaml fallback. Logs clearly when falling back. */
+export function resolveAppName(arg: string | undefined): string {
+  if (arg) return arg
+  const name = readAppNameFromYaml()
+  if (!name) {
+    console.error(chalk.red('App name required. Pass <app> or run from a directory with bodify.yaml'))
+    process.exit(1)
+  }
+  console.log(chalk.dim(`Using app "${name}" from bodify.yaml`))
+  return name
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"]
+}