vibeusage 0.2.21 → 0.2.23

package/src/lib/uploader.js

@@ -1,13 +1,13 @@
-const fs = require('node:fs/promises');
-const fssync = require('node:fs');
-const readline = require('node:readline');
+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('./vibeusage-api');
+const { ensureDir, readJson, writeJson } = require("./fs");
+const { ingestHourly } = require("./vibeusage-api");
 
-const DEFAULT_SOURCE = 'codex';
-const DEFAULT_MODEL = 'unknown';
-const BUCKET_SEPARATOR = '|';
+const DEFAULT_SOURCE = "codex";
+const DEFAULT_MODEL = "unknown";
+const BUCKET_SEPARATOR = "|";
 const MAX_INGEST_BUCKETS = 500;
 
 async function drainQueueToCloud({
@@ -20,34 +20,36 @@ async function drainQueueToCloud({
   projectQueueStatePath,
   maxBatches,
   batchSize,
-  onProgress
+  onProgress,
 }) {
-  await ensureDir(require('node:path').dirname(queueStatePath));
-  const projectQueueEnabled = typeof projectQueuePath === 'string' && projectQueuePath.length > 0;
+  await ensureDir(require("node:path").dirname(queueStatePath));
+  const projectQueueEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
   if (projectQueueEnabled && (!projectQueueStatePath || projectQueueStatePath.length === 0)) {
-    throw new Error('projectQueueStatePath is required when projectQueuePath is set');
+    throw new Error("projectQueueStatePath is required when projectQueuePath is set");
   }
   if (projectQueueEnabled) {
-    await ensureDir(require('node:path').dirname(projectQueueStatePath));
+    await ensureDir(require("node:path").dirname(projectQueueStatePath));
   }
 
   const state = (await readJson(queueStatePath)) || { offset: 0 };
   let offset = Number(state.offset || 0);
   const projectStatePath = projectQueueEnabled ? projectQueueStatePath : null;
-  const projectState = projectQueueEnabled ? (await readJson(projectStatePath)) || { offset: 0 } : { offset: 0 };
+  const projectState = projectQueueEnabled
+    ? (await readJson(projectStatePath)) || { offset: 0 }
+    : { offset: 0 };
   let projectOffset = Number(projectState.offset || 0);
   let inserted = 0;
   let skipped = 0;
   let attempted = 0;
 
-  const cb = typeof onProgress === 'function' ? onProgress : null;
+  const cb = typeof onProgress === "function" ? onProgress : null;
   const queueSize = await safeFileSize(queuePath);
   const projectQueueSize = projectQueueEnabled ? await safeFileSize(projectQueuePath) : 0;
   const maxBuckets = Math.max(1, Math.floor(Number(batchSize || 200)));
   const totalLimit = Math.min(maxBuckets, MAX_INGEST_BUCKETS);
 
   const normalizedSubscriptions = Array.isArray(deviceSubscriptions)
-    ? deviceSubscriptions.filter((entry) => entry && typeof entry === 'object')
+    ? deviceSubscriptions.filter((entry) => entry && typeof entry === "object")
     : [];
 
   for (let batch = 0; batch < maxBatches; batch++) {
@@ -66,7 +68,9 @@ async function drainQueueToCloud({
     }
 
     const res =
-      hourlyLimit > 0 ? await readBatch(queuePath, offset, hourlyLimit) : { buckets: [], nextOffset: offset };
+      hourlyLimit > 0
+        ? await readBatch(queuePath, offset, hourlyLimit)
+        : { buckets: [], nextOffset: offset };
     const projectRes =
       projectLimit > 0
         ? await readProjectBatch(projectQueuePath, projectOffset, projectLimit)
@@ -79,7 +83,7 @@ async function drainQueueToCloud({
       deviceToken,
       hourly: res.buckets,
       project_hourly: projectRes.buckets,
-      device_subscriptions: batch === 0 ? normalizedSubscriptions : undefined
+      device_subscriptions: batch === 0 ? normalizedSubscriptions : undefined,
     });
     inserted += ingest.inserted || 0;
     skipped += ingest.skipped || 0;
@@ -103,7 +107,7 @@ async function drainQueueToCloud({
         offset: combinedOffset,
         queueSize: queueSize + projectQueueSize,
         inserted,
-        skipped
+        skipped,
       });
     }
   }
@@ -116,14 +120,14 @@ async function readBatch(queuePath, startOffset, maxBuckets) {
   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 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;
+    const bytes = Buffer.byteLength(line, "utf8") + 1;
     offset += bytes;
     if (!line.trim()) continue;
     let bucket;
@@ -132,7 +136,7 @@ async function readBatch(queuePath, startOffset, maxBuckets) {
     } catch (_e) {
       continue;
     }
-    const hourStart = typeof bucket?.hour_start === 'string' ? bucket.hour_start : null;
+    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;
@@ -154,14 +158,14 @@ async function readProjectBatch(queuePath, startOffset, maxBuckets) {
   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 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;
+    const bytes = Buffer.byteLength(line, "utf8") + 1;
     offset += bytes;
     if (!line.trim()) continue;
     let bucket;
@@ -170,9 +174,9 @@ async function readProjectBatch(queuePath, startOffset, maxBuckets) {
     } catch (_e) {
       continue;
     }
-    const hourStart = typeof bucket?.hour_start === 'string' ? bucket.hour_start : null;
-    const projectKey = typeof bucket?.project_key === 'string' ? bucket.project_key : null;
-    const projectRef = typeof bucket?.project_ref === 'string' ? bucket.project_ref : null;
+    const hourStart = typeof bucket?.hour_start === "string" ? bucket.hour_start : null;
+    const projectKey = typeof bucket?.project_key === "string" ? bucket.project_key : null;
+    const projectRef = typeof bucket?.project_ref === "string" ? bucket.project_ref : null;
     if (!hourStart || !projectKey || !projectRef) continue;
     const source = normalizeSource(bucket?.source) || DEFAULT_SOURCE;
     bucket.source = source;
@@ -206,13 +210,13 @@ function projectBucketKey(projectKey, source, hourStart) {
 }
 
 function normalizeSource(value) {
-  if (typeof value !== 'string') return null;
+  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;
+  if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }

package/src/lib/vibeusage-api.js

@@ -1,68 +1,75 @@
-'use strict';
+"use strict";
 
-const { createInsforgeClient } = require('./insforge-client');
+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');
+  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');
+  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' }) {
+async function issueDeviceToken({ baseUrl, accessToken, deviceName, platform = "macos" }) {
   const data = await invokeFunction({
     baseUrl,
     accessToken,
-    slug: 'vibeusage-device-token-issue',
-    method: 'POST',
+    slug: "vibeusage-device-token-issue",
+    method: "POST",
     body: { device_name: deviceName, platform },
-    errorPrefix: 'Device token issue failed'
+    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');
+  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' }) {
+async function exchangeLinkCode({ baseUrl, linkCode, requestId, deviceName, platform = "macos" }) {
   const data = await invokeFunction({
     baseUrl,
     accessToken: null,
-    slug: 'vibeusage-link-code-exchange',
-    method: 'POST',
+    slug: "vibeusage-link-code-exchange",
+    method: "POST",
     body: {
       link_code: linkCode,
       request_id: requestId,
       device_name: deviceName,
-      platform
+      platform,
     },
-    errorPrefix: 'Link code exchange failed'
+    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 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');
+  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, project_hourly, device_subscriptions }) {
+async function ingestHourly({
+  baseUrl,
+  deviceToken,
+  hourly,
+  project_hourly,
+  device_subscriptions,
+}) {
   const body = { hourly, project_hourly };
   if (Array.isArray(device_subscriptions) && device_subscriptions.length > 0) {
     body.device_subscriptions = device_subscriptions;
@@ -71,16 +78,16 @@ async function ingestHourly({ baseUrl, deviceToken, hourly, project_hourly, devi
   const data = await invokeFunctionWithRetry({
     baseUrl,
     accessToken: deviceToken,
-    slug: 'vibeusage-ingest',
-    method: 'POST',
+    slug: "vibeusage-ingest",
+    method: "POST",
     body,
-    errorPrefix: 'Ingest failed',
-    retry: { maxRetries: 3, baseDelayMs: 500, maxDelayMs: 5000 }
+    errorPrefix: "Ingest failed",
+    retry: { maxRetries: 3, baseDelayMs: 500, maxDelayMs: 5000 },
   });
 
   return {
     inserted: Number(data?.inserted || 0),
-    skipped: Number(data?.skipped || 0)
+    skipped: Number(data?.skipped || 0),
   };
 }
 
@@ -88,16 +95,16 @@ async function syncHeartbeat({ baseUrl, deviceToken }) {
   const data = await invokeFunction({
     baseUrl,
     accessToken: deviceToken,
-    slug: 'vibeusage-sync-ping',
-    method: 'POST',
+    slug: "vibeusage-sync-ping",
+    method: "POST",
     body: {},
-    errorPrefix: 'Sync heartbeat failed'
+    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)
+    last_sync_at: typeof data?.last_sync_at === "string" ? data.last_sync_at : null,
+    min_interval_minutes: Number(data?.min_interval_minutes || 0),
   };
 }
 
@@ -106,7 +113,7 @@ module.exports = {
   issueDeviceToken,
   exchangeLinkCode,
   ingestHourly,
-  syncHeartbeat
+  syncHeartbeat,
 };
 
 async function invokeFunction({ baseUrl, accessToken, slug, method, body, errorPrefix }) {
@@ -116,7 +123,15 @@ async function invokeFunction({ baseUrl, accessToken, slug, method, body, errorP
   return data;
 }
 
-async function invokeFunctionWithRetry({ baseUrl, accessToken, slug, method, body, errorPrefix, retry }) {
+async function invokeFunctionWithRetry({
+  baseUrl,
+  accessToken,
+  slug,
+  method,
+  body,
+  errorPrefix,
+  retry,
+}) {
   const retryOptions = normalizeRetryOptions(retry);
   let attempt = 0;
 
@@ -137,8 +152,8 @@ function normalizeSdkError(error, errorPrefix) {
   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;
+  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;
@@ -147,29 +162,29 @@ function normalizeSdkError(error, errorPrefix) {
 }
 
 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 (!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.';
+  if (!isBackendRuntimeDownMessage(message)) return String(message || "Unknown error");
+  return "Backend runtime unavailable (InsForge). Please retry later.";
 }
 
 function isBackendRuntimeDownMessage(message) {
-  const s = String(message || '').toLowerCase();
+  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;
+  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;
 }
 
@@ -178,13 +193,13 @@ function isRetryableStatus(status) {
 }
 
 function isRetryableMessage(message) {
-  const s = String(message || '').toLowerCase();
+  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;
+  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;
 }
 
@@ -195,7 +210,8 @@ function normalizeRetryOptions(retry) {
   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;
+  const jitterRatio =
+    typeof retry.jitterRatio === "number" ? Math.max(0, Math.min(0.5, retry.jitterRatio)) : 0.2;
   return { maxRetries, baseDelayMs, maxDelayMs, jitterRatio };
 }
 
@@ -211,7 +227,7 @@ function computeRetryDelayMs({ retryOptions, attempt, err }) {
   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;
+  const retryAfter = typeof err?.retryAfterMs === "number" ? err.retryAfterMs : 0;
   return Math.max(backoff, retryAfter || 0);
 }
 

package/src/lib/vibeusage-public-repo.js

@@ -1,10 +1,10 @@
-const crypto = require('node:crypto');
+const crypto = require("node:crypto");
 
-const GITHUB_HOST = 'github.com';
-const GITHUB_API_BASE = 'https://api.github.com';
+const GITHUB_HOST = "github.com";
+const GITHUB_API_BASE = "https://api.github.com";
 
 function parseGitHubRepoId(projectRef) {
-  if (typeof projectRef !== 'string') return null;
+  if (typeof projectRef !== "string") return null;
   let parsed;
   try {
     parsed = new URL(projectRef);
@@ -12,24 +12,31 @@ function parseGitHubRepoId(projectRef) {
     return null;
   }
   if (!parsed.hostname || parsed.hostname.toLowerCase() !== GITHUB_HOST) return null;
-  const segments = parsed.pathname.split('/').filter(Boolean);
+  const segments = parsed.pathname.split("/").filter(Boolean);
   if (segments.length < 2) return null;
   const owner = segments[0].trim().toLowerCase();
-  const repo = segments[1].trim().replace(/\.git$/i, '').toLowerCase();
+  const repo = segments[1]
+    .trim()
+    .replace(/\.git$/i, "")
+    .toLowerCase();
   if (!owner || !repo) return null;
   return { owner, repo, repoId: `${owner}/${repo}` };
 }
 
 function hashRepoRoot(repoRoot) {
-  return crypto.createHash('sha256').update(String(repoRoot)).digest('hex');
+  return crypto.createHash("sha256").update(String(repoRoot)).digest("hex");
 }
 
 function isRateLimited(res, body) {
   if (!res) return false;
-  const remaining = res.headers?.get?.('x-ratelimit-remaining');
-  if (remaining === '0') return true;
+  const remaining = res.headers?.get?.("x-ratelimit-remaining");
+  if (remaining === "0") return true;
   if (res.status === 429) return true;
-  if (body && typeof body.message === 'string' && body.message.toLowerCase().includes('rate limit')) {
+  if (
+    body &&
+    typeof body.message === "string" &&
+    body.message.toLowerCase().includes("rate limit")
+  ) {
     return true;
   }
   return false;
@@ -38,7 +45,7 @@ function isRateLimited(res, body) {
 async function resolveGitHubPublicStatus(projectRef, fetchImpl) {
   const parsed = parseGitHubRepoId(projectRef);
   if (!parsed) {
-    return { status: 'blocked', projectKey: null, projectRef, reason: 'non_github' };
+    return { status: "blocked", projectKey: null, projectRef, reason: "non_github" };
   }
   const fetchFn = fetchImpl || fetch;
   const apiUrl = `${GITHUB_API_BASE}/repos/${parsed.repoId}`;
@@ -48,41 +55,51 @@ async function resolveGitHubPublicStatus(projectRef, fetchImpl) {
   try {
     res = await fetchFn(apiUrl, {
       headers: {
-        Accept: 'application/vnd.github+json',
-        'User-Agent': 'vibeusage-cli'
-      }
+        Accept: "application/vnd.github+json",
+        "User-Agent": "vibeusage-cli",
+      },
     });
   } catch (_err) {
-    return { status: 'pending_public', projectKey: parsed.repoId, projectRef, reason: 'fetch_failed' };
+    return {
+      status: "pending_public",
+      projectKey: parsed.repoId,
+      projectRef,
+      reason: "fetch_failed",
+    };
   }
 
   if (res.status === 200) {
     body = await res.json().catch(() => ({}));
-    const isPrivate = body && typeof body.private === 'boolean' ? body.private : null;
-    const visibility = typeof body?.visibility === 'string' ? body.visibility : null;
-    const isPublic = isPrivate === false || visibility === 'public';
+    const isPrivate = body && typeof body.private === "boolean" ? body.private : null;
+    const visibility = typeof body?.visibility === "string" ? body.visibility : null;
+    const isPublic = isPrivate === false || visibility === "public";
     return {
-      status: isPublic ? 'public_verified' : 'blocked',
+      status: isPublic ? "public_verified" : "blocked",
       projectKey: parsed.repoId,
       projectRef,
-      reason: isPublic ? 'public' : 'private'
+      reason: isPublic ? "public" : "private",
     };
   }
 
   if (res.status === 404) {
-    return { status: 'blocked', projectKey: parsed.repoId, projectRef, reason: 'not_found' };
+    return { status: "blocked", projectKey: parsed.repoId, projectRef, reason: "not_found" };
   }
 
   body = await res.json().catch(() => ({}));
   if (isRateLimited(res, body) || res.status === 401 || res.status === 403 || res.status >= 500) {
-    return { status: 'pending_public', projectKey: parsed.repoId, projectRef, reason: 'rate_limited' };
+    return {
+      status: "pending_public",
+      projectKey: parsed.repoId,
+      projectRef,
+      reason: "rate_limited",
+    };
   }
 
-  return { status: 'pending_public', projectKey: parsed.repoId, projectRef, reason: 'unknown' };
+  return { status: "pending_public", projectKey: parsed.repoId, projectRef, reason: "unknown" };
 }
 
 module.exports = {
   parseGitHubRepoId,
   hashRepoRoot,
-  resolveGitHubPublicStatus
+  resolveGitHubPublicStatus,
 };