tokentracker-cli 0.2.23

package/src/lib/claude-config.js

@@ -0,0 +1,190 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+
+const { ensureDir, readJson, writeJson } = require("./fs");
+
+const DEFAULT_EVENT = "SessionEnd";
+
+async function upsertClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const existing = await readJson(settingsPath);
+  const settings = normalizeSettings(existing);
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+
+  const normalized = normalizeEntriesForCommand(entries, hookCommand);
+  if (normalized.changed) {
+    const nextHooks = { ...hooks, [event]: normalized.entries };
+    const nextSettings = { ...settings, hooks: nextHooks };
+    const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+    return { changed: true, backupPath };
+  }
+
+  if (hasHook(entries, hookCommand)) {
+    return { changed: false, backupPath: null };
+  }
+
+  const nextEntries = entries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
+  const nextHooks = { ...hooks, [event]: nextEntries };
+  const nextSettings = { ...settings, hooks: nextHooks };
+
+  const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+  return { changed: true, backupPath };
+}
+
+async function removeClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const existing = await readJson(settingsPath);
+  if (!existing) return { removed: false, skippedReason: "settings-missing" };
+
+  const settings = normalizeSettings(existing);
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+  if (entries.length === 0) return { removed: false, skippedReason: "hook-missing" };
+
+  let removed = false;
+  const nextEntries = [];
+  for (const entry of entries) {
+    const res = stripHookFromEntry(entry, hookCommand);
+    if (res.removed) removed = true;
+    if (res.entry) nextEntries.push(res.entry);
+  }
+
+  if (!removed) return { removed: false, skippedReason: "hook-missing" };
+
+  const nextHooks = { ...hooks };
+  if (nextEntries.length > 0) nextHooks[event] = nextEntries;
+  else delete nextHooks[event];
+
+  const nextSettings = { ...settings };
+  if (Object.keys(nextHooks).length > 0) nextSettings.hooks = nextHooks;
+  else delete nextSettings.hooks;
+
+  const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+  return { removed: true, skippedReason: null, backupPath };
+}
+
+async function isClaudeHookConfigured({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const settings = await readJson(settingsPath);
+  if (!settings || typeof settings !== "object") return false;
+  const hooks = settings.hooks;
+  if (!hooks || typeof hooks !== "object") return false;
+  const entries = normalizeEntries(hooks[event]);
+  return hasHook(entries, hookCommand);
+}
+
+function buildClaudeHookCommand(notifyPath) {
+  const cmd = typeof notifyPath === "string" ? notifyPath : "";
+  return `/usr/bin/env node ${quoteArg(cmd)} --source=claude`;
+}
+
+function normalizeSettings(raw) {
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeHooks(raw) {
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeEntries(raw) {
+  return Array.isArray(raw) ? raw.slice() : [];
+}
+
+function normalizeCommand(cmd) {
+  if (Array.isArray(cmd)) return cmd.map((v) => String(v)).join("\u0000");
+  if (typeof cmd === "string") return cmd.trim();
+  return null;
+}
+
+function hasHook(entries, hookCommand) {
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.command && commandsEqual(entry.command, hookCommand)) return true;
+    const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+    for (const hook of hooks) {
+      if (hook && commandsEqual(hook.command, hookCommand)) return true;
+    }
+  }
+  return false;
+}
+
+function stripHookFromEntry(entry, hookCommand) {
+  if (!entry || typeof entry !== "object") return { entry, removed: false };
+
+  if (entry.command) {
+    if (commandsEqual(entry.command, hookCommand)) return { entry: null, removed: true };
+    return { entry, removed: false };
+  }
+
+  const hooks = Array.isArray(entry.hooks) ? entry.hooks : null;
+  if (!hooks) return { entry, removed: false };
+
+  const nextHooks = hooks.filter((hook) => !commandsEqual(hook?.command, hookCommand));
+  if (nextHooks.length === hooks.length) return { entry, removed: false };
+  if (nextHooks.length === 0) return { entry: null, removed: true };
+
+  return { entry: { ...entry, hooks: nextHooks }, removed: true };
+}
+
+function normalizeEntriesForCommand(entries, hookCommand) {
+  let changed = false;
+  const nextEntries = entries.map((entry) => {
+    if (!entry || typeof entry !== "object") return entry;
+    if (entry.command && commandsEqual(entry.command, hookCommand)) {
+      if (entry.type !== "command") {
+        changed = true;
+        return { ...entry, type: "command" };
+      }
+      return entry;
+    }
+    if (!Array.isArray(entry.hooks)) return entry;
+    let hooksChanged = false;
+    const nextHooks = entry.hooks.map((hook) => {
+      if (hook && commandsEqual(hook.command, hookCommand)) {
+        if (hook.type !== "command") {
+          hooksChanged = true;
+          return { ...hook, type: "command" };
+        }
+      }
+      return hook;
+    });
+    if (!hooksChanged) return entry;
+    changed = true;
+    return { ...entry, hooks: nextHooks };
+  });
+  return { entries: nextEntries, changed };
+}
+
+function commandsEqual(a, b) {
+  const left = normalizeCommand(a);
+  const right = normalizeCommand(b);
+  return Boolean(left && right && left === right);
+}
+
+function quoteArg(value) {
+  const v = typeof value === "string" ? value : "";
+  if (!v) return '""';
+  if (/^[A-Za-z0-9_\-./:@]+$/.test(v)) return v;
+  return `"${v.replace(/"/g, '\\"')}"`;
+}
+
+async function writeClaudeSettings({ settingsPath, settings }) {
+  await ensureDir(path.dirname(settingsPath));
+  let backupPath = null;
+  try {
+    const st = await fs.stat(settingsPath);
+    if (st && st.isFile()) {
+      backupPath = `${settingsPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+      await fs.copyFile(settingsPath, backupPath);
+    }
+  } catch (_e) {
+    // Ignore missing file.
+  }
+  await writeJson(settingsPath, settings);
+  return backupPath;
+}
+
+module.exports = {
+  upsertClaudeHook,
+  removeClaudeHook,
+  isClaudeHookConfigured,
+  buildClaudeHookCommand,
+};

package/src/lib/cli-ui.js

@@ -0,0 +1,179 @@
+const readline = require("node:readline");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const UNDERLINE = "\x1b[4m";
+
+const SPINNER_FRAMES = ["|", "/", "-", "\\"];
+
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function formatLine(line, width) {
+  if (!width) return line;
+  const raw = String(line || "");
+  const pad = Math.max(0, width - raw.length);
+  return raw + " ".repeat(pad);
+}
+
+function renderBox(lines, { padding = 1 } = {}) {
+  const content = lines.map((line) => String(line || ""));
+  const maxLen = content.reduce((max, line) => Math.max(max, line.length), 0);
+  const innerWidth = maxLen + padding * 2;
+  const top = `+${"-".repeat(innerWidth)}+`;
+  const bottom = `+${"-".repeat(innerWidth)}+`;
+  const body = content.map((line) => {
+    const padded = " ".repeat(padding) + formatLine(line, maxLen) + " ".repeat(padding);
+    return `|${padded}|`;
+  });
+  return [top, ...body, bottom].join("\n");
+}
+
+function color(text, token) {
+  return `${token}${text}${RESET}`;
+}
+
+function underline(text) {
+  return `${UNDERLINE}${text}${RESET}`;
+}
+
+async function promptEnter(message) {
+  if (!isInteractive()) return;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve) => rl.question(message, () => resolve()));
+  rl.close();
+}
+
+async function promptMenu({ message, options, defaultIndex = 0 }) {
+  if (!isInteractive()) return options[defaultIndex] || options[0];
+
+  const safeOptions = Array.isArray(options) ? options : [];
+  if (safeOptions.length === 0) return "";
+
+  const maxIndex = safeOptions.length - 1;
+  let currentIndex = Math.min(Math.max(defaultIndex, 0), maxIndex);
+  const promptMessage = `${message} (Use Up/Down arrows, Enter)`;
+  const linesCount = safeOptions.length + 1;
+
+  const renderLines = () => {
+    const lines = [promptMessage];
+    safeOptions.forEach((opt, idx) => {
+      const prefix = idx === currentIndex ? ">" : " ";
+      lines.push(`${prefix} ${opt}`);
+    });
+    process.stdout.write(lines.join("\n"));
+  };
+
+  const rerender = () => {
+    for (let i = 0; i < linesCount; i += 1) {
+      process.stdout.write("\x1b[2K");
+      if (i < linesCount - 1) process.stdout.write("\x1b[1A");
+    }
+    process.stdout.write("\r");
+    renderLines();
+  };
+
+  renderLines();
+
+  return await new Promise((resolve) => {
+    const cleanup = () => {
+      process.stdin.off("keypress", onKeypress);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write("\n");
+    };
+
+    const onKeypress = (str, key = {}) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        return resolve(safeOptions[currentIndex]);
+      }
+      if (key.name === "up" || str === "k") {
+        currentIndex = currentIndex === 0 ? maxIndex : currentIndex - 1;
+        rerender();
+        return;
+      }
+      if (key.name === "down" || str === "j") {
+        currentIndex = currentIndex === maxIndex ? 0 : currentIndex + 1;
+        rerender();
+        return;
+      }
+      if (key.name === "return") {
+        cleanup();
+        return resolve(safeOptions[currentIndex]);
+      }
+      if (str && /^[1-9]$/.test(str)) {
+        const idx = Number.parseInt(str, 10) - 1;
+        if (idx >= 0 && idx <= maxIndex) {
+          currentIndex = idx;
+          cleanup();
+          return resolve(safeOptions[currentIndex]);
+        }
+      }
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKeypress);
+  });
+}
+
+function createSpinner({ text, intervalMs = 80 }) {
+  let frame = 0;
+  let timer = null;
+
+  function start() {
+    if (!isInteractive()) {
+      process.stdout.write(`${text}\n`);
+      return;
+    }
+    timer = setInterval(() => {
+      const glyph = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+      frame += 1;
+      process.stdout.write(`\r${glyph} ${text}`);
+    }, intervalMs);
+  }
+
+  function stop(successText) {
+    if (timer) clearInterval(timer);
+    if (isInteractive()) {
+      process.stdout.write(`\r${" ".repeat(text.length + 4)}\r`);
+    }
+    if (successText) process.stdout.write(`${successText}\n`);
+  }
+
+  return { start, stop };
+}
+
+function formatSummaryLine({ label, status, detail }) {
+  const isSuccess = status === "updated" || status === "set" || status === "installed";
+  const bullet = isSuccess ? color("*", GREEN) : "o";
+  const statusLabel = isSuccess ? detail || status : detail ? `Skipped - ${detail}` : "Skipped";
+  const line = `  ${bullet} ${label.padEnd(22)} [${statusLabel}]`;
+  return isSuccess ? line : color(line, DIM);
+}
+
+module.exports = {
+  BOLD,
+  DIM,
+  CYAN,
+  GREEN,
+  YELLOW,
+  BLUE,
+  RESET,
+  color,
+  underline,
+  renderBox,
+  isInteractive,
+  promptMenu,
+  promptEnter,
+  createSpinner,
+  formatSummaryLine,
+};

package/src/lib/codex-config.js

@@ -0,0 +1,350 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+
+const { ensureDir, readJson, writeJson } = require("./fs");
+
+async function upsertNotify({ configPath, notifyCmd, notifyOriginalPath, configLabel }) {
+  const originalText = await fs.readFile(configPath, "utf8").catch(() => null);
+  if (originalText == null) {
+    const label =
+      typeof configLabel === "string" && configLabel.length > 0 ? configLabel : "Config";
+    throw new Error(`${label} not found: ${configPath}`);
+  }
+
+  const existingNotify = extractNotify(originalText);
+  const already = arraysEqual(existingNotify, notifyCmd);
+
+  if (!already) {
+    // Persist original notify once (for uninstall + chaining).
+    if (existingNotify && existingNotify.length > 0) {
+      await ensureDir(path.dirname(notifyOriginalPath));
+      const existing = await readJson(notifyOriginalPath);
+      if (!existing) {
+        await writeJson(notifyOriginalPath, {
+          notify: existingNotify,
+          capturedAt: new Date().toISOString(),
+        });
+      }
+    }
+
+    const updated = setNotify(originalText, notifyCmd);
+    const backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+    await fs.copyFile(configPath, backupPath);
+    await fs.writeFile(configPath, updated, "utf8");
+    return { changed: true, backupPath };
+  }
+
+  return { changed: false, backupPath: null };
+}
+
+async function restoreNotify({ configPath, notifyOriginalPath, expectedNotify }) {
+  const text = await fs.readFile(configPath, "utf8").catch(() => null);
+  if (text == null) return { restored: false, skippedReason: "config-missing" };
+
+  const original = await readJson(notifyOriginalPath);
+  const originalNotify = Array.isArray(original?.notify) ? original.notify : null;
+  const currentNotify = extractNotify(text);
+
+  if (!originalNotify && expectedNotify && !arraysEqual(currentNotify, expectedNotify)) {
+    return { restored: false, skippedReason: "no-backup-not-installed" };
+  }
+
+  const updated = originalNotify ? setNotify(text, originalNotify) : removeNotify(text);
+  if (updated === text) return { restored: false, skippedReason: "no-change" };
+
+  const backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  await fs.copyFile(configPath, backupPath).catch(() => {});
+  await fs.writeFile(configPath, updated, "utf8");
+  return { restored: true, skippedReason: null };
+}
+
+async function loadNotifyOriginal(notifyOriginalPath) {
+  const original = await readJson(notifyOriginalPath);
+  return Array.isArray(original?.notify) ? original.notify : null;
+}
+
+async function readNotify(configPath) {
+  const text = await fs.readFile(configPath, "utf8").catch(() => null);
+  if (text == null) return null;
+  return extractNotify(text);
+}
+
+async function upsertCodexNotify({ codexConfigPath, notifyCmd, notifyOriginalPath }) {
+  return upsertNotify({
+    configPath: codexConfigPath,
+    notifyCmd,
+    notifyOriginalPath,
+    configLabel: "Codex config",
+  });
+}
+
+async function restoreCodexNotify({ codexConfigPath, notifyOriginalPath, notifyCmd }) {
+  return restoreNotify({
+    configPath: codexConfigPath,
+    notifyOriginalPath,
+    expectedNotify: notifyCmd,
+  });
+}
+
+async function loadCodexNotifyOriginal(notifyOriginalPath) {
+  return loadNotifyOriginal(notifyOriginalPath);
+}
+
+async function readCodexNotify(codexConfigPath) {
+  return readNotify(codexConfigPath);
+}
+
+async function upsertEveryCodeNotify({ codeConfigPath, notifyCmd, notifyOriginalPath }) {
+  return upsertNotify({
+    configPath: codeConfigPath,
+    notifyCmd,
+    notifyOriginalPath,
+    configLabel: "Every Code config",
+  });
+}
+
+async function restoreEveryCodeNotify({ codeConfigPath, notifyOriginalPath, notifyCmd }) {
+  return restoreNotify({
+    configPath: codeConfigPath,
+    notifyOriginalPath,
+    expectedNotify: notifyCmd,
+  });
+}
+
+async function loadEveryCodeNotifyOriginal(notifyOriginalPath) {
+  return loadNotifyOriginal(notifyOriginalPath);
+}
+
+async function readEveryCodeNotify(codeConfigPath) {
+  return readNotify(codeConfigPath);
+}
+
+function extractNotify(text) {
+  // Heuristic parse: find a line that starts with "notify =".
+  // Supports single-line arrays:
+  // - notify = ["a", "b"]
+  // And multi-line arrays:
+  // - notify = [
+  //     "a",
+  //     "b"
+  //   ]
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = line.match(/^\s*notify\s*=\s*(.*)\s*$/);
+    if (!m) continue;
+
+    const rhs = (m[1] || "").trim();
+    const literal = readTomlArrayLiteral(lines, i, rhs);
+    if (!literal) continue;
+
+    const parsed = parseTomlStringArray(literal);
+    if (parsed) return parsed;
+  }
+  return null;
+}
+
+function setNotify(text, notifyCmd) {
+  const lines = text.split(/\r?\n/);
+  const notifyLine = `notify = ${formatTomlStringArray(notifyCmd)}`;
+
+  const out = [];
+  let replaced = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = line.match(/^\s*notify\s*=\s*(.*)\s*$/);
+    if (m) {
+      if (!replaced) {
+        out.push(notifyLine);
+        replaced = true;
+      }
+
+      const rhs = (m[1] || "").trim();
+      i = findTomlArrayBlockEnd(lines, i, rhs);
+      continue;
+    }
+    out.push(line);
+  }
+
+  if (!replaced) {
+    // Insert at top-level, before the first table header.
+    const firstTableIdx = out.findIndex((l) => /^\s*\[/.test(l));
+    const headerIdx = firstTableIdx === -1 ? out.length : firstTableIdx;
+    out.splice(headerIdx, 0, notifyLine);
+  }
+
+  return out.join("\n").replace(/\n+$/, "\n");
+}
+
+function removeNotify(text) {
+  const lines = text.split(/\r?\n/);
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const m = line.match(/^\s*notify\s*=\s*(.*)\s*$/);
+    if (m) {
+      const rhs = (m[1] || "").trim();
+      i = findTomlArrayBlockEnd(lines, i, rhs);
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n").replace(/\n+$/, "\n");
+}
+
+function parseTomlStringArray(rhs) {
+  // Minimal parser for ["a", "b"] string arrays.
+  // Assumes there are no escapes in strings (good enough for our usage).
+  if (!rhs.startsWith("[") || !rhs.endsWith("]")) return null;
+  const inner = rhs.slice(1, -1).trim();
+  if (!inner) return [];
+
+  const parts = [];
+  let current = "";
+  let inString = false;
+  let quote = null;
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (!inString) {
+      if (ch === '"' || ch === "'") {
+        inString = true;
+        quote = ch;
+        current = "";
+      }
+      continue;
+    }
+    if (ch === quote) {
+      parts.push(current);
+      inString = false;
+      quote = null;
+      continue;
+    }
+    current += ch;
+  }
+
+  return parts.length > 0 ? parts : null;
+}
+
+function formatTomlStringArray(arr) {
+  return `[${arr.map((s) => JSON.stringify(String(s))).join(", ")}]`;
+}
+
+function readTomlArrayLiteral(lines, startIndex, rhs) {
+  const first = rhs.trim();
+  if (!first.startsWith("[")) return null;
+
+  let inString = false;
+  let quote = null;
+  let depth = 0;
+  let sawOpen = false;
+
+  function scanChunk(chunk) {
+    for (let i = 0; i < chunk.length; i++) {
+      const ch = chunk[i];
+      if (!inString) {
+        if (ch === '"' || ch === "'") {
+          inString = true;
+          quote = ch;
+          continue;
+        }
+        if (ch === "[") {
+          depth += 1;
+          sawOpen = true;
+          continue;
+        }
+        if (ch === "]") {
+          depth -= 1;
+          if (sawOpen && depth === 0) return i;
+        }
+        continue;
+      }
+      if (ch === quote) {
+        inString = false;
+        quote = null;
+      }
+    }
+    return -1;
+  }
+
+  const parts = [first];
+  let endPos = scanChunk(first);
+  if (endPos !== -1) return first.slice(0, endPos + 1).trim();
+
+  for (let j = startIndex + 1; j < lines.length; j++) {
+    const line = lines[j];
+    endPos = scanChunk(line);
+    if (endPos !== -1) {
+      parts.push(line.slice(0, endPos + 1));
+      return parts.join("\n").trim();
+    }
+    parts.push(line);
+  }
+
+  return null;
+}
+
+function findTomlArrayBlockEnd(lines, startIndex, rhs) {
+  const first = rhs.trim();
+  if (!first.startsWith("[")) return startIndex;
+
+  let inString = false;
+  let quote = null;
+  let depth = 0;
+  let sawOpen = false;
+
+  function scanChunk(chunk) {
+    for (let i = 0; i < chunk.length; i++) {
+      const ch = chunk[i];
+      if (!inString) {
+        if (ch === '"' || ch === "'") {
+          inString = true;
+          quote = ch;
+          continue;
+        }
+        if (ch === "[") {
+          depth += 1;
+          sawOpen = true;
+          continue;
+        }
+        if (ch === "]") {
+          depth -= 1;
+          if (sawOpen && depth === 0) return true;
+        }
+        continue;
+      }
+      if (ch === quote) {
+        inString = false;
+        quote = null;
+      }
+    }
+    return false;
+  }
+
+  if (scanChunk(first)) return startIndex;
+  for (let j = startIndex + 1; j < lines.length; j++) {
+    if (scanChunk(lines[j])) return j;
+  }
+  return startIndex;
+}
+
+function arraysEqual(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+module.exports = {
+  upsertNotify,
+  restoreNotify,
+  loadNotifyOriginal,
+  readNotify,
+  upsertCodexNotify,
+  restoreCodexNotify,
+  loadCodexNotifyOriginal,
+  readCodexNotify,
+  upsertEveryCodeNotify,
+  restoreEveryCodeNotify,
+  loadEveryCodeNotifyOriginal,
+  readEveryCodeNotify,
+};