vibeusage 0.2.8

package/src/lib/tracker-paths.js

@@ -0,0 +1,66 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+async function resolveTrackerPaths({ home = os.homedir(), migrate = true } = {}) {
+  const legacyRootDir = path.join(home, '.vibescore');
+  const rootDir = path.join(home, '.vibeusage');
+  const legacyTrackerDir = path.join(legacyRootDir, 'tracker');
+  const legacyBinDir = path.join(legacyRootDir, 'bin');
+  const trackerDir = path.join(rootDir, 'tracker');
+  const binDir = path.join(rootDir, 'bin');
+
+  const legacyExists = await pathExists(legacyRootDir);
+  const newExists = await pathExists(rootDir);
+
+  let usingLegacy = false;
+  let migrated = false;
+
+  if (migrate && legacyExists && !newExists) {
+    const result = await migrateLegacyRoot({ legacyRootDir, rootDir });
+    usingLegacy = result.usingLegacy;
+    migrated = result.migrated;
+  } else if (!newExists && legacyExists) {
+    usingLegacy = true;
+  }
+
+  const activeRootDir = usingLegacy ? legacyRootDir : rootDir;
+  return {
+    rootDir: activeRootDir,
+    trackerDir: path.join(activeRootDir, 'tracker'),
+    binDir: path.join(activeRootDir, 'bin'),
+    legacyRootDir,
+    legacyTrackerDir,
+    legacyBinDir,
+    migrated,
+    usingLegacy
+  };
+}
+
+async function migrateLegacyRoot({ legacyRootDir, rootDir }) {
+  try {
+    await fs.rename(legacyRootDir, rootDir);
+    return { migrated: true, usingLegacy: false };
+  } catch (err) {
+    try {
+      await fs.cp(legacyRootDir, rootDir, { recursive: true });
+      return { migrated: true, usingLegacy: false };
+    } catch (copyErr) {
+      return { migrated: false, usingLegacy: true, error: copyErr };
+    }
+  }
+}
+
+async function pathExists(target) {
+  try {
+    await fs.stat(target);
+    return true;
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return false;
+    throw err;
+  }
+}
+
+module.exports = {
+  resolveTrackerPaths
+};

package/src/lib/upload-throttle.js

