crawd 0.8.0

package/src/commands/start.ts

@@ -0,0 +1,120 @@
+import { spawn } from 'child_process'
+import { existsSync, openSync, mkdirSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { isRunning, writePid } from '../daemon/pid.js'
+import { log, fmt, printHeader, printKv } from '../utils/logger.js'
+import { LOGS_DIR, LOG_FILES, PIDS_DIR } from '../utils/paths.js'
+import { loadConfig, loadEnv } from '../config/store.js'
+import type { Config } from '../config/schema.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+/** Resolve the backend entry point (src/backend/index.ts relative to package root) */
+function getBackendEntry(): string {
+  // From src/commands/ (dev with tsx)
+  const fromSrc = join(__dirname, '..', 'backend', 'index.ts')
+  if (existsSync(fromSrc)) return fromSrc
+
+  // From dist/ (built cli.js)
+  const fromDist = join(__dirname, '..', 'src', 'backend', 'index.ts')
+  if (existsSync(fromDist)) return fromDist
+
+  throw new Error('Backend entry point not found')
+}
+
+/** Build env vars from config + secrets for the backend process */
+function buildEnv(config: Config): NodeJS.ProcessEnv {
+  const secrets = loadEnv()
+  const env: NodeJS.ProcessEnv = { ...process.env }
+
+  // Secrets from ~/.crawd/.env
+  for (const [key, value] of Object.entries(secrets)) {
+    env[key] = value
+  }
+
+  // Config from ~/.crawd/config.json
+  env.PORT = String(config.ports.backend)
+  env.BACKEND_URL = `http://localhost:${config.ports.backend}`
+  env.OPENCLAW_GATEWAY_URL = config.gateway.url
+  env.CRAWD_CHANNEL_ID = config.gateway.channelId
+  env.TTS_CHAT_PROVIDER = config.tts.chatProvider
+  env.TTS_CHAT_VOICE = config.tts.chatVoice
+  env.TTS_BOT_PROVIDER = config.tts.botProvider
+  env.TTS_BOT_VOICE = config.tts.botVoice
+  if (config.chat.pumpfun) {
+    env.PUMPFUN_ENABLED = String(config.chat.pumpfun.enabled)
+    if (config.chat.pumpfun.tokenMint) {
+      env.NEXT_PUBLIC_TOKEN_MINT = config.chat.pumpfun.tokenMint
+    }
+  }
+  // Vibe state machine
+  env.VIBE_ENABLED = String(config.vibe.enabled)
+  env.VIBE_INTERVAL_MS = String(config.vibe.interval * 1000)
+  env.IDLE_AFTER_MS = String(config.vibe.idleAfter * 1000)
+  env.SLEEP_AFTER_IDLE_MS = String((config.vibe.sleepAfter - config.vibe.idleAfter) * 1000)
+
+  env.YOUTUBE_ENABLED = String(config.chat.youtube.enabled)
+  if (config.chat.youtube.videoId) {
+    env.YOUTUBE_VIDEO_ID = config.chat.youtube.videoId
+  }
+
+  return env
+}
+
+export async function startCommand() {
+  if (isRunning('crawdbot')) {
+    const config = loadConfig()
+    log.warn('Backend is already running')
+    printKv('Backend', fmt.url(`http://localhost:${config.ports.backend}`))
+    log.dim('Use `crawd stop` to stop it first')
+    return
+  }
+
+  const backendEntry = getBackendEntry()
+
+  // Ensure dirs
+  for (const dir of [LOGS_DIR, PIDS_DIR]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+  }
+
+  const config = loadConfig()
+  const env = buildEnv(config)
+
+  log.info('Starting CrawdBot backend...')
+
+  const logFd = openSync(LOG_FILES.crawdbot, 'a')
+
+  const child = spawn('bun', ['run', backendEntry], {
+    cwd: join(dirname(backendEntry), '..', '..'),
+    env,
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+  })
+
+  child.unref()
+
+  if (child.pid) {
+    writePid('crawdbot', child.pid)
+  }
+
+  // Wait for it to start
+  await new Promise((r) => setTimeout(r, 1500))
+
+  if (isRunning('crawdbot')) {
+    printHeader('CrawdBot started')
+    console.log()
+    log.success(`Backend running (PID ${child.pid})`)
+    printKv('Backend', fmt.url(`http://localhost:${config.ports.backend}`))
+    console.log()
+    log.dim('View logs: crawd logs')
+    log.dim('Stop: crawd stop')
+  } else {
+    log.error('Backend failed to start')
+    log.dim(`Check logs: tail ${LOG_FILES.crawdbot}`)
+    process.exit(1)
+  }
+}

package/src/commands/status.ts

@@ -0,0 +1,73 @@
+import { loadApiKey } from '../config/store.js'
+import { log, fmt } from '../utils/logger.js'
+
+const PLATFORM_URL = 'https://platform.crawd.bot'
+
+export async function statusCommand() {
+  const apiKey = loadApiKey()
+
+  console.log()
+  console.log(fmt.bold('crawd.bot CLI'))
+  console.log()
+
+  if (!apiKey) {
+    log.warn('Not authenticated')
+    log.dim('Run: crawd auth')
+    console.log()
+    return
+  }
+
+  log.info('Fetching stream status...')
+
+  try {
+    const response = await fetch(`${PLATFORM_URL}/api/stream`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    })
+
+    if (response.status === 401) {
+      log.error('Authentication expired')
+      log.dim('Run: crawd auth')
+      return
+    }
+
+    const data = await response.json()
+
+    if (data.error) {
+      log.error(data.error)
+      return
+    }
+
+    const { stream } = data
+
+    console.log()
+    console.log(fmt.bold('Stream Status'))
+    console.log()
+
+    if (stream.isLive) {
+      console.log(`  Status:     ${fmt.success('● LIVE')}`)
+    } else {
+      console.log(`  Status:     ${fmt.dim('○ Offline')}`)
+    }
+
+    console.log(`  Name:       ${stream.name}`)
+    console.log(`  Viewers:    ${stream.viewerCount}`)
+    console.log()
+    console.log(fmt.bold('OBS Settings'))
+    console.log()
+    console.log(`  Server:     ${fmt.dim(stream.rtmpUrl)}`)
+    console.log(`  Stream Key: ${fmt.dim(stream.streamKey.slice(0, 20) + '...')}`)
+
+    if (stream.playbackId) {
+      console.log()
+      console.log(fmt.bold('Preview'))
+      console.log()
+      console.log(`  ${fmt.url(`${PLATFORM_URL}/preview/${stream.playbackId}`)}`)
+    }
+
+    console.log()
+  } catch (err) {
+    log.error(`Failed to fetch status: ${err instanceof Error ? err.message : err}`)
+  }
+}

