vibeusage 0.2.8

package/src/lib/codex-config.js

@@ -0,0 +1,224 @@
+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 =".
+  const lines = text.split(/\r?\n/);
+  for (const line of lines) {
+    const m = line.match(/^\s*notify\s*=\s*(.+)\s*$/);
+    if (m) {
+      const rhs = m[1].trim();
+      const parsed = parseTomlStringArray(rhs);
+      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 isNotify = /^\s*notify\s*=/.test(line);
+    if (isNotify) {
+      if (!replaced) {
+        out.push(notifyLine);
+        replaced = true;
+      }
+      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 = lines.filter((l) => !/^\s*notify\s*=/.test(l));
+  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 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
+};

package/src/lib/debug-flags.js

@@ -0,0 +1,9 @@
+function stripDebugFlag(argv, env = process.env) {
+  const filtered = Array.isArray(argv) ? argv.filter((arg) => arg !== '--debug') : [];
+  const debugEnv =
+    String(env?.VIBEUSAGE_DEBUG || '') === '1' ||
+    String(env?.VIBESCORE_DEBUG || '') === '1';
+  return { argv: filtered, debug: filtered.length !== (argv || []).length || debugEnv };
+}
+
+module.exports = { stripDebugFlag };

package/src/lib/diagnostics.js

@@ -0,0 +1,190 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const { readJson } = require('./fs');
+const { readCodexNotify, readEveryCodeNotify } = require('./codex-config');
+const { isClaudeHookConfigured, buildClaudeHookCommand } = require('./claude-config');
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  isGeminiHookConfigured
+} = require('./gemini-config');
+const { resolveOpencodeConfigDir, isOpencodePluginInstalled } = require('./opencode-config');
+const { normalizeState: normalizeUploadState } = require('./upload-throttle');
+const { resolveTrackerPaths } = require('./tracker-paths');
+
+async function collectTrackerDiagnostics({
+  home = os.homedir(),
+  codexHome = process.env.CODEX_HOME || path.join(home, '.codex'),
+  codeHome = process.env.CODE_HOME || path.join(home, '.code')
+} = {}) {
+  const { trackerDir, binDir } = await resolveTrackerPaths({ home, migrate: true });
+  const configPath = path.join(trackerDir, 'config.json');
+  const queuePath = path.join(trackerDir, 'queue.jsonl');
+  const queueStatePath = path.join(trackerDir, 'queue.state.json');
+  const cursorsPath = path.join(trackerDir, 'cursors.json');
+  const notifySignalPath = path.join(trackerDir, 'notify.signal');
+  const throttlePath = path.join(trackerDir, 'sync.throttle');
+  const uploadThrottlePath = path.join(trackerDir, 'upload.throttle.json');
+  const autoRetryPath = path.join(trackerDir, 'auto.retry.json');
+  const codexConfigPath = path.join(codexHome, 'config.toml');
+  const codeConfigPath = path.join(codeHome, 'config.toml');
+  const claudeConfigPath = 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 config = await readJson(configPath);
+  const cursors = await readJson(cursorsPath);
+  const queueState = (await readJson(queueStatePath)) || { offset: 0 };
+  const uploadThrottle = normalizeUploadState(await readJson(uploadThrottlePath));
+  const autoRetry = await readJson(autoRetryPath);
+
+  const queueSize = await safeStatSize(queuePath);
+  const offsetBytes = Number(queueState.offset || 0);
+  const pendingBytes = Math.max(0, queueSize - offsetBytes);
+
+  const lastNotify = (await safeReadText(notifySignalPath))?.trim() || null;
+  const lastNotifySpawn = parseEpochMsToIso((await safeReadText(throttlePath))?.trim() || null);
+
+  const codexNotifyRaw = await readCodexNotify(codexConfigPath);
+  const notifyConfigured = Array.isArray(codexNotifyRaw) && codexNotifyRaw.length > 0;
+  const codexNotify = notifyConfigured ? codexNotifyRaw.map((v) => redactValue(v, home)) : null;
+  const everyCodeNotifyRaw = await readEveryCodeNotify(codeConfigPath);
+  const everyCodeConfigured = Array.isArray(everyCodeNotifyRaw) && everyCodeNotifyRaw.length > 0;
+  const everyCodeNotify = everyCodeConfigured ? everyCodeNotifyRaw.map((v) => redactValue(v, home)) : null;
+  const claudeHookCommand = buildClaudeHookCommand(path.join(binDir, 'notify.cjs'));
+  const claudeHookConfigured = await isClaudeHookConfigured({
+    settingsPath: claudeConfigPath,
+    hookCommand: claudeHookCommand
+  });
+  const geminiHookCommand = buildGeminiHookCommand(path.join(binDir, 'notify.cjs'));
+  const geminiHookConfigured = await isGeminiHookConfigured({
+    settingsPath: geminiSettingsPath,
+    hookCommand: geminiHookCommand
+  });
+  const opencodePluginConfigured = await isOpencodePluginInstalled({ configDir: opencodeConfigDir });
+
+  const lastSuccessAt = uploadThrottle.lastSuccessMs ? new Date(uploadThrottle.lastSuccessMs).toISOString() : null;
+  const autoRetryAt = parseEpochMsToIso(autoRetry?.retryAtMs);
+
+  return {
+    ok: true,
+    version: 1,
+    generated_at: new Date().toISOString(),
+    env: {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch
+    },
+    paths: {
+      tracker_dir: redactValue(trackerDir, home),
+      codex_home: redactValue(codexHome, home),
+      codex_config: redactValue(codexConfigPath, home),
+      code_home: redactValue(codeHome, home),
+      code_config: redactValue(codeConfigPath, home),
+      claude_config: redactValue(claudeConfigPath, home),
+      gemini_config: redactValue(geminiSettingsPath, home),
+      opencode_config: redactValue(opencodeConfigDir, home)
+    },
+    config: {
+      base_url: typeof config?.baseUrl === 'string' ? config.baseUrl : null,
+      device_token: config?.deviceToken ? 'set' : 'unset',
+      device_id: maskId(config?.deviceId),
+      installed_at: typeof config?.installedAt === 'string' ? config.installedAt : null
+    },
+    parse: {
+      updated_at: typeof cursors?.updatedAt === 'string' ? cursors.updatedAt : null,
+      file_count: cursors?.files && typeof cursors.files === 'object' ? Object.keys(cursors.files).length : null
+    },
+    queue: {
+      size_bytes: queueSize,
+      offset_bytes: offsetBytes,
+      pending_bytes: pendingBytes,
+      updated_at: typeof queueState.updatedAt === 'string' ? queueState.updatedAt : null
+    },
+    notify: {
+      last_notify: lastNotify,
+      last_notify_triggered_sync: lastNotifySpawn,
+      codex_notify_configured: notifyConfigured,
+      codex_notify: codexNotify,
+      every_code_notify_configured: everyCodeConfigured,
+      every_code_notify: everyCodeNotify,
+      claude_hook_configured: claudeHookConfigured,
+      gemini_hook_configured: geminiHookConfigured,
+      opencode_plugin_configured: opencodePluginConfigured
+    },
+    upload: {
+      last_success_at: lastSuccessAt,
+      next_allowed_after: parseEpochMsToIso(uploadThrottle.nextAllowedAtMs || null),
+      backoff_until: parseEpochMsToIso(uploadThrottle.backoffUntilMs || null),
+      last_error: uploadThrottle.lastError
+        ? {
+            at: uploadThrottle.lastErrorAt || null,
+            message: redactError(String(uploadThrottle.lastError), home)
+          }
+        : null
+    },
+    auto_retry: autoRetryAt
+      ? {
+          next_retry_at: autoRetryAt,
+          reason: typeof autoRetry?.reason === 'string' ? autoRetry.reason : null,
+          pending_bytes: Number.isFinite(Number(autoRetry?.pendingBytes))
+            ? Math.max(0, Number(autoRetry.pendingBytes))
+            : null,
+          scheduled_at: typeof autoRetry?.scheduledAt === 'string' ? autoRetry.scheduledAt : null,
+          source: typeof autoRetry?.source === 'string' ? autoRetry.source : null
+        }
+      : null
+  };
+}
+
+function maskId(v) {
+  if (typeof v !== 'string') return null;
+  const s = v.trim();
+  if (s.length < 12) return null;
+  return `${s.slice(0, 8)}…${s.slice(-4)}`;
+}
+
+function redactValue(value, home) {
+  if (typeof value !== 'string') return value;
+  if (typeof home !== 'string' || home.length === 0) return value;
+  const homeNorm = home.endsWith(path.sep) ? home.slice(0, -1) : home;
+  return value.startsWith(homeNorm) ? `~${value.slice(homeNorm.length)}` : value;
+}
+
+function redactError(message, home) {
+  if (typeof message !== 'string') return message;
+  if (typeof home !== 'string' || home.length === 0) return message;
+  const homeNorm = home.endsWith(path.sep) ? home.slice(0, -1) : home;
+  return message.split(homeNorm).join('~');
+}
+
+async function safeStatSize(p) {
+  try {
+    const st = await fs.stat(p);
+    return st && st.isFile() ? st.size : 0;
+  } catch (_e) {
+    return 0;
+  }
+}
+
+async function safeReadText(p) {
+  try {
+    return await fs.readFile(p, 'utf8');
+  } catch (_e) {
+    return null;
+  }
+}
+
+function parseEpochMsToIso(v) {
+  const ms = Number(v);
+  if (!Number.isFinite(ms) || ms <= 0) return null;
+  const d = new Date(ms);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString();
+}
+
+module.exports = { collectTrackerDiagnostics };

package/src/lib/fs.js

@@ -0,0 +1,62 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+async function writeFileAtomic(filePath, content) {
+  const dir = path.dirname(filePath);
+  await ensureDir(dir);
+  const tmp = `${filePath}.tmp.${Date.now()}`;
+  await fs.writeFile(tmp, content, { encoding: 'utf8' });
+  await fs.rename(tmp, filePath);
+}
+
+async function readJson(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (_e) {
+    return null;
+  }
+}
+
+async function writeJson(filePath, obj) {
+  await writeFileAtomic(filePath, JSON.stringify(obj, null, 2) + '\n');
+}
+
+async function chmod600IfPossible(filePath) {
+  try {
+    await fs.chmod(filePath, 0o600);
+  } catch (_e) {}
+}
+
+async function openLock(lockPath, { quietIfLocked }) {
+  try {
+    const handle = await fs.open(lockPath, 'wx');
+    return {
+      async release() {
+        await handle.close().catch(() => {});
+      }
+    };
+  } catch (e) {
+    if (e && e.code === 'EEXIST') {
+      if (!quietIfLocked) {
+        process.stdout.write('Another sync is already running.\n');
+      }
+      return null;
+    }
+    throw e;
+  }
+}
+
+module.exports = {
+  ensureDir,
+  writeFileAtomic,
+  readJson,
+  writeJson,
+  chmod600IfPossible,
+  openLock
+};
+