@vibescore/tracker 0.0.1

package/src/commands/sync.js

@@ -0,0 +1,187 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const { ensureDir, readJson, writeJson, openLock } = require('../lib/fs');
+const { listRolloutFiles, parseRolloutIncremental } = require('../lib/rollout');
+const { drainQueueToCloud } = require('../lib/uploader');
+const { createProgress, renderBar, formatNumber, formatBytes } = require('../lib/progress');
+const {
+  DEFAULTS: UPLOAD_DEFAULTS,
+  normalizeState: normalizeUploadState,
+  decideAutoUpload,
+  recordUploadSuccess,
+  recordUploadFailure
+} = require('../lib/upload-throttle');
+
+async function cmdSync(argv) {
+  const opts = parseArgs(argv);
+  const home = os.homedir();
+  const rootDir = path.join(home, '.vibescore');
+  const trackerDir = path.join(rootDir, 'tracker');
+
+  await ensureDir(trackerDir);
+
+  const lockPath = path.join(trackerDir, 'sync.lock');
+  const lock = await openLock(lockPath, { quietIfLocked: opts.auto });
+  if (!lock) return;
+
+  let progress = null;
+  try {
+    progress = !opts.auto ? createProgress({ stream: process.stdout }) : null;
+    const configPath = path.join(trackerDir, 'config.json');
+    const cursorsPath = path.join(trackerDir, 'cursors.json');
+    const queuePath = path.join(trackerDir, 'queue.jsonl');
+    const queueStatePath = path.join(trackerDir, 'queue.state.json');
+    const uploadThrottlePath = path.join(trackerDir, 'upload.throttle.json');
+
+    const config = await readJson(configPath);
+    const cursors = (await readJson(cursorsPath)) || { version: 1, files: {}, updatedAt: null };
+    const uploadThrottle = normalizeUploadState(await readJson(uploadThrottlePath));
+
+    const codexHome = process.env.CODEX_HOME || path.join(home, '.codex');
+    const sessionsDir = path.join(codexHome, 'sessions');
+    const rolloutFiles = await listRolloutFiles(sessionsDir);
+
+    if (progress?.enabled) {
+      progress.start(`Parsing ${renderBar(0)} 0/${formatNumber(rolloutFiles.length)} files | queued 0`);
+    }
+
+    const parseResult = await parseRolloutIncremental({
+      rolloutFiles,
+      cursors,
+      queuePath,
+      onProgress: (p) => {
+        if (!progress?.enabled) return;
+        const pct = p.total > 0 ? p.index / p.total : 1;
+        progress.update(
+          `Parsing ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | queued ${formatNumber(p.eventsQueued)}`
+        );
+      }
+    });
+
+    cursors.updatedAt = new Date().toISOString();
+    await writeJson(cursorsPath, cursors);
+
+    progress?.stop();
+
+    const deviceToken = config?.deviceToken || process.env.VIBESCORE_DEVICE_TOKEN || null;
+    const baseUrl = config?.baseUrl || process.env.VIBESCORE_INSFORGE_BASE_URL || 'https://5tmappuk.us-east.insforge.app';
+
+    let uploadResult = null;
+    if (deviceToken) {
+      const beforeState = (await readJson(queueStatePath)) || { offset: 0 };
+      const queueSize = await safeStatSize(queuePath);
+      const pendingBytes = Math.max(0, queueSize - Number(beforeState.offset || 0));
+      let maxBatches = opts.auto ? 3 : opts.drain ? 10_000 : 10;
+      let batchSize = UPLOAD_DEFAULTS.batchSize;
+      let allowUpload = pendingBytes > 0;
+
+      if (opts.auto) {
+        const decision = decideAutoUpload({
+          nowMs: Date.now(),
+          pendingBytes,
+          state: uploadThrottle
+        });
+        allowUpload = allowUpload && decision.allowed;
+        maxBatches = decision.allowed ? decision.maxBatches : 0;
+        batchSize = decision.batchSize;
+      }
+
+      if (progress?.enabled && pendingBytes > 0 && allowUpload) {
+        const pct = queueSize > 0 ? Number(beforeState.offset || 0) / queueSize : 0;
+        progress.start(
+          `Uploading ${renderBar(pct)} ${formatBytes(Number(beforeState.offset || 0))}/${formatBytes(queueSize)} | inserted 0 skipped 0`
+        );
+      }
+
+      if (allowUpload && maxBatches > 0) {
+        try {
+          uploadResult = await drainQueueToCloud({
+            baseUrl,
+            deviceToken,
+            queuePath,
+            queueStatePath,
+            maxBatches,
+            batchSize,
+            onProgress: (u) => {
+              if (!progress?.enabled) return;
+              const pct = u.queueSize > 0 ? u.offset / u.queueSize : 1;
+              progress.update(
+                `Uploading ${renderBar(pct)} ${formatBytes(u.offset)}/${formatBytes(u.queueSize)} | inserted ${formatNumber(
+                  u.inserted
+                )} skipped ${formatNumber(u.skipped)}`
+              );
+            }
+          });
+          if (uploadResult.attempted > 0) {
+            const next = recordUploadSuccess({ nowMs: Date.now(), state: uploadThrottle });
+            await writeJson(uploadThrottlePath, next);
+          }
+        } catch (e) {
+          const next = recordUploadFailure({ nowMs: Date.now(), state: uploadThrottle, error: e });
+          await writeJson(uploadThrottlePath, next);
+          throw e;
+        }
+      } else {
+        uploadResult = { inserted: 0, skipped: 0 };
+      }
+
+      progress?.stop();
+    }
+
+    if (!opts.auto) {
+      const afterState = (await readJson(queueStatePath)) || { offset: 0 };
+      const queueSize = await safeStatSize(queuePath);
+      const pendingBytes = Math.max(0, queueSize - Number(afterState.offset || 0));
+
+      process.stdout.write(
+        [
+          'Sync finished:',
+          `- Parsed files: ${parseResult.filesProcessed}`,
+          `- New events queued: ${parseResult.eventsQueued}`,
+          deviceToken
+            ? `- Uploaded: ${uploadResult.inserted} inserted, ${uploadResult.skipped} skipped`
+            : '- Uploaded: skipped (no device token)',
+          deviceToken && pendingBytes > 0 && !opts.drain
+            ? `- Remaining: ${formatBytes(pendingBytes)} pending (run sync again, or use --drain)`
+            : null,
+          ''
+        ]
+          .filter(Boolean)
+          .join('\n')
+      );
+    }
+  } finally {
+    progress?.stop();
+    await lock.release();
+    await fs.unlink(lockPath).catch(() => {});
+  }
+}
+
+function parseArgs(argv) {
+  const out = {
+    auto: false,
+    fromNotify: false,
+    drain: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--auto') out.auto = true;
+    else if (a === '--from-notify') out.fromNotify = true;
+    else if (a === '--drain') out.drain = true;
+    else throw new Error(`Unknown option: ${a}`);
+  }
+  return out;
+}
+
+module.exports = { cmdSync };
+
+async function safeStatSize(p) {
+  try {
+    const st = await fs.stat(p);
+    return st && st.isFile() ? st.size : 0;
+  } catch (_e) {
+    return 0;
+  }
+}