package/src/commands/stop.ts

@@ -0,0 +1,16 @@
+import { isRunning, killProcess } from '../daemon/pid.js'
+import { log } from '../utils/logger.js'
+
+export function stopCommand() {
+  if (!isRunning('crawdbot')) {
+    log.dim('CrawdBot backend is not running')
+    return
+  }
+
+  const killed = killProcess('crawdbot')
+  if (killed) {
+    log.success('CrawdBot backend stopped')
+  } else {
+    log.error('Failed to stop CrawdBot backend')
+  }
+}

package/src/commands/stream-key.ts

@@ -0,0 +1,45 @@
+import { loadApiKey } from '../config/store.js'
+import { log, printHeader, printKv } from '../utils/logger.js'
+
+const PLATFORM_URL = 'https://platform.crawd.bot'
+
+export async function streamKeyCommand() {
+  const apiKey = loadApiKey()
+
+  if (!apiKey) {
+    log.error('Not authenticated. Run: crawd auth')
+    process.exit(1)
+  }
+
+  try {
+    const response = await fetch(`${PLATFORM_URL}/api/stream`, {
+      headers: { 'Authorization': `Bearer ${apiKey}` },
+    })
+
+    if (response.status === 401) {
+      log.error('Authentication expired. Run: crawd auth')
+      process.exit(1)
+    }
+
+    const data = await response.json() as { error?: string; stream?: { rtmpUrl: string; streamKey: string } }
+
+    if (data.error) {
+      log.error(data.error)
+      process.exit(1)
+    }
+
+    if (!data.stream) {
+      log.error('No stream data returned')
+      process.exit(1)
+    }
+
+    printHeader('OBS Settings')
+    console.log()
+    printKv('Server', data.stream.rtmpUrl)
+    printKv('Stream Key', data.stream.streamKey)
+    console.log()
+  } catch (err) {
+    log.error(`Failed to fetch stream key: ${err instanceof Error ? err.message : err}`)
+    process.exit(1)
+  }
+}

package/src/commands/talk.ts