@@ -0,0 +1,129 @@
+const DEFAULTS = {
+  intervalMs: 30 * 60_000,
+  jitterMsMax: 60_000,
+  backlogBytes: 1_000_000,
+  batchSize: 300,
+  maxBatchesSmall: 2,
+  maxBatchesLarge: 4,
+  backoffInitialMs: 60_000,
+  backoffMaxMs: 30 * 60_000
+};
+
+function normalizeState(raw) {
+  const s = raw && typeof raw === 'object' ? raw : {};
+  return {
+    version: 1,
+    lastSuccessMs: toSafeInt(s.lastSuccessMs),
+    nextAllowedAtMs: toSafeInt(s.nextAllowedAtMs),
+    backoffUntilMs: toSafeInt(s.backoffUntilMs),
+    backoffStep: toSafeInt(s.backoffStep),
+    lastErrorAt: typeof s.lastErrorAt === 'string' ? s.lastErrorAt : null,
+    lastError: typeof s.lastError === 'string' ? s.lastError : null,
+    updatedAt: typeof s.updatedAt === 'string' ? s.updatedAt : null
+  };
+}
+
+function decideAutoUpload({ nowMs, pendingBytes, state, config }) {
+  const cfg = { ...DEFAULTS, ...(config || {}) };
+  const s = normalizeState(state);
+  const pending = Number(pendingBytes || 0);
+
+  if (pending <= 0) {
+    return { allowed: false, reason: 'no-pending', maxBatches: 0, batchSize: cfg.batchSize, blockedUntilMs: 0 };
+  }
+
+  const blockedUntilMs = Math.max(s.nextAllowedAtMs || 0, s.backoffUntilMs || 0);
+  if (blockedUntilMs > 0 && nowMs < blockedUntilMs) {
+    return { allowed: false, reason: 'throttled', maxBatches: 0, batchSize: cfg.batchSize, blockedUntilMs };
+  }
+
+  const maxBatches = pending >= cfg.backlogBytes ? cfg.maxBatchesLarge : cfg.maxBatchesSmall;
+  return { allowed: true, reason: 'allowed', maxBatches, batchSize: cfg.batchSize, blockedUntilMs: 0 };
+}
+
+function recordUploadSuccess({ nowMs, state, config, randInt }) {
+  const cfg = { ...DEFAULTS, ...(config || {}) };
+  const s = normalizeState(state);
+  const jitter = typeof randInt === 'function' ? randInt(0, cfg.jitterMsMax) : randomInt(0, cfg.jitterMsMax);
+  const nextAllowedAtMs = nowMs + cfg.intervalMs + jitter;
+
+  return {
+    ...s,
+    lastSuccessMs: nowMs,
+    nextAllowedAtMs,
+    backoffUntilMs: 0,
+    backoffStep: 0,
+    lastErrorAt: null,
+    lastError: null,
+    updatedAt: new Date(nowMs).toISOString()
+  };
+}
+
+function recordUploadFailure({ nowMs, state, error, config }) {
+  const cfg = { ...DEFAULTS, ...(config || {}) };
+  const s = normalizeState(state);
+
+  const retryAfterMs = toSafeInt(error?.retryAfterMs);
+  const status = toSafeInt(error?.status);
+
+  let backoffMs = 0;
+  if (retryAfterMs > 0) {
+    backoffMs = Math.min(cfg.backoffMaxMs, Math.max(cfg.backoffInitialMs, retryAfterMs));
+  } else {
+    const step = Math.min(10, Math.max(0, s.backoffStep || 0));
+    backoffMs = Math.min(cfg.backoffMaxMs, cfg.backoffInitialMs * Math.pow(2, step));
+  }
+
+  const backoffUntilMs = nowMs + backoffMs;
+  const nextAllowedAtMs = Math.max(s.nextAllowedAtMs || 0, backoffUntilMs);
+
+  return {
+    ...s,
+    nextAllowedAtMs,
+    backoffUntilMs,
+    backoffStep: Math.min(20, (s.backoffStep || 0) + 1),
+    lastErrorAt: new Date(nowMs).toISOString(),
+    lastError: truncate(String(error?.message || 'upload failed'), 200),
+    updatedAt: new Date(nowMs).toISOString()
+  };
+}
+
+function parseRetryAfterMs(headerValue, nowMs = Date.now()) {
+  if (typeof headerValue !== 'string' || headerValue.trim().length === 0) return null;
+  const v = headerValue.trim();
+  const seconds = Number(v);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.floor(seconds * 1000);
+  const d = new Date(v);
+  if (Number.isNaN(d.getTime())) return null;
+  const delta = d.getTime() - nowMs;
+  return delta > 0 ? delta : 0;
+}
+
+function randomInt(min, maxInclusive) {
+  const lo = Math.floor(min);
+  const hi = Math.floor(maxInclusive);
+  if (hi <= lo) return lo;
+  return lo + Math.floor(Math.random() * (hi - lo + 1));
+}
+
+function toSafeInt(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return 0;
+  if (n <= 0) return 0;
+  return Math.floor(n);
+}
+
+function truncate(s, maxLen) {
+  if (typeof s !== 'string') return '';
+  if (s.length <= maxLen) return s;
+  return s.slice(0, maxLen - 1) + '…';
+}
+
+module.exports = {
+  DEFAULTS,
+  normalizeState,
+  decideAutoUpload,
+  recordUploadSuccess,
+  recordUploadFailure,
+  parseRetryAfterMs
+};

package/src/lib/uploader.js