package/src/commands/uninstall.js

@@ -0,0 +1,52 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const { readJson } = require('../lib/fs');
+const { restoreCodexNotify } = require('../lib/codex-config');
+
+async function cmdUninstall(argv) {
+  const opts = parseArgs(argv);
+  const home = os.homedir();
+  const trackerDir = path.join(home, '.vibescore', 'tracker');
+  const binDir = path.join(home, '.vibescore', 'bin');
+  const codexConfigPath = path.join(home, '.codex', 'config.toml');
+  const notifyOriginalPath = path.join(trackerDir, 'codex_notify_original.json');
+
+  await restoreCodexNotify({
+    codexConfigPath,
+    notifyOriginalPath
+  });
+
+  // Remove installed notify handler.
+  const notifyPath = path.join(binDir, 'notify.cjs');
+  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, '.vibescore'), { recursive: true, force: true }).catch(() => {});
+  }
+
+  process.stdout.write(
+    [
+      'Uninstalled:',
+      `- Codex notify restored: ${codexConfigPath}`,
+      opts.purge ? `- Purged: ${path.join(home, '.vibescore')}` : '- 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 };

package/src/lib/browser-auth.js

@@ -0,0 +1,139 @@
+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 { callbackUrl, waitForCallback } = await startLocalCallbackServer({ callbackPath, timeoutMs });
+
+  const authUrl = dashboardUrl ? new URL('/connect', dashboardUrl) : new URL('/auth/sign-up', baseUrl);
+  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 }) {
+  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;
+    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) {}
+}
+
+module.exports = {
+  beginBrowserAuth
+};

