vibeusage 0.2.8

package/src/commands/uninstall.js

@@ -0,0 +1,153 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const { restoreCodexNotify, restoreEveryCodeNotify } = require('../lib/codex-config');
+const { removeClaudeHook, buildClaudeHookCommand } = require('../lib/claude-config');
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  removeGeminiHook
+} = require('../lib/gemini-config');
+const { resolveOpencodeConfigDir, removeOpencodePlugin } = require('../lib/opencode-config');
+const { resolveTrackerPaths } = require('../lib/tracker-paths');
+
+async function cmdUninstall(argv) {
+  const opts = parseArgs(argv);
+  const home = os.homedir();
+  const { trackerDir, binDir, legacyRootDir } = await resolveTrackerPaths({
+    home,
+    migrate: false
+  });
+  const codexHome = process.env.CODEX_HOME || path.join(home, '.codex');
+  const codexConfigPath = path.join(codexHome, 'config.toml');
+  const codeHome = process.env.CODE_HOME || path.join(home, '.code');
+  const codeConfigPath = path.join(codeHome, 'config.toml');
+  const claudeSettingsPath = path.join(home, '.claude', 'settings.json');
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
+  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
+  const notifyPath = path.join(binDir, 'notify.cjs');
+  const notifyOriginalPath = path.join(trackerDir, 'codex_notify_original.json');
+  const codeNotifyOriginalPath = path.join(trackerDir, 'code_notify_original.json');
+  const codexNotifyCmd = ['/usr/bin/env', 'node', notifyPath];
+  const codeNotifyCmd = ['/usr/bin/env', 'node', notifyPath, '--source=every-code'];
+  const claudeHookCommand = buildClaudeHookCommand(notifyPath);
+  const geminiHookCommand = buildGeminiHookCommand(notifyPath);
+
+  const codexConfigExists = await isFile(codexConfigPath);
+  const codeConfigExists = await isFile(codeConfigPath);
+  const claudeConfigExists = await isFile(claudeSettingsPath);
+  const geminiConfigExists = await isDir(geminiConfigDir);
+  const opencodeConfigExists = await isDir(opencodeConfigDir);
+  const codexRestore = codexConfigExists
+    ? await restoreCodexNotify({
+        codexConfigPath,
+        notifyOriginalPath,
+        notifyCmd: codexNotifyCmd
+      })
+    : { restored: false, skippedReason: 'config-missing' };
+  const codeRestore = codeConfigExists
+    ? await restoreEveryCodeNotify({
+        codeConfigPath,
+        notifyOriginalPath: codeNotifyOriginalPath,
+        notifyCmd: codeNotifyCmd
+      })
+    : { restored: false, skippedReason: 'config-missing' };
+  const claudeRemove = claudeConfigExists
+    ? await removeClaudeHook({ settingsPath: claudeSettingsPath, hookCommand: claudeHookCommand })
+    : { removed: false, skippedReason: 'config-missing' };
+  const geminiRemove = geminiConfigExists
+    ? await removeGeminiHook({ settingsPath: geminiSettingsPath, hookCommand: geminiHookCommand })
+    : { removed: false, skippedReason: 'config-missing' };
+  const opencodeRemove = opencodeConfigExists
+    ? await removeOpencodePlugin({ configDir: opencodeConfigDir })
+    : { removed: false, skippedReason: 'config-missing' };
+
+  // Remove installed notify handler.
+  await fs.unlink(notifyPath).catch(() => {});
+
+  // Remove local app runtime (installed by init for notify-driven sync).
+  await fs.rm(path.join(trackerDir, 'app'), { recursive: true, force: true }).catch(() => {});
+
+  if (opts.purge) {
+    await fs.rm(path.join(home, '.vibeusage'), { recursive: true, force: true }).catch(() => {});
+    await fs.rm(legacyRootDir, { recursive: true, force: true }).catch(() => {});
+  }
+
+  process.stdout.write(
+    [
+      'Uninstalled:',
+      codexConfigExists
+        ? codexRestore?.restored
+          ? `- Codex notify restored: ${codexConfigPath}`
+          : codexRestore?.skippedReason === 'no-backup-not-installed'
+            ? '- Codex notify: skipped (no backup; not installed)'
+            : '- Codex notify: no change'
+        : '- Codex notify: skipped (config.toml not found)',
+      codeConfigExists
+        ? codeRestore?.restored
+          ? `- Every Code notify restored: ${codeConfigPath}`
+          : codeRestore?.skippedReason === 'no-backup-not-installed'
+            ? '- Every Code notify: skipped (no backup; not installed)'
+            : '- Every Code notify: no change'
+        : '- Every Code notify: skipped (config.toml not found)',
+      claudeConfigExists
+        ? claudeRemove?.removed
+          ? `- Claude hooks removed: ${claudeSettingsPath}`
+          : claudeRemove?.skippedReason === 'hook-missing'
+            ? '- Claude hooks: no change'
+            : '- Claude hooks: skipped'
+        : '- Claude hooks: skipped (settings.json not found)',
+      geminiConfigExists
+        ? geminiRemove?.removed
+          ? `- Gemini hooks removed: ${geminiSettingsPath}`
+          : geminiRemove?.skippedReason === 'hook-missing'
+            ? '- Gemini hooks: no change'
+            : '- Gemini hooks: skipped'
+        : `- Gemini hooks: skipped (${geminiConfigDir} not found)`,
+      opencodeConfigExists
+        ? opencodeRemove?.removed
+          ? `- Opencode plugin removed: ${opencodeConfigDir}`
+          : opencodeRemove?.skippedReason === 'plugin-missing'
+            ? '- Opencode plugin: no change'
+            : opencodeRemove?.skippedReason === 'unexpected-content'
+              ? '- Opencode plugin: skipped (unexpected content)'
+              : '- Opencode plugin: skipped'
+        : `- Opencode plugin: skipped (${opencodeConfigDir} not found)`,
+      opts.purge ? `- Purged: ${path.join(home, '.vibeusage')}` : '- Purge: skipped (use --purge)',
+      ''
+    ].join('\n')
+  );
+}
+
+function parseArgs(argv) {
+  const out = { purge: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--purge') out.purge = true;
+    else throw new Error(`Unknown option: ${a}`);
+  }
+  return out;
+}
+
+module.exports = { cmdUninstall };
+
+async function isFile(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isFile();
+  } catch (_e) {
+    return false;
+  }
+}
+
+async function isDir(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isDirectory();
+  } catch (_e) {
+    return false;
+  }
+}