@@ -0,0 +1,30 @@
+import { loadConfig } from '../config/store.js'
+import { log } from '../utils/logger.js'
+
+export async function talkCommand(message: string) {
+  const config = loadConfig()
+  const port = config.ports.backend
+  const url = `http://localhost:${port}/crawd/talk`
+
+  const body = { message }
+
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}))
+      log.error((data as { error?: string }).error ?? `Request failed (${res.status})`)
+      process.exit(1)
+    }
+
+    log.success(`Sent: "${message}"`)
+  } catch {
+    log.error('Could not reach the backend daemon. Is it running?')
+    log.dim('Start with: crawd start')
+    process.exit(1)
+  }
+}

package/src/commands/up.ts

@@ -0,0 +1,59 @@
+import { loadConfig } from '../config/store.js'
+import { startAll, ensureDirectories, ensureOverlay } from '../daemon/manager.js'
+import { getProcessStatus } from '../daemon/pid.js'
+import { log, fmt, printHeader, printKv } from '../utils/logger.js'
+
+export async function upCommand(options: { force?: boolean }) {
+  const status = getProcessStatus()
+
+  if (status.backend.running && status.overlay.running) {
+    log.warn('crawd.bot is already running')
+    log.dim('Use `crawd restart` to restart, or `crawd down` to stop')
+    return
+  }
+
+  ensureDirectories()
+
+  if (options.force) {
+    ensureOverlay(true)
+  }
+
+  try {
+    await startAll()
+
+    const config = loadConfig()
+
+    // Wait a moment for processes to start
+    await new Promise((r) => setTimeout(r, 1000))
+
+    const newStatus = getProcessStatus()
+
+    printHeader('crawd.bot is starting...')
+    console.log()
+
+    if (newStatus.backend.running) {
+      log.success(`Backend running (PID ${newStatus.backend.pid})`)
+    } else {
+      log.error('Backend failed to start - check logs with `crawd logs`')
+    }
+
+    if (newStatus.overlay.running) {
+      log.success(`Overlay running (PID ${newStatus.overlay.pid})`)
+    } else {
+      log.error('Overlay failed to start - check logs with `crawd logs`')
+    }
+
+    console.log()
+    printHeader('URLs')
+    printKv('Overlay', fmt.url(`http://localhost:${config.ports.overlay}`))
+    printKv('Backend', fmt.url(`http://localhost:${config.ports.backend}`))
+    printKv('OBS Source', fmt.url(`http://localhost:${config.ports.overlay}`))
+
+    console.log()
+    log.dim('View logs with: crawd logs')
+    log.dim('Stop with: crawd down')
+  } catch (err) {
+    log.error(`Failed to start: ${err}`)
+    process.exit(1)
+  }
+}

package/src/commands/update.ts