package/src/lib/codex-config.js

@@ -0,0 +1,157 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const { ensureDir, readJson, writeJson } = require('./fs');
+
+async function upsertCodexNotify({ codexConfigPath, notifyCmd, notifyOriginalPath }) {
+  const originalText = await fs.readFile(codexConfigPath, 'utf8').catch(() => null);
+  if (originalText == null) {
+    throw new Error(`Codex config not found: ${codexConfigPath}`);
+  }
+
+  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 = `${codexConfigPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    await fs.copyFile(codexConfigPath, backupPath);
+    await fs.writeFile(codexConfigPath, updated, 'utf8');
+    return { changed: true, backupPath };
+  }
+
+  return { changed: false, backupPath: null };
+}
+
+async function restoreCodexNotify({ codexConfigPath, notifyOriginalPath }) {
+  const text = await fs.readFile(codexConfigPath, 'utf8').catch(() => null);
+  if (text == null) return;
+
+  const original = await readJson(notifyOriginalPath);
+  const originalNotify = Array.isArray(original?.notify) ? original.notify : null;
+
+  const updated = originalNotify ? setNotify(text, originalNotify) : removeNotify(text);
+  const backupPath = `${codexConfigPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
+  await fs.copyFile(codexConfigPath, backupPath).catch(() => {});
+  await fs.writeFile(codexConfigPath, updated, 'utf8');
+}
+
+async function loadCodexNotifyOriginal(notifyOriginalPath) {
+  const original = await readJson(notifyOriginalPath);
+  return Array.isArray(original?.notify) ? original.notify : null;
+}
+
+async function readCodexNotify(codexConfigPath) {
+  const text = await fs.readFile(codexConfigPath, 'utf8').catch(() => null);
+  if (text == null) return null;
+  return extractNotify(text);
+}
+
+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 = {
+  upsertCodexNotify,
+  restoreCodexNotify,
+  loadCodexNotifyOriginal,
+  readCodexNotify
+};

package/src/lib/diagnostics.js

@@ -0,0 +1,138 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const { readJson } = require('./fs');
+const { readCodexNotify } = require('./codex-config');
+const { normalizeState: normalizeUploadState } = require('./upload-throttle');
+
+async function collectTrackerDiagnostics({
+  home = os.homedir(),
+  codexHome = process.env.CODEX_HOME || path.join(home, '.codex')
+} = {}) {
+  const trackerDir = path.join(home, '.vibescore', 'tracker');
+  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 codexConfigPath = path.join(codexHome, 'config.toml');
+
+  const config = await readJson(configPath);
+  const cursors = await readJson(cursorsPath);
+  const queueState = (await readJson(queueStatePath)) || { offset: 0 };
+  const uploadThrottle = normalizeUploadState(await readJson(uploadThrottlePath));
+
+  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 lastSuccessAt = uploadThrottle.lastSuccessMs ? new Date(uploadThrottle.lastSuccessMs).toISOString() : null;
+
+  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)
+    },
+    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
+    },
+    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
+    }
+  };
+}
+
+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 };
+