@ch4p/cli 0.1.3 → 0.1.5

package/dist/onboard-LJFC6HXD.js

@@ -0,0 +1,849 @@
+import {
+  playFullAnimation
+} from "./chunk-CNLYUY2K.js";
+import {
+  runAudit
+} from "./chunk-IN2I6XRM.js";
+import {
+  configExists,
+  ensureConfigDir,
+  getConfigPath,
+  getDefaultConfig,
+  saveConfig
+} from "./chunk-TB4IZ7F7.js";
+import {
+  BOLD,
+  CHAPPIE_SMALL,
+  DIM,
+  GREEN,
+  RESET,
+  TEAL,
+  WHITE,
+  YELLOW,
+  box,
+  sectionHeader
+} from "./chunk-NMGPBPNU.js";
+
+// src/commands/onboard.ts
+import * as readline from "readline";
+import { execSync } from "child_process";
+function detectBinary(name) {
+  try {
+    const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
+    execSync(cmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectEngines() {
+  const engines = [];
+  if (detectBinary("claude")) {
+    engines.push({
+      id: "claude-cli",
+      label: "Claude Code CLI",
+      description: "Uses your Max/Pro plan locally \u2014 no API key needed"
+    });
+  }
+  if (detectBinary("codex")) {
+    engines.push({
+      id: "codex-cli",
+      label: "Codex CLI",
+      description: "Uses your OpenAI account via codex \u2014 no API key needed"
+    });
+  }
+  if (detectBinary("ollama")) {
+    engines.push({
+      id: "ollama",
+      label: "Ollama (local)",
+      description: "Run models locally \u2014 no API key, fully offline"
+    });
+  }
+  return engines;
+}
+function listOllamaModels() {
+  try {
+    const raw = execSync("curl -sf http://localhost:11434/api/tags", {
+      timeout: 3e3,
+      encoding: "utf8"
+    });
+    const data = JSON.parse(raw);
+    if (Array.isArray(data?.models)) {
+      return data.models.map((m) => m.name);
+    }
+  } catch {
+  }
+  return [];
+}
+var CHANNEL_DEFS = [
+  {
+    id: "telegram",
+    label: "Telegram",
+    fields: [
+      { key: "botToken", label: "Bot token", secret: true }
+    ]
+  },
+  {
+    id: "discord",
+    label: "Discord",
+    fields: [
+      { key: "botToken", label: "Bot token", secret: true }
+    ]
+  },
+  {
+    id: "slack",
+    label: "Slack",
+    fields: [
+      { key: "botToken", label: "Bot token (xoxb-...)", secret: true },
+      { key: "appToken", label: "App token (xapp-...)", secret: true }
+    ]
+  },
+  {
+    id: "matrix",
+    label: "Matrix",
+    fields: [
+      { key: "homeserverUrl", label: "Homeserver URL", defaultValue: "https://matrix.org" },
+      { key: "accessToken", label: "Access token", secret: true },
+      { key: "userId", label: "User ID (e.g. @bot:matrix.org)" }
+    ]
+  },
+  {
+    id: "teams",
+    label: "Microsoft Teams",
+    fields: [
+      { key: "appId", label: "App (client) ID" },
+      { key: "appPassword", label: "App password", secret: true }
+    ]
+  },
+  {
+    id: "whatsapp",
+    label: "WhatsApp",
+    fields: [
+      { key: "phoneNumberId", label: "Phone number ID" },
+      { key: "accessToken", label: "Access token", secret: true },
+      { key: "verifyToken", label: "Webhook verify token" }
+    ]
+  },
+  {
+    id: "signal",
+    label: "Signal",
+    fields: [
+      { key: "signalCliPath", label: "signal-cli path", defaultValue: "signal-cli" },
+      { key: "phoneNumber", label: "Phone number (e.g. +1234567890)" }
+    ]
+  },
+  {
+    id: "imessage",
+    label: "iMessage",
+    fields: [],
+    notes: "macOS only. Uses AppleScript \u2014 no additional config needed."
+  },
+  {
+    id: "irc",
+    label: "IRC",
+    fields: [
+      { key: "server", label: "Server hostname" },
+      { key: "port", label: "Port", defaultValue: "6697" },
+      { key: "nick", label: "Nickname" },
+      { key: "channels", label: "Channels (comma-separated, e.g. #general,#dev)" }
+    ]
+  },
+  {
+    id: "zalo-oa",
+    label: "Zalo OA",
+    fields: [
+      { key: "oaId", label: "OA ID" },
+      { key: "accessToken", label: "Access token", secret: true },
+      { key: "oaSecretKey", label: "OA secret key", secret: true }
+    ]
+  },
+  {
+    id: "bluebubbles",
+    label: "BlueBubbles",
+    fields: [
+      { key: "serverUrl", label: "Server URL (e.g. http://localhost:1234)" },
+      { key: "password", label: "Password", secret: true }
+    ]
+  },
+  {
+    id: "google-chat",
+    label: "Google Chat",
+    fields: [
+      { key: "serviceAccountKeyPath", label: "Service account JSON key path" },
+      { key: "spaceId", label: "Space ID" }
+    ]
+  },
+  {
+    id: "webchat",
+    label: "WebChat",
+    fields: [
+      { key: "path", label: "WebSocket path", defaultValue: "/webchat" }
+    ]
+  },
+  {
+    id: "zalo-personal",
+    label: "Zalo Personal",
+    fields: [
+      { key: "bridgeUrl", label: "Bridge URL (e.g. http://localhost:3500)" }
+    ],
+    notes: "Requires your own Zalo automation bridge (e.g. zca-js). May violate Zalo TOS."
+  },
+  {
+    id: "macos",
+    label: "macOS Native",
+    fields: [],
+    notes: "macOS only. Uses Notification Center + AppleScript dialogs \u2014 no additional config needed."
+  }
+];
+function parseYesNo(answer, defaultYes) {
+  const lower = answer.toLowerCase().trim();
+  if (lower === "") return defaultYes;
+  return lower === "y" || lower === "yes";
+}
+function parseMultiSelect(answer, maxIndex) {
+  if (answer.trim() === "") return [];
+  return answer.split(",").map((s) => parseInt(s.trim(), 10) - 1).filter((n) => !isNaN(n) && n >= 0 && n < maxIndex);
+}
+function createPromptInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+function askSecret(rl, question) {
+  return new Promise((resolve) => {
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    let input = "";
+    const onData = (ch) => {
+      const char = ch.toString("utf8");
+      if (char === "\n" || char === "\r") {
+        if (stdin.isTTY) {
+          stdin.setRawMode(wasRaw ?? false);
+        }
+        stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        resolve(input.trim());
+        return;
+      }
+      if (char === "") {
+        if (stdin.isTTY) {
+          stdin.setRawMode(wasRaw ?? false);
+        }
+        stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        process.exit(130);
+      }
+      if (char === "\x7F" || char === "\b") {
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+        return;
+      }
+      input += char;
+      process.stdout.write("*");
+    };
+    rl.pause();
+    stdin.on("data", onData);
+    stdin.resume();
+  });
+}
+async function askYesNo(rl, question, defaultYes = false) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  const answer = await ask(rl, `  ${TEAL}> ${question} [${hint}]: ${RESET}`);
+  return parseYesNo(answer, defaultYes);
+}
+async function askMultiSelect(rl, items) {
+  const half = Math.ceil(items.length / 2);
+  for (let i = 0; i < half; i++) {
+    const left = `  ${DIM}${String(i + 1).padStart(2)}.${RESET} ${items[i].label}`;
+    const leftPad = left.padEnd(42);
+    const rightIdx = i + half;
+    const right = rightIdx < items.length ? `${DIM}${String(rightIdx + 1).padStart(2)}.${RESET} ${items[rightIdx].label}` : "";
+    console.log(`${leftPad}${right}`);
+  }
+  const answer = await ask(rl, `  ${TEAL}> Enter numbers (e.g. 1,3,5), or Enter to skip: ${RESET}`);
+  return parseMultiSelect(answer, items.length);
+}
+var MODELS = [
+  { id: "claude-sonnet-4-20250514", label: "Claude Sonnet 4 (recommended)", provider: "anthropic" },
+  { id: "claude-opus-4-20250514", label: "Claude Opus 4", provider: "anthropic" },
+  { id: "gpt-4o", label: "GPT-4o", provider: "openai" },
+  { id: "gpt-4o-mini", label: "GPT-4o Mini", provider: "openai" }
+];
+var AUTONOMY_LEVELS = [
+  { id: "readonly", label: "Read-only   \u2014 Agent can only read files and run safe commands" },
+  { id: "supervised", label: "Supervised  \u2014 Agent asks before writes and destructive actions (recommended)" },
+  { id: "full", label: "Full        \u2014 Agent operates autonomously (use with caution)" }
+];
+async function configureProviders(rl, config) {
+  console.log("");
+  console.log(sectionHeader("Additional Providers"));
+  console.log("");
+  if (await askYesNo(rl, "Configure Google/Gemini API key?")) {
+    console.log(`  ${DIM}Get yours at https://aistudio.google.com/apikey${RESET}`);
+    const key = await askSecret(rl, `  ${TEAL}> API key: ${RESET}`);
+    if (key) {
+      config.providers["google"] = { apiKey: key };
+      console.log(`  ${GREEN}Saved.${RESET}
+`);
+    } else {
+      console.log(`  ${DIM}Skipped.${RESET}
+`);
+    }
+  }
+  if (await askYesNo(rl, "Configure OpenRouter API key?")) {
+    console.log(`  ${DIM}Get yours at https://openrouter.ai/keys${RESET}`);
+    const key = await askSecret(rl, `  ${TEAL}> API key: ${RESET}`);
+    if (key) {
+      config.providers["openrouter"] = { apiKey: key };
+      console.log(`  ${GREEN}Saved.${RESET}
+`);
+    } else {
+      console.log(`  ${DIM}Skipped.${RESET}
+`);
+    }
+  }
+  if (await askYesNo(rl, "Configure AWS Bedrock?")) {
+    const accessKey = await askSecret(rl, `  ${TEAL}> AWS Access Key ID: ${RESET}`);
+    const secretKey = await askSecret(rl, `  ${TEAL}> AWS Secret Access Key: ${RESET}`);
+    const region = await ask(rl, `  ${TEAL}> AWS Region [us-east-1]: ${RESET}`) || "us-east-1";
+    if (accessKey && secretKey) {
+      config.providers["bedrock"] = { accessKeyId: accessKey, secretAccessKey: secretKey, region };
+      console.log(`  ${GREEN}Saved.${RESET}
+`);
+    } else {
+      console.log(`  ${DIM}Skipped.${RESET}
+`);
+    }
+  }
+}
+async function configureChannels(rl, config) {
+  console.log("");
+  console.log(sectionHeader("Channels"));
+  console.log(`  ${DIM}Enable messaging channels for ch4p to receive and send messages.${RESET}`);
+  console.log("");
+  const selected = await askMultiSelect(rl, CHANNEL_DEFS.map((c) => ({ label: c.label })));
+  if (selected.length === 0) {
+    console.log(`  ${DIM}No channels selected.${RESET}
+`);
+    return;
+  }
+  for (const idx of selected) {
+    const def = CHANNEL_DEFS[idx];
+    console.log(`
+  ${BOLD}${def.label}${RESET}`);
+    if (def.notes) {
+      console.log(`  ${YELLOW}Note: ${def.notes}${RESET}`);
+    }
+    if (def.fields.length === 0) {
+      config.channels[def.id] = { enabled: true };
+      console.log(`  ${GREEN}Enabled.${RESET}`);
+      continue;
+    }
+    const channelConfig = { enabled: true };
+    for (const field of def.fields) {
+      const defaultHint = field.defaultValue ? ` [${field.defaultValue}]` : "";
+      let value;
+      if (field.secret) {
+        value = await askSecret(rl, `  ${TEAL}> ${field.label}${defaultHint}: ${RESET}`);
+      } else {
+        value = await ask(rl, `  ${TEAL}> ${field.label}${defaultHint}: ${RESET}`);
+      }
+      channelConfig[field.key] = value || field.defaultValue || "";
+    }
+    config.channels[def.id] = channelConfig;
+    console.log(`  ${GREEN}${def.label} configured.${RESET}`);
+  }
+  console.log("");
+}
+async function configureSearch(rl, config) {
+  if (!await askYesNo(rl, "Configure web search (Brave Search API)?")) return;
+  console.log(`  ${DIM}Get a key at https://api.search.brave.com${RESET}`);
+  const key = await askSecret(rl, `  ${TEAL}> Brave API key: ${RESET}`);
+  if (key) {
+    config.search = {
+      enabled: true,
+      provider: "brave",
+      apiKey: key,
+      maxResults: 5
+    };
+    console.log(`  ${GREEN}Web search enabled.${RESET}
+`);
+  } else {
+    console.log(`  ${DIM}Skipped.${RESET}
+`);
+  }
+}
+async function configureBrowser(rl, _config) {
+  if (!await askYesNo(rl, "Enable browser tool (Playwright)?")) return;
+  console.log(`  ${GREEN}Browser tool will be available.${RESET}`);
+  console.log(`  ${DIM}Install Playwright: npx playwright install chromium${RESET}
+`);
+}
+async function configureVoice(rl, config) {
+  if (!await askYesNo(rl, "Configure voice pipeline (STT/TTS)?")) return;
+  console.log("");
+  console.log(`  ${BOLD}Speech-to-Text provider:${RESET}`);
+  console.log(`  ${DIM}1.${RESET} Whisper (default)`);
+  console.log(`  ${DIM}2.${RESET} Deepgram`);
+  const sttChoice = await ask(rl, `  ${TEAL}> Choice [1]: ${RESET}`);
+  const sttProvider = sttChoice === "2" ? "deepgram" : "whisper";
+  let sttApiKey;
+  if (sttProvider === "deepgram") {
+    sttApiKey = await askSecret(rl, `  ${TEAL}> Deepgram API key: ${RESET}`) || void 0;
+  }
+  console.log("");
+  console.log(`  ${BOLD}Text-to-Speech provider:${RESET}`);
+  console.log(`  ${DIM}1.${RESET} ElevenLabs`);
+  console.log(`  ${DIM}2.${RESET} None (skip TTS)`);
+  const ttsChoice = await ask(rl, `  ${TEAL}> Choice [2]: ${RESET}`);
+  const ttsProvider = ttsChoice === "1" ? "elevenlabs" : "none";
+  let ttsApiKey;
+  let ttsVoiceId;
+  if (ttsProvider === "elevenlabs") {
+    ttsApiKey = await askSecret(rl, `  ${TEAL}> ElevenLabs API key: ${RESET}`) || void 0;
+    ttsVoiceId = await ask(rl, `  ${TEAL}> Voice ID (Enter for default): ${RESET}`) || void 0;
+  }
+  config.voice = {
+    enabled: true,
+    stt: { provider: sttProvider, apiKey: sttApiKey },
+    tts: { provider: ttsProvider, apiKey: ttsApiKey, voiceId: ttsVoiceId }
+  };
+  console.log(`  ${GREEN}Voice pipeline configured.${RESET}
+`);
+}
+async function configureMcp(rl, _config) {
+  if (!await askYesNo(rl, "Configure MCP servers?")) return;
+  console.log(`  ${DIM}MCP servers are configured in ~/.ch4p/config.json under "mcp.servers".${RESET}`);
+  console.log(`  ${DIM}See docs/how-to/use-mcp.md for details.${RESET}
+`);
+}
+async function configureCron(rl, _config) {
+  if (!await askYesNo(rl, "Enable cron scheduler & webhooks?")) return;
+  console.log(`  ${GREEN}Cron scheduler and webhooks are available via the gateway.${RESET}`);
+  console.log(`  ${DIM}Configure jobs in ~/.ch4p/config.json under "cron.jobs".${RESET}`);
+  console.log(`  ${DIM}See docs/how-to/use-cron-webhooks.md for details.${RESET}
+`);
+}
+async function configureX402(rl, config) {
+  if (!await askYesNo(rl, "Configure x402 micropayments?")) return;
+  console.log("");
+  console.log(`  ${DIM}x402 enables HTTP micropayments on Base/USDC.${RESET}`);
+  console.log(`  ${DIM}Server: require payment to access gateway endpoints.${RESET}`);
+  console.log(`  ${DIM}Client: sign payments when the agent hits 402 responses.${RESET}`);
+  console.log("");
+  const enableServer = await askYesNo(rl, "  Enable server-side payment enforcement?");
+  const enableClient = await askYesNo(rl, "  Enable client-side payment signing?");
+  if (!enableServer && !enableClient) {
+    console.log(`  ${DIM}Skipped.${RESET}
+`);
+    return;
+  }
+  const x402 = { enabled: true };
+  if (enableServer) {
+    const payTo = await ask(rl, `  ${TEAL}> Receiving wallet address (0x...): ${RESET}`);
+    const amount = await ask(rl, `  ${TEAL}> Amount in USDC smallest unit [1000000]: ${RESET}`);
+    const net = await ask(rl, `  ${TEAL}> Network [base]: ${RESET}`);
+    x402.server = {
+      payTo: payTo.trim() || "0x0000000000000000000000000000000000000000",
+      amount: amount.trim() || "1000000",
+      network: net.trim() || "base"
+    };
+  }
+  if (enableClient) {
+    console.log(`  ${DIM}Tip: store key as X402_PRIVATE_KEY env var \u2014 leave blank to use it.${RESET}`);
+    const pk = await askSecret(rl, `  ${TEAL}> Private key (blank = use \${X402_PRIVATE_KEY}): ${RESET}`);
+    const net = await ask(rl, `  ${TEAL}> Network [base]: ${RESET}`);
+    const network = net.trim() || "base";
+    const client = {
+      privateKey: pk || "${X402_PRIVATE_KEY}"
+    };
+    if (network === "base-sepolia") {
+      client.chainId = 84532;
+      client.tokenAddress = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+    }
+    x402.client = client;
+  }
+  config.x402 = x402;
+  console.log(`  ${GREEN}x402 configured.${RESET}
+`);
+}
+async function configureVoiceWake(rl, config) {
+  if (!await askYesNo(rl, "Enable always-on voice wake (hot-mic listening)?")) return;
+  console.log(`  ${DIM}Requires SoX (rec) \u2014 macOS: brew install sox, Linux: apt install sox${RESET}`);
+  let wakeWord;
+  const useWakeWord = await askYesNo(rl, 'Use a wake word (e.g. "hey ch4p")?');
+  if (useWakeWord) {
+    wakeWord = await ask(rl, `  ${TEAL}> Wake word: ${RESET}`) || void 0;
+  }
+  const thresholdStr = await ask(rl, `  ${TEAL}> Energy threshold [500]: ${RESET}`);
+  const energyThreshold = thresholdStr ? parseInt(thresholdStr, 10) : void 0;
+  const voiceConfig = config.voice;
+  const wake = { enabled: true };
+  if (wakeWord) wake.wakeWord = wakeWord;
+  if (energyThreshold && !isNaN(energyThreshold)) wake.energyThreshold = energyThreshold;
+  if (voiceConfig) {
+    voiceConfig.wake = wake;
+  } else {
+    config.voice = { enabled: false, wake };
+  }
+  console.log(`  ${GREEN}Voice wake enabled${wakeWord ? ` (wake word: "${wakeWord}")` : " (push-to-talk style)"}.${RESET}
+`);
+}
+async function configureMesh(rl, config) {
+  if (!await askYesNo(rl, "Enable mesh orchestration (multi-agent swarm)?")) return;
+  const concurrencyStr = await ask(rl, `  ${TEAL}> Max concurrent sub-agents [3]: ${RESET}`);
+  const maxConcurrency = concurrencyStr ? parseInt(concurrencyStr, 10) : 3;
+  config.mesh = {
+    enabled: true,
+    maxConcurrency: !isNaN(maxConcurrency) && maxConcurrency >= 1 && maxConcurrency <= 10 ? maxConcurrency : 3,
+    defaultTimeout: 12e4
+  };
+  console.log(`  ${GREEN}Mesh orchestration enabled (max ${maxConcurrency} concurrent agents).${RESET}
+`);
+}
+async function configureMemory(rl, config) {
+  if (!await askYesNo(rl, "Configure memory backend?")) return;
+  console.log("");
+  console.log(`  ${BOLD}Memory backend:${RESET}`);
+  console.log(`  ${DIM}1.${RESET} SQLite (default \u2014 vector + keyword search)`);
+  console.log(`  ${DIM}2.${RESET} Markdown (flat files)`);
+  console.log(`  ${DIM}3.${RESET} None (disable memory)`);
+  const choice = await ask(rl, `  ${TEAL}> Choice [1]: ${RESET}`);
+  if (choice === "2") {
+    config.memory.backend = "markdown";
+  } else if (choice === "3") {
+    config.memory.backend = "noop";
+  } else {
+    config.memory.backend = "sqlite";
+  }
+  console.log(`  ${GREEN}Memory backend: ${config.memory.backend}${RESET}
+`);
+}
+async function configureVerification(rl, config) {
+  if (!await askYesNo(rl, "Configure verification settings?")) return;
+  const enabled = await askYesNo(rl, "Enable task verification?", true);
+  let semantic = true;
+  if (enabled) {
+    semantic = await askYesNo(rl, "Enable semantic (LLM) verification?", true);
+  }
+  config.verification = { enabled, semantic };
+  console.log(`  ${GREEN}Verification: ${enabled ? "on" : "off"}${semantic ? " (semantic)" : ""}${RESET}
+`);
+}
+async function configureGateway(rl, config) {
+  if (!await askYesNo(rl, "Configure gateway settings?")) return;
+  const portStr = await ask(rl, `  ${TEAL}> Gateway port [${config.gateway.port}]: ${RESET}`);
+  if (portStr) {
+    const port = parseInt(portStr, 10);
+    if (!isNaN(port) && port > 0 && port <= 65535) {
+      config.gateway.port = port;
+    }
+  }
+  const requirePairing = await askYesNo(rl, "Require pairing tokens?", true);
+  config.gateway.requirePairing = requirePairing;
+  console.log(`  ${GREEN}Gateway: port ${config.gateway.port}, pairing ${requirePairing ? "on" : "off"}${RESET}
+`);
+}
+async function configureSecurity(rl, config) {
+  if (!await askYesNo(rl, "Configure security settings?")) return;
+  const workspaceOnly = await askYesNo(rl, "Restrict file access to workspace?", true);
+  config.security.workspaceOnly = workspaceOnly;
+  const blockedStr = await ask(rl, `  ${TEAL}> Blocked paths (comma-separated, Enter to skip): ${RESET}`);
+  if (blockedStr) {
+    config.security.blockedPaths = blockedStr.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  console.log(`  ${GREEN}Security: workspace-only ${workspaceOnly ? "on" : "off"}, ${config.security.blockedPaths.length} blocked paths${RESET}
+`);
+}
+async function configureAllowedCommands(rl, config) {
+  if (!await askYesNo(rl, "Configure allowed commands?")) return;
+  console.log(`  ${DIM}Current: ${config.autonomy.allowedCommands.join(", ")}${RESET}`);
+  const addStr = await ask(rl, `  ${TEAL}> Additional commands (comma-separated, Enter to skip): ${RESET}`);
+  if (addStr) {
+    const additional = addStr.split(",").map((s) => s.trim()).filter(Boolean);
+    config.autonomy.allowedCommands.push(...additional);
+    console.log(`  ${GREEN}Added: ${additional.join(", ")}${RESET}
+`);
+  } else {
+    console.log(`  ${DIM}Keeping defaults.${RESET}
+`);
+  }
+}
+async function configureTunnel(rl, config) {
+  if (!await askYesNo(rl, "Configure tunnel provider?")) return;
+  console.log("");
+  console.log(`  ${BOLD}Tunnel provider:${RESET}`);
+  console.log(`  ${DIM}1.${RESET} None (default)`);
+  console.log(`  ${DIM}2.${RESET} Cloudflare Tunnel`);
+  console.log(`  ${DIM}3.${RESET} Tailscale`);
+  console.log(`  ${DIM}4.${RESET} ngrok`);
+  const choice = await ask(rl, `  ${TEAL}> Choice [1]: ${RESET}`);
+  const providers = ["none", "cloudflare", "tailscale", "ngrok"];
+  const idx = choice ? parseInt(choice, 10) - 1 : 0;
+  config.tunnel.provider = providers[idx] ?? "none";
+  console.log(`  ${GREEN}Tunnel: ${config.tunnel.provider}${RESET}
+`);
+}
+async function configureCanvas(rl, config) {
+  if (!await askYesNo(rl, "Configure canvas workspace?")) return;
+  const portStr = await ask(rl, `  ${TEAL}> Canvas port [4800]: ${RESET}`);
+  const port = portStr ? parseInt(portStr, 10) : 4800;
+  config.canvas = {
+    enabled: true,
+    port: !isNaN(port) && port > 0 && port <= 65535 ? port : 4800
+  };
+  console.log(`  ${GREEN}Canvas enabled on port ${config.canvas.port}.${RESET}
+`);
+}
+async function configureObservability(rl, config) {
+  if (!await askYesNo(rl, "Configure observability?")) return;
+  console.log("");
+  console.log(`  ${BOLD}Log level:${RESET}`);
+  console.log(`  ${DIM}1.${RESET} debug`);
+  console.log(`  ${DIM}2.${RESET} info (default)`);
+  console.log(`  ${DIM}3.${RESET} warn`);
+  console.log(`  ${DIM}4.${RESET} error`);
+  const choice = await ask(rl, `  ${TEAL}> Choice [2]: ${RESET}`);
+  const levels = ["debug", "info", "warn", "error"];
+  const idx = choice ? parseInt(choice, 10) - 1 : 1;
+  config.observability.logLevel = levels[idx] ?? "info";
+  const fileObserver = await askYesNo(rl, "Enable file observer (JSONL logs)?");
+  config.observability.observers = fileObserver ? ["console", "file"] : ["console"];
+  console.log(`  ${GREEN}Observability: ${config.observability.logLevel}, observers: ${config.observability.observers.join(", ")}${RESET}
+`);
+}
+async function configureSkills(rl, config) {
+  if (!await askYesNo(rl, "Configure skills?")) return;
+  console.log(`  ${DIM}Default skill paths: ${config.skills.paths.join(", ")}${RESET}`);
+  const additionalPaths = await ask(rl, `  ${TEAL}> Additional skill paths (comma-separated, Enter to skip): ${RESET}`);
+  if (additionalPaths) {
+    const paths = additionalPaths.split(",").map((s) => s.trim()).filter(Boolean);
+    config.skills.paths.push(...paths);
+    console.log(`  ${GREEN}Added: ${paths.join(", ")}${RESET}
+`);
+  } else {
+    console.log(`  ${DIM}Keeping defaults.${RESET}
+`);
+  }
+}
+async function onboard() {
+  const mascotLines = [];
+  const info = [
+    "",
+    `${TEAL}${BOLD}ch4p${RESET}  ${DIM}Personal AI Assistant${RESET}`,
+    "",
+    `${DIM}Security-first. BEAM-inspired. Zero-dependency memory.${RESET}`,
+    ""
+  ];
+  for (let i = 0; i < Math.max(CHAPPIE_SMALL.length, info.length); i++) {
+    const art = i < CHAPPIE_SMALL.length ? `${TEAL}${CHAPPIE_SMALL[i]}${RESET}` : "            ";
+    const text = i < info.length ? info[i] : "";
+    mascotLines.push(`${art}    ${text}`);
+  }
+  console.log("");
+  console.log(box("", mascotLines));
+  console.log("");
+  if (configExists()) {
+    console.log(`  ${YELLOW}A config file already exists at ${getConfigPath()}${RESET}`);
+    console.log(`  ${YELLOW}Running the wizard will overwrite it.${RESET}
+`);
+  }
+  const rl = createPromptInterface();
+  const config = getDefaultConfig();
+  try {
+    console.log(`  ${DIM}Let's get you set up. Press Enter to skip any step.${RESET}
+`);
+    const detectedEngines = detectEngines();
+    let useApiKeys = true;
+    let step = 0;
+    let totalSteps = 6;
+    if (detectedEngines.length > 0) {
+      step++;
+      console.log(`  ${TEAL}${BOLD}Step ${step}${RESET} ${WHITE}Engine Setup${RESET}`);
+      console.log("");
+      for (const eng of detectedEngines) {
+        console.log(`  ${GREEN}\u2713${RESET} ${eng.label} detected`);
+      }
+      console.log("");
+      for (let i = 0; i < detectedEngines.length; i++) {
+        const eng = detectedEngines[i];
+        const marker = i === 0 ? ` ${GREEN}(recommended)${RESET}` : "";
+        console.log(`  ${DIM}${i + 1}.${RESET} ${eng.label} \u2014 ${eng.description}${marker}`);
+      }
+      const apiIdx = detectedEngines.length + 1;
+      console.log(`  ${DIM}${apiIdx}.${RESET} API key setup (Anthropic/OpenAI keys)`);
+      const engineChoice = await ask(rl, `  ${TEAL}> Choice [1]: ${RESET}`);
+      const choiceNum = engineChoice ? parseInt(engineChoice, 10) : 1;
+      const chosenEngineIdx = choiceNum - 1;
+      if (chosenEngineIdx >= 0 && chosenEngineIdx < detectedEngines.length) {
+        const chosen = detectedEngines[chosenEngineIdx];
+        useApiKeys = false;
+        totalSteps = 4;
+        if (chosen.id === "claude-cli" || chosen.id === "codex-cli") {
+          config.engines.default = chosen.id;
+          console.log(`  ${GREEN}Engine set to ${chosen.label}.${RESET}
+`);
+          if (chosen.id === "claude-cli") {
+            console.log(`  ${YELLOW}${BOLD}\u26A0  Personal use only${RESET}`);
+            console.log(`  ${YELLOW}This setup is intended for personal, local use only.${RESET}`);
+            console.log(`  ${YELLOW}Do not use it in a commercial product or multi-user service${RESET}`);
+            console.log(`  ${YELLOW}where ch4p routes your subscription on behalf of other users.${RESET}`);
+            console.log("");
+            console.log(`  ${DIM}For production or shared deployments, use an API key instead.${RESET}`);
+            console.log(`  ${DIM}See: https://console.anthropic.com${RESET}
+`);
+          }
+        } else if (chosen.id === "ollama") {
+          config.engines.default = "native";
+          config.agent.provider = "ollama";
+          const models = listOllamaModels();
+          if (models.length > 0) {
+            console.log(`  ${GREEN}Ollama server is running.${RESET} Installed models:
+`);
+            for (let i = 0; i < models.length; i++) {
+              const marker = i === 0 ? ` ${GREEN}(default)${RESET}` : "";
+              console.log(`  ${DIM}${i + 1}.${RESET} ${models[i]}${marker}`);
+            }
+            const modelChoice = await ask(rl, `  ${TEAL}> Choice [1]: ${RESET}`);
+            const modelIdx = modelChoice ? parseInt(modelChoice, 10) - 1 : 0;
+            config.agent.model = models[modelIdx] ?? models[0] ?? "llama3.3";
+          } else {
+            config.agent.model = "llama3.3";
+            console.log(`  ${YELLOW}Ollama server not reachable. Using default model: llama3.3${RESET}`);
+            console.log(`  ${DIM}Start Ollama with 'ollama serve' before running ch4p.${RESET}`);
+          }
+          console.log(`  ${GREEN}Engine set to Ollama (${config.agent.model}).${RESET}
+`);
+        }
+      } else {
+        useApiKeys = true;
+        totalSteps = 7;
+        console.log(`  ${DIM}Proceeding with API key setup.${RESET}
+`);
+      }
+    }
+    if (useApiKeys) {
+      step++;
+      console.log(`  ${TEAL}${BOLD}Step ${step}/${totalSteps}${RESET} ${WHITE}Anthropic API Key${RESET}`);
+      console.log(`  ${DIM}Get yours at https://console.anthropic.com/keys${RESET}`);
+      const anthropicKey = await askSecret(rl, `  ${TEAL}> API key: ${RESET}`);
+      if (anthropicKey) {
+        config.providers["anthropic"]["apiKey"] = anthropicKey;
+        console.log(`  ${GREEN}Saved.${RESET}
+`);
+      } else {
+        console.log(`  ${DIM}Skipped. Set ANTHROPIC_API_KEY env var later.${RESET}
+`);
+      }
+      step++;
+      console.log(`  ${TEAL}${BOLD}Step ${step}/${totalSteps}${RESET} ${WHITE}OpenAI API Key (optional)${RESET}`);
+      console.log(`  ${DIM}Get yours at https://platform.openai.com/api-keys${RESET}`);
+      const openaiKey = await askSecret(rl, `  ${TEAL}> API key: ${RESET}`);
+      if (openaiKey) {
+        config.providers["openai"]["apiKey"] = openaiKey;
+        console.log(`  ${GREEN}Saved.${RESET}
+`);
+      } else {
+        console.log(`  ${DIM}Skipped.${RESET}
+`);
+      }
+      step++;
+      console.log(`  ${TEAL}${BOLD}Step ${step}/${totalSteps}${RESET} ${WHITE}Preferred Model${RESET}`);
+      for (let i = 0; i < MODELS.length; i++) {
+        const m = MODELS[i];
+        const marker = i === 0 ? ` ${GREEN}(default)${RESET}` : "";
+        console.log(`  ${DIM}${i + 1}.${RESET} ${m.label}${marker}`);
+      }
+      const modelChoice = await ask(rl, `  ${TEAL}> Choice [1]: ${RESET}`);
+      const modelIdx = modelChoice ? parseInt(modelChoice, 10) - 1 : 0;
+      const selectedModel = MODELS[modelIdx] ?? MODELS[0];
+      config.agent.model = selectedModel.id;
+      config.agent.provider = selectedModel.provider;
+      console.log(`  ${GREEN}Selected: ${selectedModel.label}${RESET}
+`);
+    }
+    step++;
+    console.log(`  ${TEAL}${BOLD}Step ${step}/${totalSteps}${RESET} ${WHITE}Autonomy Level${RESET}`);
+    for (let i = 0; i < AUTONOMY_LEVELS.length; i++) {
+      const a = AUTONOMY_LEVELS[i];
+      const marker = i === 1 ? ` ${GREEN}(default)${RESET}` : "";
+      console.log(`  ${DIM}${i + 1}.${RESET} ${a.label}${marker}`);
+    }
+    const autonomyChoice = await ask(rl, `  ${TEAL}> Choice [2]: ${RESET}`);
+    const autonomyIdx = autonomyChoice ? parseInt(autonomyChoice, 10) - 1 : 1;
+    const selectedAutonomy = AUTONOMY_LEVELS[autonomyIdx] ?? AUTONOMY_LEVELS[1];
+    config.autonomy.level = selectedAutonomy.id;
+    console.log(`  ${GREEN}Selected: ${selectedAutonomy.id}${RESET}
+`);
+    step++;
+    console.log(`  ${TEAL}${BOLD}Step ${step}/${totalSteps}${RESET} ${WHITE}Additional Features${RESET}`);
+    console.log(`  ${DIM}Configure providers, channels, services, and system settings.${RESET}`);
+    console.log(`  ${DIM}Each category can be skipped individually.${RESET}
+`);
+    const configureFeatures = await askYesNo(rl, "Configure additional features?");
+    if (configureFeatures) {
+      await configureProviders(rl, config);
+      await configureChannels(rl, config);
+      console.log("");
+      console.log(sectionHeader("Services"));
+      console.log("");
+      await configureSearch(rl, config);
+      await configureBrowser(rl, config);
+      await configureVoice(rl, config);
+      await configureVoiceWake(rl, config);
+      await configureMesh(rl, config);
+      await configureMcp(rl, config);
+      await configureCron(rl, config);
+      await configureX402(rl, config);
+      console.log("");
+      console.log(sectionHeader("System"));
+      console.log("");
+      await configureMemory(rl, config);
+      await configureVerification(rl, config);
+      await configureGateway(rl, config);
+      await configureSecurity(rl, config);
+      await configureAllowedCommands(rl, config);
+      await configureTunnel(rl, config);
+      await configureCanvas(rl, config);
+      await configureObservability(rl, config);
+      await configureSkills(rl, config);
+    }
+    step++;
+    console.log(`  ${TEAL}${BOLD}Step ${step}/${totalSteps}${RESET} ${WHITE}Saving configuration${RESET}`);
+    ensureConfigDir();
+    saveConfig(config);
+    console.log(`  ${GREEN}Config written to ${getConfigPath()}${RESET}
+`);
+    console.log(`  ${BOLD}Running security audit...${RESET}
+`);
+    runAudit(config);
+    await playFullAnimation();
+    console.log(`  ${DIM}Run ${TEAL}ch4p${DIM} to start an interactive session.${RESET}`);
+    console.log(`  ${DIM}Run ${TEAL}ch4p --help${DIM} for all commands.${RESET}`);
+    console.log("");
+  } finally {
+    rl.close();
+  }
+}
+export {
+  CHANNEL_DEFS,
+  detectBinary,
+  detectEngines,
+  onboard,
+  parseMultiSelect,
+  parseYesNo
+};