@ipv9/tokentracker-cli 0.39.0

package/src/lib/gemini-config.js

@@ -0,0 +1,288 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+
+const { ensureDir, readJson, writeJson } = require("./fs");
+
+const DEFAULT_EVENT = "SessionEnd";
+const DEFAULT_HOOK_NAME = "tokentracker";
+const DEFAULT_MATCHER = "exit|clear|logout|prompt_input_exit|other";
+
+function resolveGeminiConfigDir({ home = os.homedir(), env = process.env } = {}) {
+  const explicit = typeof env.GEMINI_HOME === "string" ? env.GEMINI_HOME.trim() : "";
+  if (explicit) return path.resolve(explicit);
+  return path.join(home, ".gemini");
+}
+
+function resolveGeminiSettingsPath({ configDir }) {
+  return path.join(configDir, "settings.json");
+}
+
+async function upsertGeminiHook({
+  settingsPath,
+  hookCommand,
+  hookName = DEFAULT_HOOK_NAME,
+  matcher = DEFAULT_MATCHER,
+  event = DEFAULT_EVENT,
+}) {
+  const existing = await readJson(settingsPath);
+  const settings = normalizeSettings(existing);
+  const enableResult = ensureHooksEnabled(settings);
+  const baseSettings = enableResult.settings;
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+
+  const normalized = normalizeEntriesForHook(entries, { hookCommand, hookName });
+  let nextEntries = normalized.entries;
+  let changed = normalized.changed || enableResult.changed;
+
+  if (!hasHook(nextEntries, { hookCommand, hookName })) {
+    nextEntries = nextEntries.concat([buildHookEntry({ hookCommand, hookName, matcher })]);
+    changed = true;
+  }
+
+  if (!changed) return { changed: false, backupPath: null };
+
+  const nextHooks = { ...hooks, [event]: nextEntries };
+  const nextSettings = { ...baseSettings, hooks: nextHooks };
+  const backupPath = await writeGeminiSettings({ settingsPath, settings: nextSettings });
+  return { changed: true, backupPath };
+}
+
+async function removeGeminiHook({
+  settingsPath,
+  hookCommand,
+  hookName = DEFAULT_HOOK_NAME,
+  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, hookName });
+    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 writeGeminiSettings({ settingsPath, settings: nextSettings });
+  return { removed: true, skippedReason: null, backupPath };
+}
+
+async function isGeminiHookConfigured({
+  settingsPath,
+  hookCommand,
+  hookName = DEFAULT_HOOK_NAME,
+  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, hookName });
+}
+
+function buildGeminiHookCommand(notifyPath) {
+  const cmd = typeof notifyPath === "string" ? notifyPath : "";
+  return `/usr/bin/env node ${quoteArg(cmd)} --source=gemini`;
+}
+
+function buildHookEntry({ hookCommand, hookName, matcher }) {
+  const hook = {
+    name: hookName,
+    type: "command",
+    command: hookCommand,
+  };
+  const entry = { hooks: [hook] };
+  if (typeof matcher === "string" && matcher.length > 0) entry.matcher = matcher;
+  return entry;
+}
+
+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 normalizeTools(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 normalizeName(name) {
+  if (typeof name !== "string") return null;
+  const trimmed = name.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function ensureHooksEnabled(settings) {
+  const tools = normalizeTools(settings.tools);
+  if (tools.enableHooks === true) return { settings, changed: false };
+  const nextTools = { ...tools, enableHooks: true };
+  return { settings: { ...settings, tools: nextTools }, changed: true };
+}
+
+function hookMatches(hook, { hookCommand, hookName, requireCommand = false }) {
+  if (!hook || typeof hook !== "object") return false;
+  const name = normalizeName(hook.name);
+  const targetName = normalizeName(hookName);
+  const cmd = normalizeCommand(hook.command);
+  const targetCmd = normalizeCommand(hookCommand);
+  const commandMatches = Boolean(cmd && targetCmd && cmd === targetCmd);
+  if (requireCommand) return commandMatches;
+  const nameMatches = Boolean(name && targetName && name === targetName);
+  return Boolean(commandMatches || nameMatches);
+}
+
+function entryMatches(entry, { hookCommand, hookName, requireCommand = false }) {
+  if (!entry || typeof entry !== "object") return false;
+  if (entry.command || entry.name)
+    return hookMatches(entry, { hookCommand, hookName, requireCommand });
+  if (!Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some((hook) => hookMatches(hook, { hookCommand, hookName, requireCommand }));
+}
+
+function hasHook(entries, { hookCommand, hookName }) {
+  return entries.some((entry) => entryMatches(entry, { hookCommand, hookName }));
+}
+
+function normalizeEntriesForHook(entries, { hookCommand, hookName }) {
+  let changed = false;
+  const nextEntries = entries.map((entry) => {
+    if (!entry || typeof entry !== "object") return entry;
+
+    if (entry.command || entry.name) {
+      if (hookMatches(entry, { hookCommand, hookName })) {
+        const next = normalizeHookObject(entry, { hookCommand, hookName });
+        if (next !== entry) changed = true;
+        return next;
+      }
+      return entry;
+    }
+
+    const hooks = Array.isArray(entry.hooks) ? entry.hooks : null;
+    if (!hooks) return entry;
+
+    let hooksChanged = false;
+    const nextHooks = hooks.map((hook) => {
+      if (hookMatches(hook, { hookCommand, hookName })) {
+        const next = normalizeHookObject(hook, { hookCommand, hookName });
+        if (next !== hook) hooksChanged = true;
+        return next;
+      }
+      return hook;
+    });
+
+    if (!hooksChanged) return entry;
+    changed = true;
+    return { ...entry, hooks: nextHooks };
+  });
+
+  return { entries: nextEntries, changed };
+}
+
+function normalizeHookObject(hook, { hookCommand, hookName }) {
+  const next = { ...hook };
+  let changed = false;
+
+  if (next.type !== "command") {
+    next.type = "command";
+    changed = true;
+  }
+
+  if (hookCommand && next.command !== hookCommand) {
+    next.command = hookCommand;
+    changed = true;
+  }
+
+  if (hookName && next.name !== hookName) {
+    next.name = hookName;
+    changed = true;
+  }
+
+  return changed ? next : hook;
+}
+
+function stripHookFromEntry(entry, { hookCommand, hookName }) {
+  if (!entry || typeof entry !== "object") return { entry, removed: false };
+
+  if (entry.command || entry.name) {
+    if (hookMatches(entry, { hookCommand, hookName, requireCommand: true }))
+      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) => !hookMatches(hook, { hookCommand, hookName, requireCommand: true }),
+  );
+  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 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 writeGeminiSettings({ 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 = {
+  DEFAULT_EVENT,
+  DEFAULT_HOOK_NAME,
+  DEFAULT_MATCHER,
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  upsertGeminiHook,
+  removeGeminiHook,
+  isGeminiHookConfigured,
+};

package/src/lib/grok-hook.js

@@ -0,0 +1,351 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+const fssync = require("node:fs");
+
+const GROK_HOOK_FILENAME = "99-tokentracker-usage.json";
+
+function resolveGrokHome(env = process.env) {
+  if (env.TOKENTRACKER_GROK_HOME && env.TOKENTRACKER_GROK_HOME.length > 0) {
+    return env.TOKENTRACKER_GROK_HOME;
+  }
+  if (env.GROK_HOME && env.GROK_HOME.length > 0) {
+    return env.GROK_HOME;
+  }
+  return path.join(os.homedir(), ".grok");
+}
+
+function resolveGrokHooksDir(env = process.env) {
+  return path.join(resolveGrokHome(env), "hooks");
+}
+
+function resolveTrackerBinDir(trackerDir) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+  return path.basename(trackerDir) === "tracker"
+    ? path.join(path.dirname(trackerDir), "bin")
+    : path.join(trackerDir, "bin");
+}
+
+function resolveLegacyTrackerBinDir(trackerDir) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+  return path.join(trackerDir, "bin");
+}
+
+function buildGrokSessionEndHookJson({ notifyGrokHandlerPath }) {
+  // The command runs our dedicated handler.
+  // We pass the session id and cwd via environment variables that Grok already sets.
+  const cmd = `/usr/bin/env node ${shellQuote(notifyGrokHandlerPath)}`;
+  return {
+    hooks: {
+      SessionEnd: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: cmd,
+              timeout: 60
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+async function ensureGrokHookFiles({
+  grokHooksDir,
+  trackerDir,
+  handlerSource // path to the .cjs template we will write
+} = {}) {
+  if (!grokHooksDir || !trackerDir) {
+    throw new Error("grokHooksDir and trackerDir are required");
+  }
+
+  await fs.mkdir(grokHooksDir, { recursive: true });
+
+  const hookPath = path.join(grokHooksDir, GROK_HOOK_FILENAME);
+  const binDir = resolveTrackerBinDir(trackerDir);
+  await fs.mkdir(binDir, { recursive: true });
+
+  const handlerPath = path.join(binDir, "grok-session-end-hook.cjs");
+
+  // Write the hook JSON (always overwrite to keep command up-to-date if bin path changes)
+  const hookJson = buildGrokSessionEndHookJson({ notifyGrokHandlerPath: handlerPath });
+  await fs.writeFile(hookPath, JSON.stringify(hookJson, null, 2) + "\n", "utf8");
+
+  // Write (or update) the handler script
+  const handlerSourceCode = buildGrokSessionEndHandler({ trackerDir });
+  await fs.writeFile(handlerPath, handlerSourceCode, "utf8");
+
+  // Make executable
+  try {
+    fssync.chmodSync(handlerPath, 0o755);
+  } catch {}
+
+  return { hookPath, handlerPath };
+}
+
+function buildGrokSessionEndHandler({ trackerDir }) {
+  // This is the source of the .cjs that will be executed by the Grok hook.
+  // It must be self-contained enough or rely on the copied runtime.
+  // For simplicity and reliability we write a small script that:
+  // 1. Reads GROK_SESSION_ID + GROK_WORKSPACE_ROOT from env
+  // 2. Locates the session metadata files
+  // 3. Extracts usage metadata only
+  // 4. Writes a signal file under trackerDir that sync.js will pick up on next run
+
+  return `#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const readline = require('node:readline');
+
+const GROK_HOME = process.env.TOKENTRACKER_GROK_HOME || process.env.GROK_HOME || path.join(os.homedir(), '.grok');
+const SESSION_ID = process.env.GROK_SESSION_ID;
+const WORKSPACE_ROOT = process.env.GROK_WORKSPACE_ROOT || process.cwd();
+
+if (!SESSION_ID) {
+  process.exit(0); // nothing to do
+}
+
+function encodeGrokCwd(cwd) {
+  // Grok uses encodeURIComponent on the full path, replacing / with %2F etc.
+  return encodeURIComponent(cwd);
+}
+
+const encodedCwd = encodeGrokCwd(WORKSPACE_ROOT);
+const sessionDir = path.join(GROK_HOME, 'sessions', encodedCwd, SESSION_ID);
+const signalsPath = path.join(sessionDir, 'signals.json');
+const summaryPath = path.join(sessionDir, 'summary.json');
+const updatesPath = path.join(sessionDir, 'updates.jsonl');
+
+let signals = {};
+try {
+  const raw = fs.readFileSync(signalsPath, 'utf8');
+  signals = JSON.parse(raw);
+} catch (err) {
+  signals = {};
+}
+if (!signals || typeof signals !== 'object') {
+  signals = {};
+}
+
+const summary = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+  } catch {
+    return {};
+  }
+})();
+
+function toNonNegativeFiniteNumber(value) {
+  const number = Number(value || 0);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+function timestampToIso(value) {
+  if (value == null) return null;
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value) || value <= 0) return null;
+    const millis = value < 10000000000 ? value * 1000 : value;
+    const dt = new Date(millis);
+    return Number.isFinite(dt.getTime()) ? dt.toISOString() : null;
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (/^[0-9]+(?:\\.[0-9]+)?$/.test(trimmed)) return timestampToIso(Number(trimmed));
+    const dt = new Date(trimmed);
+    return Number.isFinite(dt.getTime()) ? dt.toISOString() : null;
+  }
+  return null;
+}
+
+async function readUpdateTelemetry(filePath) {
+  let totalTokens = 0;
+  let lastEventId = null;
+  let lastEventTimestamp = null;
+  let lineNumber = 0;
+
+  try {
+    const input = fs.createReadStream(filePath, { encoding: 'utf8' });
+    const rl = readline.createInterface({ input, crlfDelay: Infinity });
+    try {
+      for await (const line of rl) {
+        lineNumber += 1;
+        if (!line || !line.trim()) continue;
+        let record = null;
+        try {
+          record = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const meta = record && record.params && record.params._meta ? record.params._meta : record && record._meta;
+        if (!meta || typeof meta !== 'object') continue;
+        const nextTotal = toNonNegativeFiniteNumber(meta.totalTokens);
+        if (nextTotal <= 0) continue;
+        totalTokens = Math.max(totalTokens, nextTotal);
+        lastEventId = meta.eventId != null ? String(meta.eventId) : String(lineNumber);
+        lastEventTimestamp =
+          timestampToIso(meta.agentTimestampMs) ||
+          timestampToIso(meta.timestampMs) ||
+          timestampToIso(record.timestamp_ms) ||
+          timestampToIso(record.timestamp) ||
+          lastEventTimestamp;
+      }
+    } finally {
+      rl.close();
+    }
+  } catch {
+    return { totalTokens, lastEventId, lastEventTimestamp };
+  }
+  return { totalTokens, lastEventId, lastEventTimestamp };
+}
+
+async function main() {
+const contextTokensUsed = toNonNegativeFiniteNumber(signals.contextTokensUsed ?? signals.totalTokens);
+const totalTokensBeforeCompaction = toNonNegativeFiniteNumber(signals.totalTokensBeforeCompaction);
+const signalTotalTokens = totalTokensBeforeCompaction + contextTokensUsed;
+const updateTelemetry = await readUpdateTelemetry(updatesPath);
+const totalTokens = Math.max(updateTelemetry.totalTokens, signalTotalTokens);
+const messageCount = toNonNegativeFiniteNumber(signals.assistantMessageCount || signals.num_chat_messages);
+const model = signals.primaryModelId || (Array.isArray(signals.modelsUsed) ? signals.modelsUsed[0] : 'grok-build');
+const lastActive = signals.lastActiveAt || updateTelemetry.lastEventTimestamp || summary.updated_at || new Date().toISOString();
+
+if (totalTokens <= 0) {
+  process.exit(0);
+}
+
+// Write a signal that the TokenTracker sync / local API can pick up
+const trackerDir = ${JSON.stringify(trackerDir)};
+const signalDir = trackerDir;
+try { fs.mkdirSync(signalDir, { recursive: true }); } catch {}
+
+const signal = {
+  source: 'grok',
+  sessionId: SESSION_ID,
+  cwd: WORKSPACE_ROOT,
+  model,
+  totalTokens,
+  contextTokensUsed,
+  totalTokensBeforeCompaction,
+  messageCount,
+  lastActive,
+  sessionDir,
+  updatesPath,
+  signalsPath,
+  summaryPath,
+  lastEventId: updateTelemetry.lastEventId,
+  lastEventTimestamp: updateTelemetry.lastEventTimestamp,
+  capturedAt: new Date().toISOString()
+};
+
+const signalPath = path.join(signalDir, 'grok-last-session.json');
+fs.writeFileSync(signalPath, JSON.stringify(signal, null, 2) + '\\n');
+
+// Also touch a file so any running serve instance can react (optional)
+try {
+  fs.writeFileSync(path.join(signalDir, 'grok-session-end.trigger'), Date.now().toString());
+} catch {}
+
+process.exit(0);
+}
+
+main().catch(() => process.exit(0));
+`;
+}
+
+async function probeGrokHookState({ home = os.homedir(), trackerDir, env = process.env } = {}) {
+  const grokHooksDir = resolveGrokHooksDir(env);
+  const hookPath = path.join(grokHooksDir, GROK_HOOK_FILENAME);
+  const binDir = resolveTrackerBinDir(trackerDir);
+  const handlerPath = path.join(binDir, "grok-session-end-hook.cjs");
+  const legacyHandlerPath = path.join(resolveLegacyTrackerBinDir(trackerDir), "grok-session-end-hook.cjs");
+
+  const hookExists = fssync.existsSync(hookPath);
+  const handlerExists = fssync.existsSync(handlerPath) || fssync.existsSync(legacyHandlerPath);
+
+  let configured = false;
+  if (hookExists) {
+    try {
+      const content = fssync.readFileSync(hookPath, "utf8");
+      const json = JSON.parse(content);
+      configured = Boolean(json?.hooks?.SessionEnd?.[0]?.hooks?.[0]?.command?.includes("grok-session-end-hook"));
+    } catch {}
+  }
+
+  const sessionsDir = path.join(resolveGrokHome(env), "sessions");
+  const hasSessions = fssync.existsSync(sessionsDir);
+
+  return {
+    configured,
+    hookExists,
+    handlerExists,
+    grokHome: resolveGrokHome(env),
+    grokHooksDir,
+    hookPath,
+    handlerPath,
+    legacyHandlerPath,
+    hasGrokInstall: fssync.existsSync(path.join(resolveGrokHome(env), "bin", "grok")) || hasSessions,
+    sessionsDir
+  };
+}
+
+async function upsertGrokHook({ home = os.homedir(), trackerDir, env = process.env } = {}) {
+  const grokHooksDir = resolveGrokHooksDir(env);
+  const result = await ensureGrokHookFiles({ grokHooksDir, trackerDir });
+
+  const state = await probeGrokHookState({ home, trackerDir, env });
+  return {
+    ...state,
+    changed: true,
+    ...result
+  };
+}
+
+async function removeGrokHook({ home = os.homedir(), trackerDir, env = process.env } = {}) {
+  const grokHooksDir = resolveGrokHooksDir(env);
+  const hookPath = path.join(grokHooksDir, GROK_HOOK_FILENAME);
+  const binDir = resolveTrackerBinDir(trackerDir);
+  const handlerPath = path.join(binDir, "grok-session-end-hook.cjs");
+  const legacyHandlerPath = path.join(resolveLegacyTrackerBinDir(trackerDir), "grok-session-end-hook.cjs");
+
+  let removed = false;
+  try {
+    if (fssync.existsSync(hookPath)) {
+      fssync.unlinkSync(hookPath);
+      removed = true;
+    }
+  } catch {}
+  try {
+    if (fssync.existsSync(handlerPath)) {
+      fssync.unlinkSync(handlerPath);
+      removed = true;
+    }
+  } catch {}
+  if (legacyHandlerPath !== handlerPath) {
+    try {
+      if (fssync.existsSync(legacyHandlerPath)) {
+        fssync.unlinkSync(legacyHandlerPath);
+        removed = true;
+      }
+    } catch {}
+  }
+
+  return { removed, hookPath, handlerPath, legacyHandlerPath };
+}
+
+module.exports = {
+  resolveGrokHome,
+  resolveGrokHooksDir,
+  buildGrokSessionEndHookJson,
+  upsertGrokHook,
+  probeGrokHookState,
+  removeGrokHook,
+  GROK_HOOK_FILENAME,
+  buildGrokSessionEndHandler
+};

package/src/lib/init-flow.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const { formatSummaryLine, renderBox, underline } = require("./cli-ui");
+
+const DIVIDER = "----------------------------------------------";
+
+function renderLocalReport({ summary, isDryRun }) {
+  const header = isDryRun
+    ? "Dry run complete. Preview only; no changes were applied."
+    : "Local configuration complete.";
+  const lines = [header, "", "Integration Status:"];
+  for (const item of summary || []) lines.push(formatSummaryLine(item));
+  process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+function renderAuthTransition({ authUrl, canAutoOpen }) {
+  const lines = ["", DIVIDER, "", "Next: Registering device..."];
+  if (canAutoOpen) {
+    lines.push("Opening your browser to link account...");
+    if (authUrl) lines.push(`If it does not open, visit: ${underline(authUrl)}`);
+  } else {
+    lines.push("Open the link below to sign in.");
+    if (authUrl) lines.push(`Visit: ${underline(authUrl)}`);
+  }
+  lines.push("");
+  process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+function renderSuccessBox({ configPath, dashboardUrl }) {
+  const identityLine = "Account linked.";
+  const lines = ["You are all set!", "", identityLine, `Token saved to: ${configPath}`, ""];
+  if (dashboardUrl) lines.push(`View your stats at: ${dashboardUrl}`);
+  lines.push("You can close this terminal window.");
+  process.stdout.write(`${renderBox(lines)}\n`);
+}
+
+module.exports = {
+  DIVIDER,
+  renderLocalReport,
+  renderAuthTransition,
+  renderSuccessBox,
+};