@@ -0,0 +1,92 @@
+import { execSync } from 'child_process'
+import { realpathSync } from 'fs'
+import { isRunning, killProcess, readPid, isProcessRunning } from '../daemon/pid.js'
+import { log } from '../utils/logger.js'
+import { startCommand } from './start.js'
+
+type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun'
+
+const INSTALL_CMD: Record<PackageManager, string> = {
+  npm: 'npm install -g @crawd/cli@latest',
+  pnpm: 'pnpm add -g @crawd/cli@latest',
+  yarn: 'yarn global add @crawd/cli@latest',
+  bun: 'bun install -g @crawd/cli@latest',
+}
+
+/** Detect which package manager installed the CLI by resolving the binary path */
+function detectPackageManager(): PackageManager {
+  try {
+    const bin = execSync('which crawd', { encoding: 'utf-8' }).trim()
+    const resolved = realpathSync(bin)
+
+    if (resolved.includes('/pnpm')) return 'pnpm'
+    if (resolved.includes('/.bun/')) return 'bun'
+    if (resolved.includes('/.yarn/') || resolved.includes('/yarn/')) return 'yarn'
+  } catch {
+    // which failed or path unresolvable — fall through
+  }
+  return 'npm'
+}
+
+/** Wait for a process to exit (up to timeoutMs) */
+function waitForExit(pid: number, timeoutMs = 5000): boolean {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    if (!isProcessRunning(pid)) return true
+    execSync('sleep 0.1')
+  }
+  return false
+}
+
+export async function updateCommand() {
+  const daemonWasRunning = isRunning('crawdbot')
+  const oldPid = readPid('crawdbot')
+
+  // 1. Stop daemon if running
+  if (daemonWasRunning && oldPid) {
+    log.info('Stopping backend daemon...')
+    killProcess('crawdbot')
+
+    if (!waitForExit(oldPid)) {
+      log.error('Backend daemon did not stop in time')
+      process.exit(1)
+    }
+    log.success('Backend daemon stopped')
+  }
+
+  // 2. Detect package manager and update
+  const pm = detectPackageManager()
+  const cmd = INSTALL_CMD[pm]
+  log.info(`Updating @crawd/cli via ${pm}...`)
+
+  try {
+    const output = execSync(`${cmd} 2>&1`, {
+      encoding: 'utf-8',
+      timeout: 60_000,
+    })
+
+    const versionMatch = output.match(/@crawd\/cli@([\d.]+)/)
+    if (versionMatch) {
+      log.success(`Updated to v${versionMatch[1]}`)
+    } else {
+      log.success('CLI updated')
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    log.error(`Failed to update: ${msg}`)
+    // Still restart daemon if it was running
+    if (daemonWasRunning) {
+      log.info('Restarting backend daemon with current version...')
+      await startCommand()
+    }
+    process.exit(1)
+  }
+
+  // 3. Restart daemon if it was running
+  if (daemonWasRunning) {
+    log.info('Restarting backend daemon...')
+    await startCommand()
+  } else {
+    log.dim('Backend daemon was not running, skipping restart')
+  }
+}

package/src/config/schema.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod'
+
+const ttsProviderEnum = z.enum(['openai', 'elevenlabs', 'tiktok'])
+
+export const ConfigSchema = z.object({
+  /** Gateway configuration */
+  gateway: z.object({
+    url: z.string().default('ws://localhost:18789'),
+    /** Channel ID for the agent session */
+    channelId: z.string().default('agent:main:crawd:live'),
+  }).default({}),
+
+  /** Server ports */
+  ports: z.object({
+    backend: z.number().default(4000),
+    overlay: z.number().default(3000),
+  }).default({}),
+
+  /** TTS configuration */
+  tts: z.object({
+    /** Provider for reading chat messages aloud */
+    chatProvider: ttsProviderEnum.default('tiktok'),
+    /** Voice ID for chat TTS (must match chatProvider) */
+    chatVoice: z.string().default('en_us_002'),
+    /** Provider for bot speech */
+    botProvider: ttsProviderEnum.default('elevenlabs'),
+    /** Voice ID for bot TTS (must match botProvider) */
+    botVoice: z.string().default('TX3LPaxmHKxFdv7VOQHJ'),
+  }).default({}),
+
+  /** Chat platform configuration */
+  chat: z.object({
+    pumpfun: z.object({
+      enabled: z.boolean().default(false),
+      tokenMint: z.string().optional(),
+    }).optional(),
+    youtube: z.object({
+      enabled: z.boolean().default(false),
+      videoId: z.string().optional(),
+    }).default({}),
+  }).default({}),
+
+  /** Autonomous vibing state machine */
+  vibe: z.object({
+    /** Enable autonomous vibing (agent acts on its own between chat messages) */
+    enabled: z.boolean().default(true),
+    /** Seconds between vibe pings while active */
+    interval: z.number().default(30),
+    /** Seconds of inactivity before going idle */
+    idleAfter: z.number().default(180),
+    /** Seconds of inactivity before going to sleep (must be > idleAfter) */
+    sleepAfter: z.number().default(360),
+  }).default({}),
+
+  /** Stream configuration */
+  stream: z.object({
+    /** RTMP stream key for pump.fun */
+    key: z.string().optional(),
+  }).default({}),
+
+})
+
+export type Config = z.infer<typeof ConfigSchema>
+
+/** Default configuration */
+export const DEFAULT_CONFIG: Config = ConfigSchema.parse({})

package/src/config/store.ts

@@ -0,0 +1,185 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { dirname } from 'path'
+import { CONFIG_PATH, CRAWD_HOME, ENV_PATH } from '../utils/paths.js'
+import { Config, ConfigSchema, DEFAULT_CONFIG } from './schema.js'
+
+/** Ensure the crawd home directory exists */
+export function ensureHome() {
+  if (!existsSync(CRAWD_HOME)) {
+    mkdirSync(CRAWD_HOME, { recursive: true })
+  }
+}
+
+/** Load configuration from disk */
+export function loadConfig(): Config {
+  ensureHome()
+
+  if (!existsSync(CONFIG_PATH)) {
+    return DEFAULT_CONFIG
+  }
+
+  try {
+    const raw = readFileSync(CONFIG_PATH, 'utf-8')
+    const parsed = JSON.parse(raw)
+    return ConfigSchema.parse(parsed)
+  } catch (e) {
+    console.warn('Failed to parse config, using defaults:', e)
+    return DEFAULT_CONFIG
+  }
+}
+
+/** Save configuration to disk */
+export function saveConfig(config: Config) {
+  ensureHome()
+  const dir = dirname(CONFIG_PATH)
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2))
+}
+
+/** Update specific config values (deep merge) */
+export function updateConfig(updates: Partial<Config>) {
+  const current = loadConfig()
+  const merged = deepMerge(current, updates)
+  const validated = ConfigSchema.parse(merged)
+  saveConfig(validated)
+  return validated
+}
+
+/** Get a specific config value by dot-notation path */
+export function getConfigValue(path: string): unknown {
+  const config = loadConfig()
+  return getByPath(config, path)
+}
+
+/** Set a specific config value by dot-notation path */
+export function setConfigValue(path: string, value: unknown) {
+  // Read raw JSON (without Zod defaults) so we only persist explicit values
+  let raw: Record<string, unknown> = {}
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      raw = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'))
+    } catch { /* start fresh */ }
+  }
+  setByPath(raw, path, value)
+  // Validate through Zod — throws on invalid values
+  const validated = ConfigSchema.parse(raw)
+  // Save raw JSON (only user-set values, not all defaults)
+  ensureHome()
+  const dir = dirname(CONFIG_PATH)
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2))
+  return validated
+}
+
+/** Load secrets from ~/.crawd/.env */
+export function loadEnv(): Record<string, string> {
+  if (!existsSync(ENV_PATH)) return {}
+
+  const content = readFileSync(ENV_PATH, 'utf-8')
+  const env: Record<string, string> = {}
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+    const eqIndex = trimmed.indexOf('=')
+    if (eqIndex === -1) continue
+    const key = trimmed.slice(0, eqIndex).trim()
+    let value = trimmed.slice(eqIndex + 1).trim()
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1)
+    }
+    env[key] = value
+  }
+
+  return env
+}
+
+/** Save secrets to ~/.crawd/.env */
+export function saveEnv(env: Record<string, string>) {
+  ensureHome()
+  const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`)
+  writeFileSync(ENV_PATH, lines.join('\n') + '\n')
+}
+
+/** Load API key from ~/.crawd/.env */
+export function loadApiKey(): string | null {
+  const env = loadEnv()
+  return env.CRAWD_API_KEY ?? null
+}
+
+/** Known .env keys — included with empty defaults so users can see what's available */
+const ENV_TEMPLATE_KEYS = [
+  'CRAWD_API_KEY',
+  'OPENAI_API_KEY',
+  'ELEVENLABS_API_KEY',
+  'TIKTOK_SESSION_ID',
+  'OPENCLAW_GATEWAY_TOKEN',
+]
+
+/** Save API key to ~/.crawd/.env, seeding empty placeholders for known keys */
+export function saveApiKey(apiKey: string) {
+  const env = loadEnv()
+  for (const key of ENV_TEMPLATE_KEYS) {
+    if (!(key in env)) env[key] = ''
+  }
+  env.CRAWD_API_KEY = apiKey
+  saveEnv(env)
+}
+
+// Helper functions
+
+function deepMerge<T extends Record<string, unknown>>(
+  target: T,
+  source: Partial<T>
+): T {
+  const result = { ...target }
+  for (const key of Object.keys(source) as (keyof T)[]) {
+    const sourceVal = source[key]
+    const targetVal = target[key]
+
+    if (
+      sourceVal !== undefined &&
+      typeof sourceVal === 'object' &&
+      sourceVal !== null &&
+      !Array.isArray(sourceVal) &&
+      typeof targetVal === 'object' &&
+      targetVal !== null
+    ) {
+      result[key] = deepMerge(
+        targetVal as Record<string, unknown>,
+        sourceVal as Record<string, unknown>
+      ) as T[keyof T]
+    } else if (sourceVal !== undefined) {
+      result[key] = sourceVal as T[keyof T]
+    }
+  }
+  return result
+}
+
+function getByPath(obj: unknown, path: string): unknown {
+  const parts = path.split('.')
+  let current = obj
+  for (const part of parts) {
+    if (current === null || current === undefined) return undefined
+    current = (current as Record<string, unknown>)[part]
+  }
+  return current
+}
+
+function setByPath(obj: unknown, path: string, value: unknown) {
+  const parts = path.split('.')
+  let current = obj as Record<string, unknown>
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i]
+    if (!(part in current) || typeof current[part] !== 'object') {
+      current[part] = {}
+    }
+    current = current[part] as Record<string, unknown>
+  }
+  current[parts[parts.length - 1]] = value
+}