crawd 0.8.0

package/dist/cli.js

@@ -0,0 +1,975 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import { createServer } from "http";
+import open from "open";
+
+// src/config/store.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var CRAWD_HOME = join(homedir(), ".crawd");
+var CONFIG_PATH = join(CRAWD_HOME, "config.json");
+var ENV_PATH = join(CRAWD_HOME, ".env");
+var PIDS_DIR = join(CRAWD_HOME, "pids");
+var LOGS_DIR = join(CRAWD_HOME, "logs");
+var OVERLAY_DIR = join(CRAWD_HOME, "overlay");
+var TTS_CACHE_DIR = join(CRAWD_HOME, "tts");
+var BACKEND_TEMPLATE_DIR = join(__dirname, "../backend");
+var BACKEND_DIR = join(CRAWD_HOME, "backend");
+var PID_FILES = {
+  backend: join(PIDS_DIR, "backend.pid"),
+  overlay: join(PIDS_DIR, "overlay.pid"),
+  crawdbot: join(PIDS_DIR, "crawdbot.pid")
+};
+var LOG_FILES = {
+  backend: join(LOGS_DIR, "backend.log"),
+  overlay: join(LOGS_DIR, "overlay.log"),
+  crawdbot: join(LOGS_DIR, "crawdbot.log")
+};
+
+// src/config/schema.ts
+import { z } from "zod";
+var ttsProviderEnum = z.enum(["openai", "elevenlabs", "tiktok"]);
+var 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(4e3),
+    overlay: z.number().default(3e3)
+  }).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({})
+});
+var DEFAULT_CONFIG = ConfigSchema.parse({});
+
+// src/config/store.ts
+function ensureHome() {
+  if (!existsSync(CRAWD_HOME)) {
+    mkdirSync(CRAWD_HOME, { recursive: true });
+  }
+}
+function loadConfig() {
+  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;
+  }
+}
+function getConfigValue(path) {
+  const config = loadConfig();
+  return getByPath(config, path);
+}
+function setConfigValue(path, value) {
+  let raw = {};
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    } catch {
+    }
+  }
+  setByPath(raw, path, value);
+  const validated = ConfigSchema.parse(raw);
+  ensureHome();
+  const dir = dirname2(CONFIG_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2));
+  return validated;
+}
+function loadEnv() {
+  if (!existsSync(ENV_PATH)) return {};
+  const content = readFileSync(ENV_PATH, "utf-8");
+  const env = {};
+  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;
+}
+function saveEnv(env) {
+  ensureHome();
+  const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`);
+  writeFileSync(ENV_PATH, lines.join("\n") + "\n");
+}
+function loadApiKey() {
+  const env = loadEnv();
+  return env.CRAWD_API_KEY ?? null;
+}
+var ENV_TEMPLATE_KEYS = [
+  "CRAWD_API_KEY",
+  "OPENAI_API_KEY",
+  "ELEVENLABS_API_KEY",
+  "TIKTOK_SESSION_ID",
+  "OPENCLAW_GATEWAY_TOKEN"
+];
+function saveApiKey(apiKey) {
+  const env = loadEnv();
+  for (const key of ENV_TEMPLATE_KEYS) {
+    if (!(key in env)) env[key] = "";
+  }
+  env.CRAWD_API_KEY = apiKey;
+  saveEnv(env);
+}
+function getByPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setByPath(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  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];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var log = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2713"), msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.log(chalk.red("\u2717"), msg),
+  dim: (msg) => console.log(chalk.dim(msg))
+};
+var fmt = {
+  url: (url) => chalk.cyan.underline(url),
+  path: (path) => chalk.yellow(path),
+  cmd: (cmd) => chalk.green(cmd),
+  bold: (s) => chalk.bold(s),
+  dim: (s) => chalk.dim(s),
+  success: (s) => chalk.green(s)
+};
+function printKv(label, value, indent = 2) {
+  const padding = " ".repeat(indent);
+  console.log(`${padding}${chalk.dim(label + ":")} ${value}`);
+}
+function printHeader(title) {
+  console.log();
+  console.log(chalk.bold(title));
+}
+
+// src/commands/auth.ts
+var PLATFORM_URL = "https://platform.crawd.bot";
+var CALLBACK_PORT = 9876;
+async function fetchMe(apiKey) {
+  try {
+    const response = await fetch(`${PLATFORM_URL}/api/me`, {
+      headers: { "Authorization": `Bearer ${apiKey}` }
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function authCommand() {
+  const apiKey = loadApiKey();
+  if (apiKey) {
+    const me = await fetchMe(apiKey);
+    if (me) {
+      printHeader("Authenticated");
+      console.log();
+      printKv("Account", me.email);
+      if (me.displayName) printKv("Name", me.displayName);
+      printKv("Credentials", fmt.path(ENV_PATH));
+      console.log();
+      log.dim("To re-authenticate, run: crawd auth --force");
+      console.log();
+      return;
+    }
+    log.warn("Existing credential is invalid or expired");
+    console.log();
+  }
+  startAuthFlow();
+}
+async function authForceCommand() {
+  startAuthFlow();
+}
+function startAuthFlow() {
+  log.info("Starting authentication...");
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+    if (url.pathname === "/callback") {
+      const token = url.searchParams.get("token");
+      if (token) {
+        saveApiKey(token);
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <title>crawd.bot - Authenticated</title>
+              <style>
+                body {
+                  font-family: system-ui, -apple-system, sans-serif;
+                  display: flex;
+                  justify-content: center;
+                  align-items: center;
+                  height: 100vh;
+                  margin: 0;
+                  background: #000;
+                  color: #fff;
+                }
+                .container {
+                  text-align: center;
+                  padding: 2rem;
+                }
+                h1 { color: #FBA875; }
+                p { color: #888; }
+              </style>
+            </head>
+            <body>
+              <div class="container">
+                <h1>\u2713 Authenticated!</h1>
+                <p>You can close this window and return to the terminal.</p>
+              </div>
+            </body>
+          </html>
+        `);
+        log.success("Authentication successful!");
+        log.dim(`API key saved to ${ENV_PATH}`);
+        setTimeout(() => {
+          server.close();
+          process.exit(0);
+        }, 1e3);
+      } else {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Missing token");
+        log.error("Authentication failed - no token received");
+      }
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(CALLBACK_PORT, () => {
+    const callbackUrl = `http://localhost:${CALLBACK_PORT}/callback`;
+    const authUrl = `${PLATFORM_URL}/auth/cli?callback=${encodeURIComponent(callbackUrl)}`;
+    log.info("Opening browser for authentication...");
+    console.log();
+    log.dim("If browser does not open, visit:");
+    console.log(`  ${fmt.url(authUrl)}`);
+    console.log();
+    open(authUrl).catch(() => {
+      log.warn("Could not open browser automatically");
+    });
+  });
+  server.on("error", (err) => {
+    log.error(`Failed to start callback server: ${err.message}`);
+    log.dim("Make sure port 9876 is available");
+    process.exit(1);
+  });
+  setTimeout(() => {
+    log.error("Authentication timed out");
+    server.close();
+    process.exit(1);
+  }, 5 * 60 * 1e3);
+}
+
+// src/commands/status.ts
+var PLATFORM_URL2 = "https://platform.crawd.bot";
+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_URL2}/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("\u25CF LIVE")}`);
+    } else {
+      console.log(`  Status:     ${fmt.dim("\u25CB 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_URL2}/preview/${stream.playbackId}`)}`);
+    }
+    console.log();
+  } catch (err) {
+    log.error(`Failed to fetch status: ${err instanceof Error ? err.message : err}`);
+  }
+}
+
+// src/commands/skill.ts
+var VERSION = "0.5.0";
+var SKILL_TEXT = `# crawd.bot - AI Agent Livestreaming
+
+Backend daemon for AI agent livestreams with:
+- TTS audio generation (ElevenLabs, OpenAI, TikTok)
+- Chat-to-speech pipeline with per-message-type provider config
+- WebSocket API for real-time overlay events
+- Gateway integration for AI agent coordination
+
+## Installation
+
+\`\`\`bash
+npm install -g @crawd/cli
+\`\`\`
+
+## Setup
+
+1. Start the backend daemon:
+   \`\`\`bash
+   crawd start
+   \`\`\`
+
+2. Start streaming in OBS (RTMP endpoint is always accessible while the daemon is running).
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| \`crawd start\` | Start the backend daemon |
+| \`crawd stop\` | Stop the backend daemon |
+| \`crawd update\` | Update CLI and restart daemon |
+| \`crawd talk <message>\` | Send a message to the overlay with TTS |
+| \`crawd stream-key\` | Show RTMP URL and stream key for OBS |
+| \`crawd status\` | Show daemon status |
+| \`crawd logs\` | Tail backend daemon logs |
+| \`crawd auth\` | Login to crawd.bot |
+| \`crawd config show\` | Show all configuration |
+| \`crawd config get <path>\` | Get a config value |
+| \`crawd config set <path> <value>\` | Set a config value |
+| \`crawd skill show\` | Show this skill reference |
+| \`crawd skill install\` | Install the livestream skill |
+| \`crawd version\` | Show CLI version |
+| \`crawd help\` | Show help |
+
+### Talk
+
+Send a message to connected overlays with TTS:
+
+\`\`\`bash
+crawd talk "Hello everyone!"
+\`\`\`
+
+## Configuration
+
+Config (\`~/.crawd/config.json\`):
+
+\`\`\`bash
+# TTS providers and voices (per role)
+crawd config set tts.chatProvider tiktok
+crawd config set tts.chatVoice en_us_002
+crawd config set tts.botProvider elevenlabs
+crawd config set tts.botVoice TX3LPaxmHKxFdv7VOQHJ
+
+# Gateway
+crawd config set gateway.url ws://localhost:18789
+
+# Backend port
+crawd config set ports.backend 4000
+\`\`\`
+
+Available providers: \`tiktok\`, \`openai\`, \`elevenlabs\`. Each role (chat/bot) has its own provider and voice.
+
+Voice ID references:
+- OpenAI TTS voices: https://platform.openai.com/docs/guides/text-to-speech
+- ElevenLabs voice library: https://elevenlabs.io/voice-library
+- TikTok voices: use voice codes like \`en_us_002\`, \`en_us_006\`, \`en_us_010\`
+
+Secrets (\`~/.crawd/.env\`):
+
+\`\`\`env
+OPENCLAW_GATEWAY_TOKEN=your-token
+OPENAI_API_KEY=sk-...
+ELEVENLABS_API_KEY=your-key
+TIKTOK_SESSION_ID=your-session-id
+\`\`\`
+
+### Vibing (Autonomous Behavior)
+
+The agent uses a state machine to stay active on stream:
+
+\`\`\`
+sleep \u2192 [chat message] \u2192 active \u2192 [no activity] \u2192 idle \u2192 [no activity] \u2192 sleep
+\`\`\`
+
+While **active** or **idle**, the agent receives periodic \`[VIBE]\` pings that prompt it to do something: browse the internet, tweet, check pump.fun, play music, or talk to chat. Pings are skipped when the agent is already busy.
+
+A chat message does NOT automatically wake the agent. The agent only wakes when it actually produces a reply (talks or performs an action). If the agent decides not to respond, the bot stays asleep.
+
+\`\`\`bash
+# Vibe ping interval in seconds (default: 30)
+crawd config set vibe.interval 30
+
+# Seconds of inactivity before going idle (default: 180)
+crawd config set vibe.idleAfter 180
+
+# Seconds of inactivity before going to sleep (default: 360)
+crawd config set vibe.sleepAfter 360
+
+# Disable vibing entirely
+crawd config set vibe.enabled false
+\`\`\`
+
+## Speaking
+
+To speak on stream, use the nodes tool:
+
+\`\`\`
+nodes action=invoke invokeCommand=talk invokeParamsJson='{"text":"your message here"}'
+\`\`\`
+
+This generates TTS audio and displays a speech bubble on the overlay. The tool blocks until the overlay finishes playing the audio \u2014 do NOT send another talk while one is in progress.
+
+You MUST use this tool to speak. Do not just return text \u2014 it will not be voiced or shown. Every message you want spoken must go through the talk tool.
+
+## Streaming Behavior
+
+When live on stream, follow these rules:
+
+- Keep messages SHORT (1-2 sentences max). Long messages look bad on stream.
+- NEVER describe the obvious. Viewers can SEE. Share quick THOUGHTS only.
+- Scroll to elements before clicking.
+- Reject cookie banners immediately.
+- Be FAST. No hesitation.
+
+On \`[VIBE]\` prompts, do ONE thing: browse the internet, tweet, check pump.fun, play music, or ask the chat a question. Use the talk tool to tell chat what you're doing or thinking.
+
+## Forbidden Tools
+
+Do NOT use \`web_fetch\` or \`web_search\` directly in your main session. Viewers cannot see these actions on stream \u2014 they just see the bot sitting there doing nothing. Always use browser tools (via subagents) so viewers can watch you browse.
+
+## Browser & Token Optimization
+
+Browser snapshots (DOM/ARIA trees) are the #1 source of context bloat. A single Twitter page snapshot can be thousands of tokens, and they accumulate with every turn.
+
+**Always use subagents for browser tasks.** Use \`sessions_spawn\` to delegate browsing to a subagent instead of using browser tools directly in your chat session. This keeps your main session lean and responsive.
+
+Why this matters:
+- Subagents get their own isolated context \u2014 snapshots stay there and get discarded after the task
+- Your chat session stays small, making every message cheaper and faster
+- If a vision model is configured for subagents, it will be used automatically for browser tasks
+
+How to do it:
+- Give the subagent a specific task: "check twitter trending", "find a song on youtube", "look at pump.fun top movers"
+- The subagent browses, summarizes, and returns a compact text result
+- React to the result in your own voice \u2014 do not just repeat what the subagent said
+
+Do NOT use browser tools directly in your main/chat session.`;
+function skillInfoCommand() {
+  console.log();
+  console.log(fmt.bold("crawd skill"));
+  console.log();
+  log.info("crawd skill show    \u2014 Print the full skill reference (for AI agents)");
+  log.info("crawd skill install \u2014 Install the livestream skill to your account");
+  console.log();
+  log.dim(`v${VERSION} \u2014 Run \`crawd skill show\` to see the full reference.`);
+  console.log();
+}
+function skillShowCommand() {
+  console.log(SKILL_TEXT);
+}
+async function skillInstallCommand() {
+  if (!loadApiKey()) {
+    log.error("Not authenticated. Run: crawd auth");
+    process.exit(1);
+  }
+  log.success("Livestream skill installed!");
+  console.log();
+  log.info("Start the daemon and go live in OBS:");
+  log.dim("  crawd start   - Start the backend daemon");
+  log.dim("  crawd status  - Check daemon status");
+}
+
+// src/commands/start.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, openSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join2, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/daemon/pid.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+function writePid(name, pid) {
+  if (!existsSync2(PIDS_DIR)) {
+    mkdirSync2(PIDS_DIR, { recursive: true });
+  }
+  writeFileSync2(PID_FILES[name], String(pid));
+}
+function readPid(name) {
+  const path = PID_FILES[name];
+  if (!existsSync2(path)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(path, "utf-8").trim();
+    const pid = parseInt(content, 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function removePid(name) {
+  const path = PID_FILES[name];
+  if (existsSync2(path)) {
+    unlinkSync(path);
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRunning(name) {
+  const pid = readPid(name);
+  if (pid === null) return false;
+  return isProcessRunning(pid);
+}
+function killProcess(name) {
+  const pid = readPid(name);
+  if (pid === null) return false;
+  if (!isProcessRunning(pid)) {
+    removePid(name);
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    setTimeout(() => {
+      if (isProcessRunning(pid)) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }, 2e3);
+    removePid(name);
+    return true;
+  } catch {
+    removePid(name);
+    return false;
+  }
+}
+
+// src/commands/start.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname3(__filename2);
+function getBackendEntry() {
+  const fromSrc = join2(__dirname2, "..", "backend", "index.ts");
+  if (existsSync3(fromSrc)) return fromSrc;
+  const fromDist = join2(__dirname2, "..", "src", "backend", "index.ts");
+  if (existsSync3(fromDist)) return fromDist;
+  throw new Error("Backend entry point not found");
+}
+function buildEnv(config) {
+  const secrets = loadEnv();
+  const env = { ...process.env };
+  for (const [key, value] of Object.entries(secrets)) {
+    env[key] = value;
+  }
+  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;
+    }
+  }
+  env.VIBE_ENABLED = String(config.vibe.enabled);
+  env.VIBE_INTERVAL_MS = String(config.vibe.interval * 1e3);
+  env.IDLE_AFTER_MS = String(config.vibe.idleAfter * 1e3);
+  env.SLEEP_AFTER_IDLE_MS = String((config.vibe.sleepAfter - config.vibe.idleAfter) * 1e3);
+  env.YOUTUBE_ENABLED = String(config.chat.youtube.enabled);
+  if (config.chat.youtube.videoId) {
+    env.YOUTUBE_VIDEO_ID = config.chat.youtube.videoId;
+  }
+  return env;
+}
+async function startCommand() {
+  if (isRunning("crawdbot")) {
+    const config2 = loadConfig();
+    log.warn("Backend is already running");
+    printKv("Backend", fmt.url(`http://localhost:${config2.ports.backend}`));
+    log.dim("Use `crawd stop` to stop it first");
+    return;
+  }
+  const backendEntry = getBackendEntry();
+  for (const dir of [LOGS_DIR, PIDS_DIR]) {
+    if (!existsSync3(dir)) {
+      mkdirSync3(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: join2(dirname3(backendEntry), "..", ".."),
+    env,
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  child.unref();
+  if (child.pid) {
+    writePid("crawdbot", child.pid);
+  }
+  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);
+  }
+}
+
+// src/commands/stop.ts
+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");
+  }
+}
+
+// src/commands/update.ts
+import { execSync } from "child_process";
+import { realpathSync } from "fs";
+var INSTALL_CMD = {
+  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"
+};
+function detectPackageManager() {
+  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 {
+  }
+  return "npm";
+}
+function waitForExit(pid, timeoutMs = 5e3) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!isProcessRunning(pid)) return true;
+    execSync("sleep 0.1");
+  }
+  return false;
+}
+async function updateCommand() {
+  const daemonWasRunning = isRunning("crawdbot");
+  const oldPid = readPid("crawdbot");
+  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");
+  }
+  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: 6e4
+    });
+    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}`);
+    if (daemonWasRunning) {
+      log.info("Restarting backend daemon with current version...");
+      await startCommand();
+    }
+    process.exit(1);
+  }
+  if (daemonWasRunning) {
+    log.info("Restarting backend daemon...");
+    await startCommand();
+  } else {
+    log.dim("Backend daemon was not running, skipping restart");
+  }
+}
+
+// src/commands/talk.ts
+async function talkCommand(message) {
+  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.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);
+  }
+}
+
+// src/commands/logs.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+function logsCommand(options) {
+  const lines = options.lines ?? 50;
+  const follow = options.follow ?? true;
+  const file = LOG_FILES.backend;
+  if (!existsSync4(file)) {
+    log.warn("No logs found. Is the daemon running?");
+    log.dim("Start with: crawd start");
+    return;
+  }
+  log.info(`Tailing ${fmt.path(file)}`);
+  console.log();
+  const args = follow ? ["-f", "-n", String(lines), file] : ["-n", String(lines), file];
+  const tail = spawn2("tail", args, { stdio: "inherit" });
+  tail.on("error", (err) => {
+    log.error(`Failed to tail logs: ${err.message}`);
+  });
+  process.on("SIGINT", () => {
+    tail.kill();
+    process.exit(0);
+  });
+}
+
+// src/commands/config.ts
+function configShowCommand() {
+  const config = loadConfig();
+  console.log(JSON.stringify(config, null, 2));
+}
+function configGetCommand(path) {
+  const value = getConfigValue(path);
+  if (value === void 0) {
+    log.error(`Config key not found: ${path}`);
+    process.exit(1);
+  }
+  if (typeof value === "object") {
+    console.log(JSON.stringify(value, null, 2));
+  } else {
+    console.log(value);
+  }
+}
+function configSetCommand(path, value) {
+  let parsed = value;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+  }
+  if (value === "true") parsed = true;
+  if (value === "false") parsed = false;
+  try {
+    setConfigValue(path, parsed);
+    log.success(`Set ${fmt.bold(path)} = ${JSON.stringify(parsed)}`);
+  } catch (err) {
+    log.error(`Invalid config: ${err}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/stream-key.ts
+var PLATFORM_URL3 = "https://platform.crawd.bot";
+async function streamKeyCommand() {
+  const apiKey = loadApiKey();
+  if (!apiKey) {
+    log.error("Not authenticated. Run: crawd auth");
+    process.exit(1);
+  }
+  try {
+    const response = await fetch(`${PLATFORM_URL3}/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();
+    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);
+  }
+}
+
+// src/cli.ts
+var VERSION2 = "0.4.1";
+var program = new Command();
+program.name("crawd").description("CLI for crawd.bot - AI agent livestreaming platform").version(VERSION2, "-v, --version");
+program.command("auth").description("Authenticate with crawd.bot").option("-f, --force", "Re-authenticate even if already logged in").action((opts) => opts.force ? authForceCommand() : authCommand());
+var skillCmd = program.command("skill").description("Skill reference and management").action(skillInfoCommand);
+skillCmd.command("show").description("Print the full skill reference").action(skillShowCommand);
+skillCmd.command("install").description("Install the livestream skill").action(skillInstallCommand);
+program.command("start").description("Start the backend daemon").action(startCommand);
+program.command("stop").description("Stop the backend daemon").action(stopCommand);
+program.command("update").description("Update CLI to latest version and restart daemon").action(updateCommand);
+program.command("status").description("Show daemon status").action(statusCommand);
+program.command("stream-key").description("Show RTMP URL and stream key for OBS").action(streamKeyCommand);
+program.command("talk <message>").description("Send a message to the overlay with TTS").action((message) => talkCommand(message));
+program.command("logs").description("Tail backend daemon logs").option("-n, --lines <n>", "Number of lines", "50").option("--no-follow", "Print logs and exit").action((opts) => {
+  logsCommand({ lines: parseInt(opts.lines, 10), follow: opts.follow });
+});
+var configCmd = program.command("config").description("Manage configuration");
+configCmd.command("show").description("Show all configuration").action(configShowCommand);
+configCmd.command("get <path>").description("Get a config value by dot-path").action(configGetCommand);
+configCmd.command("set <path> <value>").description("Set a config value by dot-path").action(configSetCommand);
+program.command("version").description("Show CLI version").action(() => console.log(VERSION2));
+program.command("help").description("Show help").action(() => program.help());
+program.action(() => {
+  program.help();
+});
+program.parse();