@settinghead/voxlert 0.3.5

package/src/setup-ui.js

@@ -0,0 +1,177 @@
+import { getProvider } from "./providers.js";
+
+const ANSI = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  hideCursor: "\x1b[?25l",
+  showCursor: "\x1b[?25h",
+  clear: "\x1b[2J",
+  home: "\x1b[H",
+};
+
+const LOGO_LINES = [
+  "██╗   ██╗ ██████╗ ██╗ ██████╗███████╗███████╗ ██████╗ ██████╗  ██████╗ ███████╗",
+  "██║   ██║██╔═══██╗██║██╔════╝██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝",
+  "██║   ██║██║   ██║██║██║     █████╗  █████╗  ██║   ██║██████╔╝██║  ███╗█████╗  ",
+  "╚██╗ ██╔╝██║   ██║██║██║     ██╔══╝  ██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝  ",
+  " ╚████╔╝ ╚██████╔╝██║╚██████╗███████╗██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗",
+  "  ╚═══╝   ╚═════╝ ╚═╝ ╚═════╝╚══════╝╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝",
+];
+
+function color(text, code) {
+  return `${code}${text}${ANSI.reset}`;
+}
+
+function useFancyUi() {
+  return Boolean(process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb");
+}
+
+function rgb(r, g, b) {
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function interpolate(a, b, t) {
+  return Math.round(a + (b - a) * t);
+}
+
+const LOGO_GRADIENT_STOPS = [
+  [88, 196, 255],
+  [116, 140, 255],
+  [178, 92, 255],
+  [255, 64, 196],
+  [255, 82, 120],
+  [255, 64, 196],
+  [178, 92, 255],
+  [116, 140, 255],
+  [88, 196, 255],
+];
+
+function sampleLogoGradient(t) {
+  const clamped = Math.max(0, Math.min(1, t));
+  const segments = LOGO_GRADIENT_STOPS.length - 1;
+  const scaled = clamped * segments;
+  const index = Math.min(Math.floor(scaled), segments - 1);
+  const local = scaled - index;
+  const eased = 0.5 - (Math.cos(local * Math.PI) / 2);
+  const [r1, g1, b1] = LOGO_GRADIENT_STOPS[index];
+  const [r2, g2, b2] = LOGO_GRADIENT_STOPS[index + 1];
+  return [
+    interpolate(r1, r2, eased),
+    interpolate(g1, g2, eased),
+    interpolate(b1, b2, eased),
+  ];
+}
+
+function animatedLogoLine(text, phase = 0, shimmerIndex = -1) {
+  if (!useFancyUi()) return text;
+  const chars = [...text];
+  const last = Math.max(chars.length - 1, 1);
+  return chars.map((ch, index) => {
+    if (ch === " ") return ch;
+    const raw = (index / last) + phase;
+    const wrapped = raw - Math.floor(raw);
+    let [r, g, b] = sampleLogoGradient(wrapped);
+    if (Math.abs(index - shimmerIndex) <= 1) {
+      r = Math.min(255, r + 70);
+      g = Math.min(255, g + 70);
+      b = Math.min(255, b + 70);
+    }
+    return `${rgb(r, g, b)}${ANSI.bold}${ch}${ANSI.reset}`;
+  }).join("") + ANSI.reset;
+}
+
+function centerLine(text, width = 92) {
+  const padding = Math.max(0, Math.floor((width - text.length) / 2));
+  return `${" ".repeat(padding)}${text}`;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function formatCurrentConfig(config, installedPlatforms) {
+  const provider = getProvider(config.llm_backend || "openrouter");
+  const providerLabel = config.llm_api_key
+    ? `${provider ? provider.name : (config.llm_backend || "openrouter")} (${config.llm_model || provider?.defaultModel || "default"})`
+    : "Fallback only";
+  const ttsLabel = config.tts_backend || "chatterbox";
+  const voiceLabel = config.active_pack || "sc2-adjutant";
+  const platforms = installedPlatforms.filter(Boolean);
+  return [
+    `${color("Current", ANSI.dim)} ${providerLabel}`,
+    `${color("Voice", ANSI.dim)}   ${voiceLabel}`,
+    `${color("TTS", ANSI.dim)}     ${ttsLabel}`,
+    `${color("Hooks", ANSI.dim)}   ${platforms.length > 0 ? platforms.join(", ") : "None"}`,
+  ];
+}
+
+function renderLogoFrame(config, installedPlatforms, shimmerStep = -1) {
+  const current = formatCurrentConfig(config, installedPlatforms).map((line) => `  ${line}`);
+  const rule = color("┈".repeat(92), ANSI.dim);
+  const glow = color("SYNTHETIC VOICE NOTIFICATIONS FOR AGENT WORKFLOWS", ANSI.cyan);
+  const logo = LOGO_LINES.map((line, index) => {
+    const shimmerIndex = shimmerStep >= 0 ? shimmerStep - index * 3 : -1;
+    const phase = shimmerStep >= 0 ? shimmerStep * 0.015 + index * 0.02 : index * 0.02;
+    return centerLine(animatedLogoLine(line, phase, shimmerIndex), 92);
+  });
+  return [
+    "",
+    rule,
+    ...logo,
+    centerLine(glow, 92),
+    rule,
+    "",
+    ...current,
+    "",
+  ].join("\n");
+}
+
+export async function printSetupHeader(config, installedPlatforms) {
+  if (!useFancyUi()) {
+    console.log("");
+    console.log(color("=== Voxlert Setup ===", ANSI.bold));
+    console.log("");
+    for (const line of formatCurrentConfig(config, installedPlatforms)) {
+      console.log(`  ${line}`);
+    }
+    console.log("");
+    return;
+  }
+
+  process.stdout.write(ANSI.hideCursor);
+  try {
+    const frames = Array.from({ length: 16 }, (_, index) => 4 + index * 6);
+    for (const shimmerStep of frames) {
+      process.stdout.write(ANSI.clear + ANSI.home + renderLogoFrame(config, installedPlatforms, shimmerStep));
+      await sleep(125);
+    }
+    process.stdout.write(ANSI.clear + ANSI.home + renderLogoFrame(config, installedPlatforms));
+  } finally {
+    process.stdout.write(ANSI.showCursor);
+  }
+}
+
+export function printStep(number, title) {
+  console.log(color(`Step ${number}/6: ${title}`, ANSI.bold));
+  console.log("");
+}
+
+export function printStatus(label, value) {
+  console.log(`  ${color(label, ANSI.dim)} ${value}`);
+}
+
+export function printSuccess(message) {
+  console.log(`  ${color("OK", ANSI.green)} ${message}`);
+}
+
+export function printWarning(message) {
+  console.log(`  ${color("->", ANSI.yellow)} ${message}`);
+}
+
+export function highlight(text) {
+  return color(text, ANSI.cyan);
+}

package/src/setup.js

@@ -0,0 +1,504 @@
+/**
+ * Interactive setup wizard for Voxlert.
+ * Handles LLM provider selection, API key input, voice pack picking,
+ * TTS server detection, and Claude Code hook registration.
+ */
+
+import { existsSync, mkdirSync, readdirSync, copyFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import * as http from "http";
+import * as https from "https";
+import select from "@inquirer/select";
+import checkbox from "@inquirer/checkbox";
+import input from "@inquirer/input";
+import confirm from "@inquirer/confirm";
+import { loadConfig, saveConfig, ensureConfig } from "./config.js";
+import { listPacks } from "./packs.js";
+import { CONFIG_PATH, PACKS_DIR, CACHE_DIR, IS_NPM_GLOBAL, BUNDLED_PACKS_DIR, SCRIPT_DIR } from "./paths.js";
+import { PACK_REGISTRY, DEFAULT_DOWNLOAD_PACK_IDS, getPackRegistryBaseUrl } from "./pack-registry.js";
+import { LLM_PROVIDERS, getProvider } from "./providers.js";
+import { registerHooks, installSkill, unregisterHooks, hasVoxlertHooks, hasInstalledSkill, removeSkill } from "./hooks.js";
+import { registerCursorHooks, unregisterCursorHooks, hasCursorHooks } from "./cursor-hooks.js";
+import { registerCodexNotify, getCodexConfigPath, unregisterCodexNotify, hasCodexNotify } from "./codex-config.js";
+import { printSetupHeader, printStep, printStatus, printSuccess, printWarning, highlight } from "./setup-ui.js";
+import {
+  QWEN_DOCS_URL,
+  CHATTERBOX_DOCS_URL,
+  probeTtsBackend,
+  chooseTtsBackend,
+  verifyTtsSetup,
+} from "./tts-test.js";
+
+/**
+ * Validate an API key by making a lightweight request to the provider.
+ */
+function validateApiKey(providerId, apiKey) {
+  return new Promise((resolve) => {
+    const provider = getProvider(providerId);
+    if (!provider) return resolve({ ok: false, error: "Unknown provider" });
+
+    let url;
+    let options;
+
+    const base = provider.baseUrl.replace(/\/+$/, "");
+
+    if (provider.format === "anthropic") {
+      // Anthropic: POST to /v1/messages with a tiny request
+      url = new URL(`${base}/v1/messages`);
+      const authHeaders = provider.authHeader(apiKey);
+      const payload = JSON.stringify({
+        model: provider.defaultModel,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }],
+      });
+      options = {
+        method: "POST",
+        headers: {
+          ...authHeaders,
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+        timeout: 8000,
+      };
+      const req = https.request(url, options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 401) return resolve({ ok: false, error: "Invalid API key" });
+          if (res.statusCode === 403) return resolve({ ok: false, error: "API key lacks permissions" });
+          resolve({ ok: res.statusCode < 500 });
+        });
+      });
+      req.on("error", (err) => resolve({ ok: false, error: err.message }));
+      req.on("timeout", () => { req.destroy(); resolve({ ok: false, error: "Timeout" }); });
+      req.write(payload);
+      req.end();
+    } else {
+      // OpenAI-compatible: GET /models
+      url = new URL(`${base}/models`);
+      const authHeaders = provider.authHeader(apiKey);
+      options = {
+        method: "GET",
+        headers: { ...authHeaders },
+        timeout: 8000,
+      };
+      const reqFn = url.protocol === "https:" ? https.request : http.request;
+      const req = reqFn(url, options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 401) return resolve({ ok: false, error: "Invalid API key" });
+          if (res.statusCode === 403) return resolve({ ok: false, error: "API key lacks permissions" });
+          resolve({ ok: res.statusCode >= 200 && res.statusCode < 300 });
+        });
+      });
+      req.on("error", (err) => resolve({ ok: false, error: err.message }));
+      req.on("timeout", () => { req.destroy(); resolve({ ok: false, error: "Timeout" }); });
+      req.end();
+    }
+  });
+}
+
+/**
+ * Fetch a URL and return the response body as a Buffer.
+ * Rejects on non-2xx or network error.
+ */
+function fetchUrl(url, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    let urlObj;
+    try {
+      urlObj = new URL(url);
+    } catch (e) {
+      return reject(e);
+    }
+    const reqFn = urlObj.protocol === "https:" ? https.request : http.request;
+    const req = reqFn(urlObj, { method: "GET", timeout: timeoutMs }, (res) => {
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        res.resume();
+        return;
+      }
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Timeout"));
+    });
+    req.end();
+  });
+}
+
+/**
+ * Download a voice pack from the registry base URL into PACKS_DIR/<id>/.
+ * Writes pack.json and voice.wav. Resolves on success, rejects on fetch/write error.
+ */
+async function downloadPack(packId, baseUrl) {
+  const dir = join(PACKS_DIR, packId);
+  mkdirSync(dir, { recursive: true });
+
+  const packUrl = `${baseUrl.replace(/\/$/, "")}/${packId}/pack.json`;
+  const voiceUrl = `${baseUrl.replace(/\/$/, "")}/${packId}/voice.wav`;
+
+  const [packBuf, voiceBuf] = await Promise.all([
+    fetchUrl(packUrl),
+    fetchUrl(voiceUrl),
+  ]);
+
+  writeFileSync(join(dir, "pack.json"), packBuf);
+  writeFileSync(join(dir, "voice.wav"), voiceBuf);
+}
+
+/**
+ * Copy bundled packs to the user's packs directory (for npm global installs).
+ */
+function ensurePacks() {
+  if (!IS_NPM_GLOBAL) return;
+  if (!existsSync(BUNDLED_PACKS_DIR)) return;
+
+  mkdirSync(PACKS_DIR, { recursive: true });
+  for (const name of readdirSync(BUNDLED_PACKS_DIR)) {
+    const src = join(BUNDLED_PACKS_DIR, name);
+    const dest = join(PACKS_DIR, name);
+    mkdirSync(dest, { recursive: true });
+
+    const packJson = join(src, "pack.json");
+    if (existsSync(packJson)) {
+      copyFileSync(packJson, join(dest, "pack.json"));
+    }
+    const voiceWav = join(src, "voice.wav");
+    if (existsSync(voiceWav) && !existsSync(join(dest, "voice.wav"))) {
+      copyFileSync(voiceWav, join(dest, "voice.wav"));
+    }
+  }
+}
+
+export async function runSetup() {
+  // Ensure config exists
+  ensureConfig();
+  ensurePacks();
+  mkdirSync(CACHE_DIR, { recursive: true });
+
+  const config = loadConfig();
+  const currentBackend = config.llm_backend || "openrouter";
+  const currentProvider = getProvider(currentBackend);
+  const currentModel = config.llm_model || currentProvider?.defaultModel || "default";
+  const installedPlatforms = [];
+  if (hasVoxlertHooks() || hasInstalledSkill()) installedPlatforms.push("Claude");
+  if (hasCursorHooks()) installedPlatforms.push("Cursor");
+  if (hasCodexNotify()) installedPlatforms.push("Codex");
+  await printSetupHeader(config, installedPlatforms);
+
+  // --- Step 1: LLM Provider ---
+  printStep(1, "LLM Provider");
+
+  const providerChoices = [
+    ...Object.entries(LLM_PROVIDERS).map(([id, p]) => ({
+      name: [
+        p.name,
+        id === currentBackend ? `(current: ${currentModel})` : "",
+        id === "openrouter" ? "(recommended)" : "",
+        "—",
+        p.description,
+      ].filter(Boolean).join(" "),
+      value: id,
+    })),
+    {
+      name: currentBackend === "local" || !config.llm_api_key
+        ? "Skip (current: fallback only) — fallback phrases only, no API key needed"
+        : "Skip — fallback phrases only, no API key needed",
+      value: "skip",
+    },
+  ];
+
+  const chosenProvider = await select({
+    message: "Which LLM provider would you like to use?",
+    choices: providerChoices,
+    default: currentBackend !== "local" ? currentBackend : "openrouter",
+  });
+
+  let apiKey = null;
+
+  if (chosenProvider !== "skip") {
+    config.llm_backend = chosenProvider;
+    const provider = getProvider(chosenProvider);
+
+    // --- Step 2: API Key ---
+    console.log("");
+    printStep(2, "API Key");
+    printStatus("Get a key at:", provider.signupUrl);
+    console.log("");
+
+    const existingKey = config.llm_api_key ?? config.openrouter_api_key ?? "";
+    const maskedExisting = existingKey
+      ? `${existingKey.slice(0, 4)}…${existingKey.slice(-4)}`
+      : "";
+
+    apiKey = await input({
+      message: "Paste your API key:",
+      default: existingKey || undefined,
+      transformer: (val) => {
+        if (!val) return maskedExisting || "";
+        if (val === existingKey) return maskedExisting;
+        if (val.length <= 8) return "****";
+        return val.slice(0, 4) + "…" + val.slice(-4);
+      },
+    });
+
+    if (apiKey) {
+      process.stdout.write("  Validating key... ");
+      const result = await validateApiKey(chosenProvider, apiKey);
+      if (result.ok) {
+        console.log("valid!\n");
+      } else {
+        console.log(`could not validate (${result.error || "unknown error"})`);
+        const proceed = await confirm({
+          message: "Use this key anyway?",
+          default: true,
+        });
+        if (!proceed) {
+          apiKey = null;
+          printWarning("Skipped. Set it later with: voxlert config set llm_api_key <key>");
+          console.log("");
+        } else {
+          console.log("");
+        }
+      }
+
+      if (apiKey) {
+        config.llm_api_key = apiKey;
+        // Clear legacy field if using the new unified field
+        if (chosenProvider === "openrouter") {
+          config.openrouter_api_key = apiKey;
+        }
+      } else {
+        config.llm_api_key = null;
+        config.openrouter_api_key = null;
+      }
+    } else {
+      config.llm_api_key = null;
+      config.openrouter_api_key = null;
+    }
+
+    // Set default model for chosen provider
+    if (!config.llm_model && !config.openrouter_model) {
+      config.llm_model = provider.defaultModel;
+    }
+  } else {
+    config.llm_api_key = null;
+    config.openrouter_api_key = null;
+    console.log("");
+    printWarning("Using fallback phrases from the voice pack.");
+    console.log("");
+  }
+
+  // --- Step 3: Download voice packs (from GitHub) ---
+  console.log("");
+  printStep(3, "Download voice packs");
+  printStatus("Source", "Voxlert GitHub repo");
+  console.log("");
+
+  mkdirSync(PACKS_DIR, { recursive: true });
+  const existingPackIds = new Set();
+  try {
+    for (const entry of readdirSync(PACKS_DIR, { withFileTypes: true })) {
+      if (entry.isDirectory() && existsSync(join(PACKS_DIR, entry.name, "pack.json"))) {
+        existingPackIds.add(entry.name);
+      }
+    }
+  } catch {
+    // PACKS_DIR may not exist yet
+  }
+
+  const packChoices = PACK_REGISTRY.map((p) => ({
+    name: existingPackIds.has(p.id) ? `${p.name} (already installed)` : p.name,
+    value: p.id,
+    checked: existingPackIds.size > 0
+      ? existingPackIds.has(p.id)
+      : DEFAULT_DOWNLOAD_PACK_IDS.includes(p.id),
+  }));
+
+  const toDownload = await checkbox({
+    message: "Which voice packs do you want to install? (downloaded from GitHub)",
+    choices: packChoices,
+    required: false,
+  });
+
+  const baseUrl = getPackRegistryBaseUrl();
+  for (const packId of toDownload || []) {
+    if (existingPackIds.has(packId)) continue;
+    const pack = PACK_REGISTRY.find((p) => p.id === packId);
+    const label = pack ? pack.name : packId;
+    process.stdout.write(`  Downloading ${label}... `);
+    try {
+      await downloadPack(packId, baseUrl);
+      console.log("done.");
+    } catch (err) {
+      console.log(`failed (${err.message}).`);
+    }
+  }
+
+  // --- Step 4: Voice Pack ---
+  printStep(4, "Voice Pack");
+
+  const packs = listPacks();
+  if (packs.length > 0) {
+    const active = config.active_pack || "";
+    const packChoices = [
+      {
+        name: active === "random" ? "Random (current)" : "Random",
+        value: "random",
+        description: "Picks a different voice each time",
+      },
+      ...packs.map((p) => ({
+        name: p.id === active ? `${p.name} (current)` : p.name,
+        value: p.id,
+        description: p.id,
+      })),
+    ];
+
+    const chosenPack = await select({
+      message: "Choose a voice pack:",
+      choices: packChoices,
+      default: active || "sc2-adjutant",
+    });
+    config.active_pack = chosenPack;
+  } else {
+    printWarning("No voice packs found. Using default.");
+    console.log("");
+  }
+
+  // --- Step 5: TTS Server ---
+  console.log("");
+  printStep(5, "TTS Server");
+
+  printStatus("Recommended", "Qwen TTS for a more natural voice");
+  printStatus("Voice test", `Uses the voice you picked in Step 4 (${config.active_pack || "default"})`);
+  printStatus("Qwen TTS setup docs", QWEN_DOCS_URL);
+  printStatus("Chatterbox setup docs", CHATTERBOX_DOCS_URL);
+  console.log("");
+
+  process.stdout.write("  Checking Chatterbox (port 8004)... ");
+  const chatterboxUp = await probeTtsBackend(config, "chatterbox");
+  console.log(chatterboxUp ? "detected!" : "not running");
+
+  process.stdout.write("  Checking Qwen TTS (port 8100)...   ");
+  const qwenUp = await probeTtsBackend(config, "qwen");
+  console.log(qwenUp ? "detected!" : "not running");
+
+  config.tts_backend = await chooseTtsBackend(config, { qwenUp, chatterboxUp });
+  await verifyTtsSetup(config, config.tts_backend);
+
+  // --- Step 6: Hooks (platforms) ---
+  console.log("");
+  printStep(6, "Hooks");
+
+  const platformChoices = [
+    {
+      name: "Claude Code",
+      value: "claude",
+      description: "Register in ~/.claude/settings.json + install skill",
+      checked: hasVoxlertHooks() || hasInstalledSkill(),
+    },
+    {
+      name: "Cursor",
+      value: "cursor",
+      description: "Register in ~/.cursor/hooks.json (Agent / Cmd+K)",
+      checked: hasCursorHooks(),
+    },
+    {
+      name: "Codex",
+      value: "codex",
+      description: "Install/update notify in ~/.codex/config.toml",
+      checked: hasCodexNotify(),
+    },
+  ];
+
+  const selectedPlatforms = await checkbox({
+    message: "Which platforms do you want to install hooks for?",
+    choices: platformChoices,
+    required: false,
+  });
+
+  // Determine the hook command for Claude Code (used when "claude" is selected)
+  const hookCommand = IS_NPM_GLOBAL ? "voxlert hook" : join(SCRIPT_DIR, "voxlert.sh");
+  const codexNotifyCommand = IS_NPM_GLOBAL
+    ? ["voxlert", "codex-notify"]
+    : [process.execPath, join(SCRIPT_DIR, "src", "cli.js"), "codex-notify"];
+
+  if (selectedPlatforms.includes("claude")) {
+    const hookCount = registerHooks(hookCommand);
+    printSuccess(`Registered ${hookCount} hook events in ~/.claude/settings.json`);
+    if (installSkill()) {
+      printSuccess("Installed voxlert-config skill");
+    }
+  } else {
+    const removed = unregisterHooks();
+    const skillRemoved = removeSkill();
+    if (removed > 0) {
+      printWarning(`Removed ${removed} hook(s) from ~/.claude/settings.json`);
+    }
+    if (skillRemoved) {
+      printWarning("Removed voxlert-config skill");
+    }
+  }
+
+  if (selectedPlatforms.includes("cursor")) {
+    const cursorCount = registerCursorHooks("voxlert cursor-hook");
+    printSuccess(`Registered ${cursorCount} hook events in ~/.cursor/hooks.json`);
+    printStatus("Next", "Restart Cursor to hear Voxlert in Agent Chat.");
+  } else {
+    const cursorRemoved = unregisterCursorHooks();
+    if (cursorRemoved > 0) {
+      printWarning(`Removed ${cursorRemoved} hook(s) from ~/.cursor/hooks.json`);
+    }
+  }
+
+  if (selectedPlatforms.includes("codex")) {
+    registerCodexNotify(codexNotifyCommand);
+    printSuccess(`Installed Codex notify command in ${getCodexConfigPath()}`);
+  } else {
+    const codexRemoved = unregisterCodexNotify();
+    if (codexRemoved) {
+      printWarning(`Removed Codex notify from ${getCodexConfigPath()}`);
+    }
+  }
+
+  if (selectedPlatforms.length === 0) {
+    printWarning("No platforms selected. Run 'voxlert setup' again to install hooks later.");
+  }
+
+  // --- Save config ---
+  saveConfig(config);
+
+  // --- Summary ---
+  console.log("");
+  console.log(highlight("=== Setup Complete ==="));
+  console.log("");
+  printStatus("Config", CONFIG_PATH);
+  if (chosenProvider !== "skip") {
+    const p = getProvider(config.llm_backend);
+    printStatus("LLM", `${p ? p.name : config.llm_backend} (${config.llm_model || p?.defaultModel || "default"})`);
+  } else {
+    printStatus("LLM", "Skipped (fallback phrases only)");
+  }
+  printStatus("Voice", config.active_pack);
+  printStatus("TTS", config.tts_backend);
+  console.log("");
+  console.log(`  ${highlight("Start a new session in each platform you installed to hear Voxlert.")}`);
+  if (selectedPlatforms.includes("claude")) {
+    printStatus("Claude Code", "Start a new Claude Code session.");
+  }
+  if (selectedPlatforms.includes("cursor")) {
+    printStatus("Cursor", "Restart Cursor to hear Voxlert in Agent Chat.");
+  }
+  if (selectedPlatforms.includes("codex")) {
+    printStatus("Codex", "Start a new Codex session to pick up the notify config.");
+  }
+  printStatus("Reconfigure", "voxlert setup");
+  console.log("");
+}