@@ -0,0 +1,116 @@
+const fs = require('node:fs/promises');
+const fssync = require('node:fs');
+const readline = require('node:readline');
+
+const { ensureDir, readJson, writeJson } = require('./fs');
+const { ingestHourly } = require('./vibescore-api');
+
+const DEFAULT_SOURCE = 'codex';
+const DEFAULT_MODEL = 'unknown';
+const BUCKET_SEPARATOR = '|';
+
+async function drainQueueToCloud({ baseUrl, deviceToken, queuePath, queueStatePath, maxBatches, batchSize, onProgress }) {
+  await ensureDir(require('node:path').dirname(queueStatePath));
+
+  const state = (await readJson(queueStatePath)) || { offset: 0 };
+  let offset = Number(state.offset || 0);
+  let inserted = 0;
+  let skipped = 0;
+  let attempted = 0;
+
+  const cb = typeof onProgress === 'function' ? onProgress : null;
+  const queueSize = await safeFileSize(queuePath);
+  const maxBuckets = Math.max(1, Math.floor(Number(batchSize || 200)));
+
+  for (let batch = 0; batch < maxBatches; batch++) {
+    const res = await readBatch(queuePath, offset, maxBuckets);
+    if (res.buckets.length === 0) break;
+
+    attempted += res.buckets.length;
+    const ingest = await ingestHourly({ baseUrl, deviceToken, hourly: res.buckets });
+    inserted += ingest.inserted || 0;
+    skipped += ingest.skipped || 0;
+
+    offset = res.nextOffset;
+    state.offset = offset;
+    state.updatedAt = new Date().toISOString();
+    await writeJson(queueStatePath, state);
+
+    if (cb) {
+      cb({
+        batch: batch + 1,
+        maxBatches,
+        offset,
+        queueSize,
+        inserted,
+        skipped
+      });
+    }
+  }
+
+  return { inserted, skipped, attempted };
+}
+
+async function readBatch(queuePath, startOffset, maxBuckets) {
+  const st = await fs.stat(queuePath).catch(() => null);
+  if (!st || !st.isFile()) return { buckets: [], nextOffset: startOffset };
+  if (startOffset >= st.size) return { buckets: [], nextOffset: startOffset };
+
+  const stream = fssync.createReadStream(queuePath, { encoding: 'utf8', start: startOffset });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  const bucketMap = new Map();
+  let offset = startOffset;
+  let linesRead = 0;
+  for await (const line of rl) {
+    const bytes = Buffer.byteLength(line, 'utf8') + 1;
+    offset += bytes;
+    if (!line.trim()) continue;
+    let bucket;
+    try {
+      bucket = JSON.parse(line);
+    } catch (_e) {
+      continue;
+    }
+    const hourStart = typeof bucket?.hour_start === 'string' ? bucket.hour_start : null;
+    if (!hourStart) continue;
+    const source = normalizeSource(bucket?.source) || DEFAULT_SOURCE;
+    const model = normalizeModel(bucket?.model) || DEFAULT_MODEL;
+    bucket.source = source;
+    bucket.model = model;
+    bucketMap.set(bucketKey(source, model, hourStart), bucket);
+    linesRead += 1;
+    if (linesRead >= maxBuckets) break;
+  }
+
+  rl.close();
+  stream.close?.();
+  return { buckets: Array.from(bucketMap.values()), nextOffset: offset };
+}
+
+async function safeFileSize(p) {
+  try {
+    const st = await fs.stat(p);
+    return st && st.isFile() ? st.size : 0;
+  } catch (_e) {
+    return 0;
+  }
+}
+
+function bucketKey(source, model, hourStart) {
+  return `${source}${BUCKET_SEPARATOR}${model}${BUCKET_SEPARATOR}${hourStart}`;
+}
+
+function normalizeSource(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim().toLowerCase();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizeModel(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+module.exports = { drainQueueToCloud };

package/src/lib/vibescore-api.js

@@ -0,0 +1,222 @@
+'use strict';
+
+const { createInsforgeClient } = require('./insforge-client');
+
+async function signInWithPassword({ baseUrl, email, password }) {
+  const client = createInsforgeClient({ baseUrl });
+  const { data, error } = await client.auth.signInWithPassword({ email, password });
+  if (error) throw normalizeSdkError(error, 'Sign-in failed');
+
+  const accessToken = data?.accessToken;
+  if (typeof accessToken !== 'string' || accessToken.length === 0) {
+    throw new Error('Sign-in failed: missing accessToken');
+  }
+
+  return accessToken;
+}
+
+async function issueDeviceToken({ baseUrl, accessToken, deviceName, platform = 'macos' }) {
+  const data = await invokeFunction({
+    baseUrl,
+    accessToken,
+    slug: 'vibescore-device-token-issue',
+    method: 'POST',
+    body: { device_name: deviceName, platform },
+    errorPrefix: 'Device token issue failed'
+  });
+
+  const token = data?.token;
+  const deviceId = data?.device_id;
+  if (typeof token !== 'string' || token.length === 0) throw new Error('Device token issue failed: missing token');
+  if (typeof deviceId !== 'string' || deviceId.length === 0) {
+    throw new Error('Device token issue failed: missing device_id');
+  }
+
+  return { token, deviceId };
+}
+
+async function exchangeLinkCode({ baseUrl, linkCode, requestId, deviceName, platform = 'macos' }) {
+  const data = await invokeFunction({
+    baseUrl,
+    accessToken: null,
+    slug: 'vibescore-link-code-exchange',
+    method: 'POST',
+    body: {
+      link_code: linkCode,
+      request_id: requestId,
+      device_name: deviceName,
+      platform
+    },
+    errorPrefix: 'Link code exchange failed'
+  });
+
+  const token = data?.token;
+  const deviceId = data?.device_id;
+  if (typeof token !== 'string' || token.length === 0) {
+    throw new Error('Link code exchange failed: missing token');
+  }
+  if (typeof deviceId !== 'string' || deviceId.length === 0) {
+    throw new Error('Link code exchange failed: missing device_id');
+  }
+
+  return { token, deviceId, userId: data?.user_id || null };
+}
+
+async function ingestHourly({ baseUrl, deviceToken, hourly }) {
+  const data = await invokeFunctionWithRetry({
+    baseUrl,
+    accessToken: deviceToken,
+    slug: 'vibescore-ingest',
+    method: 'POST',
+    body: { hourly },
+    errorPrefix: 'Ingest failed',
+    retry: { maxRetries: 3, baseDelayMs: 500, maxDelayMs: 5000 }
+  });
+
+  return {
+    inserted: Number(data?.inserted || 0),
+    skipped: Number(data?.skipped || 0)
+  };
+}
+
+async function syncHeartbeat({ baseUrl, deviceToken }) {
+  const data = await invokeFunction({
+    baseUrl,
+    accessToken: deviceToken,
+    slug: 'vibescore-sync-ping',
+    method: 'POST',
+    body: {},
+    errorPrefix: 'Sync heartbeat failed'
+  });
+
+  return {
+    updated: Boolean(data?.updated),
+    last_sync_at: typeof data?.last_sync_at === 'string' ? data.last_sync_at : null,
+    min_interval_minutes: Number(data?.min_interval_minutes || 0)
+  };
+}
+
+module.exports = {
+  signInWithPassword,
+  issueDeviceToken,
+  exchangeLinkCode,
+  ingestHourly,
+  syncHeartbeat
+};
+
+async function invokeFunction({ baseUrl, accessToken, slug, method, body, errorPrefix }) {
+  const client = createInsforgeClient({ baseUrl, accessToken });
+  const { data, error } = await client.functions.invoke(slug, { method, body });
+  if (error) throw normalizeSdkError(error, errorPrefix);
+  return data;
+}
+
+async function invokeFunctionWithRetry({ baseUrl, accessToken, slug, method, body, errorPrefix, retry }) {
+  const retryOptions = normalizeRetryOptions(retry);
+  let attempt = 0;
+
+  while (true) {
+    try {
+      return await invokeFunction({ baseUrl, accessToken, slug, method, body, errorPrefix });
+    } catch (e) {
+      if (!shouldRetry({ err: e, attempt, retryOptions })) throw e;
+      const delayMs = computeRetryDelayMs({ retryOptions, attempt, err: e });
+      await sleep(delayMs);
+      attempt += 1;
+    }
+  }
+}
+
+function normalizeSdkError(error, errorPrefix) {
+  const raw = extractSdkErrorMessage(error);
+  const msg = normalizeBackendErrorMessage(raw);
+  const err = new Error(errorPrefix ? `${errorPrefix}: ${msg}` : msg);
+  const status = error?.statusCode ?? error?.status;
+  const code = typeof error?.error === 'string' ? error.error.trim() : '';
+  if (typeof status === 'number') err.status = status;
+  if (code) err.code = code;
+  err.retryable = isRetryableStatus(status) || isRetryableMessage(raw);
+  if (msg !== raw) err.originalMessage = raw;
+  if (error?.nextActions) err.nextActions = error.nextActions;
+  return err;
+}
+
+function extractSdkErrorMessage(error) {
+  if (!error) return 'Unknown error';
+  const message = typeof error.message === 'string' ? error.message.trim() : '';
+  const code = typeof error.error === 'string' ? error.error.trim() : '';
+  if (message && message !== 'InsForgeError') return message;
+  if (code && code !== 'REQUEST_FAILED') return code;
+  if (message) return message;
+  if (code) return code;
+  return String(error);
+}
+
+function normalizeBackendErrorMessage(message) {
+  if (!isBackendRuntimeDownMessage(message)) return String(message || 'Unknown error');
+  return 'Backend runtime unavailable (InsForge). Please retry later.';
+}
+
+function isBackendRuntimeDownMessage(message) {
+  const s = String(message || '').toLowerCase();
+  if (!s) return false;
+  if (s.includes('deno:') || s.includes('deno')) return true;
+  if (s.includes('econnreset') || s.includes('econnrefused')) return true;
+  if (s.includes('etimedout')) return true;
+  if (s.includes('timeout') && s.includes('request')) return true;
+  if (s.includes('upstream') && (s.includes('deno') || s.includes('connect'))) return true;
+  return false;
+}
+
+function isRetryableStatus(status) {
+  return status === 429 || status === 502 || status === 503 || status === 504;
+}
+
+function isRetryableMessage(message) {
+  const s = String(message || '').toLowerCase();
+  if (!s) return false;
+  if (isBackendRuntimeDownMessage(s)) return true;
+  if (s.includes('econnreset') || s.includes('econnrefused')) return true;
+  if (s.includes('etimedout') || s.includes('timeout')) return true;
+  if (s.includes('networkerror') || s.includes('failed to fetch')) return true;
+  if (s.includes('socket hang up') || s.includes('connection reset')) return true;
+  return false;
+}
+
+function normalizeRetryOptions(retry) {
+  if (!retry) {
+    return { maxRetries: 0, baseDelayMs: 0, maxDelayMs: 0, jitterRatio: 0.0 };
+  }
+  const maxRetries = clampInt(retry.maxRetries, 0, 10);
+  const baseDelayMs = clampInt(retry.baseDelayMs ?? 300, 50, 60_000);
+  const maxDelayMs = clampInt(retry.maxDelayMs ?? baseDelayMs * 4, baseDelayMs, 120_000);
+  const jitterRatio = typeof retry.jitterRatio === 'number' ? Math.max(0, Math.min(0.5, retry.jitterRatio)) : 0.2;
+  return { maxRetries, baseDelayMs, maxDelayMs, jitterRatio };
+}
+
+function shouldRetry({ err, attempt, retryOptions }) {
+  if (!retryOptions || retryOptions.maxRetries <= 0) return false;
+  if (attempt >= retryOptions.maxRetries) return false;
+  return Boolean(err && err.retryable);
+}
+
+function computeRetryDelayMs({ retryOptions, attempt, err }) {
+  if (!retryOptions || retryOptions.maxRetries <= 0) return 0;
+  const exp = retryOptions.baseDelayMs * Math.pow(2, attempt);
+  const capped = Math.min(retryOptions.maxDelayMs, exp);
+  const jitter = capped * retryOptions.jitterRatio * Math.random();
+  const backoff = Math.round(capped + jitter);
+  const retryAfter = typeof err?.retryAfterMs === 'number' ? err.retryAfterMs : 0;
+  return Math.max(backoff, retryAfter || 0);
+}
+
+function clampInt(value, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return min;
+  return Math.min(max, Math.max(min, Math.floor(n)));
+}
+
+function sleep(ms) {
+  if (!ms || ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}