package/src/lib/browser-auth.js

@@ -0,0 +1,175 @@
+const http = require('node:http');
+const crypto = require('node:crypto');
+const cp = require('node:child_process');
+
+const DEFAULT_BASE_URL = 'https://5tmappuk.us-east.insforge.app';
+
+async function beginBrowserAuth({ baseUrl, dashboardUrl, timeoutMs, open }) {
+  const nonce = crypto.randomBytes(16).toString('hex');
+  const callbackPath = `/vibescore/callback/${nonce}`;
+  const authUrl = dashboardUrl ? new URL('/', dashboardUrl) : new URL('/auth/sign-up', baseUrl);
+  const postAuthRedirect = resolvePostAuthRedirect({ dashboardUrl, authUrl });
+  const { callbackUrl, waitForCallback } = await startLocalCallbackServer({
+    callbackPath,
+    timeoutMs,
+    redirectUrl: postAuthRedirect
+  });
+  authUrl.searchParams.set('redirect', callbackUrl);
+  if (dashboardUrl && baseUrl && baseUrl !== DEFAULT_BASE_URL) authUrl.searchParams.set('base_url', baseUrl);
+
+  if (open !== false) openInBrowser(authUrl.toString());
+
+  return { authUrl: authUrl.toString(), waitForCallback };
+}
+
+async function startLocalCallbackServer({ callbackPath, timeoutMs, redirectUrl }) {
+  let resolved = false;
+  let resolveResult;
+  let rejectResult;
+
+  const resultPromise = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+
+  const server = http.createServer((req, res) => {
+    if (resolved) {
+      res.writeHead(409, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.end('Already authenticated.\n');
+      return;
+    }
+
+    const method = req.method || 'GET';
+    if (method !== 'GET') {
+      res.writeHead(405, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.end('Method not allowed.\n');
+      return;
+    }
+
+    const url = new URL(req.url || '/', 'http://127.0.0.1');
+    if (url.pathname !== callbackPath) {
+      res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.end('Not found.\n');
+      return;
+    }
+
+    const accessToken = url.searchParams.get('access_token') || '';
+    if (!accessToken) {
+      res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.end('Missing access_token.\n');
+      return;
+    }
+
+    resolved = true;
+    if (redirectUrl) {
+      res.writeHead(302, {
+        Location: redirectUrl,
+        'Content-Type': 'text/html; charset=utf-8'
+      });
+      res.end(
+        [
+          '<!doctype html>',
+          '<html><head><meta charset="utf-8"><title>VibeScore</title></head>',
+          '<body>',
+          '<h2>Login succeeded</h2>',
+          `<p>Redirecting to <a href="${redirectUrl}">dashboard</a>...</p>`,
+          '</body></html>'
+        ].join('')
+      );
+    } else {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(
+        [
+          '<!doctype html>',
+          '<html><head><meta charset="utf-8"><title>VibeScore</title></head>',
+          '<body>',
+          '<h2>Login succeeded</h2>',
+          '<p>You can close this tab and return to the CLI.</p>',
+          '</body></html>'
+        ].join('')
+      );
+    }
+
+    resolveResult({
+      accessToken,
+      userId: url.searchParams.get('user_id') || null,
+      email: url.searchParams.get('email') || null,
+      name: url.searchParams.get('name') || null
+    });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+
+  const addr = server.address();
+  const port = typeof addr === 'object' && addr ? addr.port : null;
+  if (!port) {
+    server.close();
+    throw new Error('Failed to bind local callback server');
+  }
+
+  const callbackUrl = `http://127.0.0.1:${port}${callbackPath}`;
+
+  const timer = setTimeout(() => {
+    if (resolved) return;
+    resolved = true;
+    rejectResult(new Error('Authentication timed out'));
+    server.close();
+  }, timeoutMs);
+
+  async function waitForCallback() {
+    try {
+      return await resultPromise;
+    } finally {
+      clearTimeout(timer);
+      server.close();
+    }
+  }
+
+  return { callbackUrl, waitForCallback };
+}
+
+function openInBrowser(url) {
+  const platform = process.platform;
+
+  let cmd = null;
+  let args = [];
+
+  if (platform === 'darwin') {
+    cmd = 'open';
+    args = [url];
+  } else if (platform === 'win32') {
+    cmd = 'cmd';
+    args = ['/c', 'start', '', url];
+  } else {
+    cmd = 'xdg-open';
+    args = [url];
+  }
+
+  try {
+    const child = cp.spawn(cmd, args, { stdio: 'ignore', detached: true });
+    child.unref();
+  } catch (_e) {}
+}
+
+function resolvePostAuthRedirect({ dashboardUrl, authUrl }) {
+  try {
+    if (dashboardUrl) {
+      const target = new URL('/', dashboardUrl);
+      if (target.protocol === 'http:' || target.protocol === 'https:') {
+        return target.toString();
+      }
+      return null;
+    }
+  } catch (_e) {
+    return null;
+  }
+  return null;
+}
+
+module.exports = {
+  beginBrowserAuth,
+  openInBrowser
+};

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
+};