@settinghead/voxlert 0.3.5

package/src/audio.js

@@ -0,0 +1,381 @@
+import {
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  unlinkSync,
+  renameSync,
+  mkdirSync,
+  existsSync,
+  statSync,
+  utimesSync,
+} from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+import { spawn, execSync } from "child_process";
+import { request as httpsRequest } from "https";
+import { request as httpRequest } from "http";
+import { CACHE_DIR, QUEUE_DIR, LOCK_FILE } from "./paths.js";
+
+const DEFAULT_MAX_CACHE = 150;
+
+function evictCache(cacheDir, maxEntries) {
+  let files;
+  try {
+    files = readdirSync(cacheDir)
+      .filter((f) => f.endsWith(".wav"))
+      .map((f) => {
+        const p = join(cacheDir, f);
+        return { path: p, atime: statSync(p).atimeMs };
+      });
+  } catch {
+    return;
+  }
+  if (files.length <= maxEntries) return;
+  // Sort oldest-accessed first, remove excess
+  files.sort((a, b) => a.atime - b.atime);
+  const toRemove = files.length - maxEntries;
+  for (let i = 0; i < toRemove; i++) {
+    try {
+      unlinkSync(files[i].path);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function touchFile(filePath) {
+  const now = new Date();
+  try {
+    utimesSync(filePath, now, statSync(filePath).mtime);
+  } catch {
+    // ignore
+  }
+}
+
+function audioFilter() {
+  // Short multi-tap echo: two taps at 40ms and 75ms with moderate decay
+  return "aecho=0.8:0.88:40|75:0.4|0.25";
+}
+
+// --- File-based playback queue ---
+
+function acquireLock() {
+  mkdirSync(QUEUE_DIR, { recursive: true });
+  try {
+    writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    // Lock exists — check if holder is still alive
+    try {
+      const pid = parseInt(readFileSync(LOCK_FILE, "utf-8").trim(), 10);
+      process.kill(pid, 0); // throws if dead
+      return false; // holder alive, let it drain the queue
+    } catch {
+      // Stale lock — reclaim
+      try {
+        unlinkSync(LOCK_FILE);
+        writeFileSync(LOCK_FILE, String(process.pid), { flag: "wx" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+}
+
+function releaseLock() {
+  try {
+    unlinkSync(LOCK_FILE);
+  } catch {
+    // ignore
+  }
+}
+
+function enqueue(cachePath, volume) {
+  mkdirSync(QUEUE_DIR, { recursive: true });
+  const filename = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
+  writeFileSync(join(QUEUE_DIR, filename), JSON.stringify({ cachePath, volume }));
+}
+
+function getNextEntry() {
+  try {
+    const files = readdirSync(QUEUE_DIR)
+      .filter((f) => f.endsWith(".json"))
+      .sort();
+    return files.length > 0 ? files[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+// --- Playback ---
+
+function applyEcho(cachePath, customAudioFilter) {
+  if (!existsSync(cachePath)) return;
+  const tmpOut = cachePath + ".fx.wav";
+  const filter = customAudioFilter || audioFilter();
+  try {
+    execSync(
+      `ffmpeg -y -i "${cachePath}" -af "${filter}" "${tmpOut}"`,
+      { timeout: 10000, stdio: "ignore" },
+    );
+    if (existsSync(tmpOut)) {
+      unlinkSync(cachePath);
+      renameSync(tmpOut, cachePath);
+    }
+  } catch {
+    try { unlinkSync(tmpOut); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Return { cmd, args } to play a WAV file, or null if no player for this platform.
+ * - darwin: afplay (macOS)
+ * - win32: ffplay (FFmpeg) — install FFmpeg and add to PATH
+ * - linux: ffplay, else paplay (PulseAudio) or pw-play (PipeWire)
+ */
+function getPlaybackCommand(platform, volume, cachePath) {
+  const vol = Math.max(0, Math.min(1, volume));
+  if (platform === "darwin") {
+    return { cmd: "afplay", args: ["-v", String(vol), cachePath] };
+  }
+  if (platform === "win32") {
+    return { cmd: "ffplay", args: ["-nodisp", "-autoexit", "-loglevel", "quiet", cachePath] };
+  }
+  if (platform === "linux") {
+    return { cmd: "ffplay", args: ["-nodisp", "-autoexit", "-loglevel", "quiet", cachePath] };
+  }
+  return null;
+}
+
+export function playFile(cachePath, volume) {
+  return new Promise((resolve) => {
+    if (!existsSync(cachePath)) return resolve();
+    const platform = process.platform;
+    const spec = getPlaybackCommand(platform, volume, cachePath);
+    if (!spec) return resolve();
+    const proc = spawn(spec.cmd, spec.args, {
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    proc.on("error", () => resolve());
+    proc.on("close", () => resolve());
+  });
+}
+
+async function processQueue() {
+  if (!acquireLock()) return;
+  try {
+    let entry;
+    while ((entry = getNextEntry())) {
+      const entryPath = join(QUEUE_DIR, entry);
+      try {
+        const entry_data = JSON.parse(
+          readFileSync(entryPath, "utf-8"),
+        );
+        unlinkSync(entryPath);
+        await playFile(entry_data.cachePath, entry_data.volume);
+      } catch {
+        try {
+          unlinkSync(entryPath);
+        } catch {
+          // ignore
+        }
+      }
+    }
+  } finally {
+    releaseLock();
+  }
+}
+
+// --- TTS download ---
+
+function downloadChatterbox(phrase, cachePath, config, voicePath, ttsParams) {
+  return new Promise((resolve) => {
+    const chatterboxUrl = config.chatterbox_url || "http://localhost:8004";
+    const endpoint = `${chatterboxUrl}/tts`;
+
+    const body = {
+      text: phrase,
+      voice_mode: "predefined",
+      predefined_voice_id: voicePath || config.voice || "default.wav",
+      output_format: "wav",
+    };
+    // Apply per-pack TTS parameters (exaggeration, cfg_weight, temperature)
+    if (ttsParams) {
+      if (ttsParams.exaggeration != null) body.exaggeration = ttsParams.exaggeration;
+      if (ttsParams.cfg_weight != null) body.cfg_weight = ttsParams.cfg_weight;
+      if (ttsParams.temperature != null) body.temperature = ttsParams.temperature;
+    }
+    const payload = JSON.stringify(body);
+
+    const url = new URL(endpoint);
+    const requestFn = url.protocol === "https:" ? httpsRequest : httpRequest;
+
+    const req = requestFn(
+      endpoint,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+        timeout: 8000,
+      },
+      (res) => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          res.resume();
+          return resolve();
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          try {
+            writeFileSync(cachePath, Buffer.concat(chunks));
+          } catch {
+            // ignore
+          }
+          resolve();
+        });
+        res.on("error", () => resolve());
+      },
+    );
+
+    req.on("error", () => resolve());
+    req.on("timeout", () => {
+      req.destroy();
+      resolve();
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+function downloadQwen(phrase, cachePath, config, packId) {
+  return new Promise((resolve) => {
+    const qwenUrl = config.qwen_tts_url || "http://localhost:8100";
+    const endpoint = `${qwenUrl}/tts`;
+
+    const payload = JSON.stringify({ text: phrase, pack_id: packId });
+
+    const url = new URL(endpoint);
+    const requestFn = url.protocol === "https:" ? httpsRequest : httpRequest;
+
+    const req = requestFn(
+      endpoint,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+        timeout: 30000,
+      },
+      (res) => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          res.resume();
+          return resolve();
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          try {
+            writeFileSync(cachePath, Buffer.concat(chunks));
+          } catch {
+            // ignore
+          }
+          resolve();
+        });
+        res.on("error", () => resolve());
+      },
+    );
+
+    req.on("error", () => resolve());
+    req.on("timeout", () => {
+      req.destroy();
+      resolve();
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+function downloadToCache(phrase, cachePath, config, voicePath, ttsParams, packId) {
+  if (config.tts_backend === "qwen") {
+    return downloadQwen(phrase, cachePath, config, packId);
+  }
+  return downloadChatterbox(phrase, cachePath, config, voicePath, ttsParams);
+}
+
+// --- Post-processing ---
+
+function normalizeVolume(cachePath) {
+  if (!existsSync(cachePath)) return;
+  const tmpOut = cachePath + ".norm.wav";
+  try {
+    // Simple peak normalization to -3dB headroom — no look-ahead artifacts
+    execSync(
+      `sox "${cachePath}" "${tmpOut}" norm -3`,
+      { timeout: 10000, stdio: "ignore" },
+    );
+    if (existsSync(tmpOut)) {
+      unlinkSync(cachePath);
+      renameSync(tmpOut, cachePath);
+    }
+  } catch {
+    try { unlinkSync(tmpOut); } catch { /* ignore */ }
+  }
+}
+
+function postProcess(cachePath, command) {
+  if (!command || !existsSync(cachePath)) return;
+  const tmpOut = cachePath + ".tmp.wav";
+  // Replace $INPUT and $OUTPUT placeholders in command
+  const cmd = command.replace(/\$INPUT/g, cachePath).replace(/\$OUTPUT/g, tmpOut);
+  try {
+    execSync(cmd, { timeout: 15000, stdio: "ignore" });
+    if (existsSync(tmpOut)) {
+      unlinkSync(cachePath);
+      renameSync(tmpOut, cachePath);
+    }
+  } catch {
+    // Post-processing failed — use raw TTS output
+    try { unlinkSync(tmpOut); } catch { /* ignore */ }
+  }
+}
+
+// --- Public API ---
+
+export async function speakPhrase(phrase, config, pack) {
+  const packId = (pack && pack.id) || "_default";
+  const packCacheDir = join(CACHE_DIR, packId);
+  mkdirSync(packCacheDir, { recursive: true });
+
+  const ttsParams = pack ? pack.tts_params : null;
+  const backend = config.tts_backend || "chatterbox";
+  const cacheKey = createHash("md5")
+    .update(backend + ":" + phrase.toLowerCase() + (ttsParams ? JSON.stringify(ttsParams) : ""))
+    .digest("hex");
+  const cachePath = join(packCacheDir, `${cacheKey}.wav`);
+  const volume = config.volume ?? 0.5;
+  const maxCache = config.max_cache_entries ?? DEFAULT_MAX_CACHE;
+  const echo = pack ? pack.echo !== false : true;
+  const voicePath = (pack && pack.voicePath) || config.voice || "default.wav";
+  const customAudioFilter = (pack && pack.audio_filter) || null;
+  const postProcessCmd = (pack && pack.post_process) || null;
+
+  // Ensure audio is in cache (all effects baked in at cache time)
+  if (existsSync(cachePath)) {
+    touchFile(cachePath);
+  } else {
+    await downloadToCache(phrase, cachePath, config, voicePath, ttsParams, packId);
+    if (!existsSync(cachePath)) return; // download failed
+    if (postProcessCmd) postProcess(cachePath, postProcessCmd);
+    if (customAudioFilter || echo) applyEcho(cachePath, customAudioFilter);
+    normalizeVolume(cachePath);
+    evictCache(packCacheDir, maxCache);
+  }
+
+  // Enqueue and try to become the player
+  enqueue(cachePath, volume);
+  await processQueue();
+}

package/src/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { STATE_DIR } from "./paths.js";
+import { getUpgradeInfo, printUpgradeNotification } from "./upgrade-check.js";
+import { COMMANDS, resolveCommand } from "./commands/index.js";
+import { formatHelp } from "./commands/help.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+
+function isPromptAbort(err) {
+  const name = err && typeof err.name === "string" ? err.name : "";
+  const message = err && typeof err.message === "string" ? err.message : "";
+  return name === "ExitPromptError" || message.includes("User force closed the prompt");
+}
+
+function createHelpText() {
+  return formatHelp(COMMANDS, pkg);
+}
+
+async function maybeRunSetup(command) {
+  if (command.skipSetupWizard || existsSync(STATE_DIR)) return false;
+  console.log("Welcome to Voxlert! Let's get you set up.\n");
+  const { runSetup } = await import("./setup.js");
+  await runSetup();
+  return true;
+}
+
+(async () => {
+  const args = process.argv.slice(2);
+  const requested = args[0] || "help";
+  const command = resolveCommand(requested);
+
+  const interactiveUpgrade =
+    process.stdout.isTTY &&
+    (!command || !command.skipUpgradeCheck);
+  const upgradePromise = interactiveUpgrade
+    ? getUpgradeInfo(pkg.version, pkg.name)
+    : null;
+
+  if (!command) {
+    console.error(`Unknown command: ${requested}\n`);
+    console.log(createHelpText());
+    process.exit(1);
+  }
+
+  if (await maybeRunSetup(command)) {
+    return;
+  }
+
+  await command.run({
+    args,
+    command,
+    formatHelp: createHelpText,
+    pkg,
+  });
+
+  if (upgradePromise) {
+    try {
+      const info = await upgradePromise;
+      if (info) {
+        const releaseNotesUrl =
+          pkg.repository?.url &&
+          String(pkg.repository.url).replace(/\.git$/i, "").replace(/^git\+https:/, "https:");
+        printUpgradeNotification(info, {
+          packageName: pkg.name,
+          releaseNotesUrl: releaseNotesUrl
+            ? `${releaseNotesUrl}/releases/latest`
+            : undefined,
+        });
+      }
+    } catch {
+      // non-fatal: ignore
+    }
+  }
+})().catch((err) => {
+  if (isPromptAbort(err)) {
+    process.stdout.write("\n");
+    process.exit(130);
+  }
+  console.error(err && err.stack ? err.stack : String(err));
+  process.exit(1);
+});

package/src/codex-config.js

@@ -0,0 +1,149 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const CODEX_DIR = join(homedir(), ".codex");
+const CODEX_CONFIG_FILE = join(CODEX_DIR, "config.toml");
+
+function splitTopLevelPrefix(content) {
+  const lines = content.split("\n");
+  const firstSectionIndex = lines.findIndex((line) => /^\s*\[/.test(line));
+  if (firstSectionIndex === -1) {
+    return { prefixLines: lines, suffixLines: [] };
+  }
+  return {
+    prefixLines: lines.slice(0, firstSectionIndex),
+    suffixLines: lines.slice(firstSectionIndex),
+  };
+}
+
+function countBrackets(text) {
+  let depth = 0;
+  for (const ch of text) {
+    if (ch === "[") depth++;
+    if (ch === "]") depth--;
+  }
+  return depth;
+}
+
+function replaceTopLevelArrayAssignment(content, key, renderedValue) {
+  const { prefixLines, suffixLines } = splitTopLevelPrefix(content);
+  const output = [];
+  let i = 0;
+  let replaced = false;
+
+  while (i < prefixLines.length) {
+    const line = prefixLines[i];
+    if (/^\s*$/.test(line) || /^\s*#/.test(line)) {
+      output.push(line);
+      i++;
+      continue;
+    }
+
+    const match = line.match(new RegExp(`^(\\s*)${key}\\s*=`));
+    if (!match) {
+      output.push(line);
+      i++;
+      continue;
+    }
+
+    replaced = true;
+    output.push(`${match[1]}${key} = ${renderedValue}`);
+
+    let depth = countBrackets(line.slice(line.indexOf("=") + 1));
+    i++;
+    while (depth > 0 && i < prefixLines.length) {
+      depth += countBrackets(prefixLines[i]);
+      i++;
+    }
+  }
+
+  if (!replaced) {
+    while (output.length > 0 && output[output.length - 1] === "") {
+      output.pop();
+    }
+    if (output.length > 0) output.push("");
+    output.push(`${key} = ${renderedValue}`);
+    if (suffixLines.length > 0) output.push("");
+  }
+
+  return [...output, ...suffixLines].join("\n");
+}
+
+function removeTopLevelAssignment(content, key) {
+  const { prefixLines, suffixLines } = splitTopLevelPrefix(content);
+  const output = [];
+  let i = 0;
+  let removed = false;
+
+  while (i < prefixLines.length) {
+    const line = prefixLines[i];
+    const match = line.match(new RegExp(`^(\\s*)${key}\\s*=`));
+    if (!match) {
+      output.push(line);
+      i++;
+      continue;
+    }
+
+    removed = true;
+    let depth = countBrackets(line.slice(line.indexOf("=") + 1));
+    i++;
+    while (depth > 0 && i < prefixLines.length) {
+      depth += countBrackets(prefixLines[i]);
+      i++;
+    }
+  }
+
+  while (output.length > 0 && output[output.length - 1] === "" && suffixLines.length > 0 && /^\s*\[/.test(suffixLines[0])) {
+    output.pop();
+  }
+
+  return {
+    removed,
+    content: [...output, ...suffixLines].join("\n"),
+  };
+}
+
+function loadCodexConfig() {
+  try {
+    return readFileSync(CODEX_CONFIG_FILE, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+function saveCodexConfig(content) {
+  mkdirSync(CODEX_DIR, { recursive: true });
+  const normalized = content.endsWith("\n") ? content : `${content}\n`;
+  writeFileSync(CODEX_CONFIG_FILE, normalized);
+}
+
+function renderTomlStringArray(values) {
+  return `[${values.map((value) => JSON.stringify(value)).join(", ")}]`;
+}
+
+export function getCodexConfigPath() {
+  return CODEX_CONFIG_FILE;
+}
+
+export function hasCodexNotify() {
+  if (!existsSync(CODEX_CONFIG_FILE)) return false;
+  const current = loadCodexConfig();
+  return /^\s*notify\s*=/m.test(splitTopLevelPrefix(current).prefixLines.join("\n"));
+}
+
+export function registerCodexNotify(commandArgs) {
+  const current = loadCodexConfig();
+  const next = replaceTopLevelArrayAssignment(current, "notify", renderTomlStringArray(commandArgs));
+  saveCodexConfig(next);
+  return existsSync(CODEX_CONFIG_FILE);
+}
+
+export function unregisterCodexNotify() {
+  if (!existsSync(CODEX_CONFIG_FILE)) return false;
+  const current = loadCodexConfig();
+  const { removed, content } = removeTopLevelAssignment(current, "notify");
+  if (!removed) return false;
+  saveCodexConfig(content);
+  return true;
+}

package/src/commands/codex-notify.js

@@ -0,0 +1,70 @@
+import { processHookEvent } from "../voxlert.js";
+import {
+  appendHookDebugLine,
+  CODEX_NOTIFY_TYPE_TO_EVENT,
+  getHookRuntimeInfo,
+  normalizeCodexInputMessages,
+  stringifyForLog,
+} from "./hook-utils.js";
+
+export const codexNotifyCommand = {
+  name: "codex-notify",
+  aliases: [],
+  help: [
+    "  voxlert codex-notify        Process a notify payload from argv (used by OpenAI Codex notify)",
+  ],
+  skipSetupWizard: true,
+  skipUpgradeCheck: true,
+  async run() {
+    const argvTail = process.argv.slice(3);
+    const rawArg = argvTail[0] === "--" ? argvTail[1] : argvTail[0];
+    const raw = typeof rawArg === "string" ? rawArg : "";
+    appendHookDebugLine(`voxlert codex-notify runtime ${stringifyForLog(getHookRuntimeInfo())}`);
+    appendHookDebugLine(`voxlert codex-notify argv_tail=${stringifyForLog(argvTail)} raw=${stringifyForLog(raw)}`);
+    if (!raw || typeof raw !== "string") {
+      appendHookDebugLine("voxlert codex-notify exiting: missing raw payload");
+      process.exit(0);
+    }
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+      appendHookDebugLine(`voxlert codex-notify parsed payload ${stringifyForLog(payload)}`);
+      appendHookDebugLine(`voxlert codex-notify payload summary ${stringifyForLog({
+        type: payload.type || "",
+        cwd: payload.cwd || "",
+        hasLastAssistantMessage: Boolean(payload["last-assistant-message"] || payload.last_assistant_message),
+        inputMessageCount: Array.isArray(payload["input-messages"] || payload.input_messages || payload.inputMessages)
+          ? (payload["input-messages"] || payload.input_messages || payload.inputMessages).length
+          : 0,
+        threadId: payload["thread-id"] || payload.thread_id || "",
+        turnId: payload["turn-id"] || payload.turn_id || "",
+      })}`);
+    } catch (err) {
+      appendHookDebugLine(`voxlert codex-notify parse error ${err && err.message}`);
+      process.exit(0);
+    }
+    const codexType = payload.type || "";
+    const ourEvent = CODEX_NOTIFY_TYPE_TO_EVENT[codexType];
+    if (!ourEvent) {
+      appendHookDebugLine(`voxlert codex-notify exiting: unsupported type=${codexType || "(empty)"}`);
+      process.exit(0);
+    }
+    const translated = {
+      hook_event_name: ourEvent,
+      cwd: payload.cwd || "",
+      source: "codex",
+      last_assistant_message: payload["last-assistant-message"] || payload.last_assistant_message || "",
+      input_messages: normalizeCodexInputMessages(payload),
+      codex_thread_id: payload["thread-id"] || payload.thread_id || "",
+      codex_turn_id: payload["turn-id"] || payload.turn_id || "",
+    };
+    appendHookDebugLine(`voxlert codex-notify translated event ${stringifyForLog(translated)}`);
+    try {
+      await processHookEvent(translated);
+      appendHookDebugLine(`voxlert codex-notify processHookEvent completed type=${codexType} event=${ourEvent}`);
+    } catch (err) {
+      appendHookDebugLine(`voxlert codex-notify processHookEvent error ${err && err.message}`);
+    }
+    process.exit(0);
+  },
+};