vibeusage 0.2.15 → 0.2.17

package/src/lib/subscriptions.js

@@ -0,0 +1,317 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs');
+const cp = require('node:child_process');
+
+const { readJson } = require('./fs');
+
+const OPENAI_AUTH_CLAIM = 'https://api.openai.com/auth';
+const MACOS_SECURITY_BIN = '/usr/bin/security';
+const CLAUDE_CODE_KEYCHAIN_SERVICES = ['Claude Code-credentials'];
+
+function normalizeString(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizeScalarToString(value) {
+  if (value === null || value === undefined) return null;
+  if (typeof value === 'string') return normalizeString(value);
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) return null;
+    return normalizeString(String(value));
+  }
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  return null;
+}
+
+function base64UrlDecodeToString(value) {
+  if (typeof value !== 'string' || value.length === 0) return null;
+  const padLen = (4 - (value.length % 4)) % 4;
+  const padded = value + '='.repeat(padLen);
+  const base64 = padded.replace(/-/g, '+').replace(/_/g, '/');
+  try {
+    return Buffer.from(base64, 'base64').toString('utf8');
+  } catch (_e) {
+    return null;
+  }
+}
+
+function decodeJwtPayload(token) {
+  const jwt = normalizeString(token);
+  if (!jwt) return null;
+  const parts = jwt.split('.');
+  if (parts.length < 2) return null;
+  const decoded = base64UrlDecodeToString(parts[1]);
+  if (!decoded) return null;
+  try {
+    return JSON.parse(decoded);
+  } catch (_e) {
+    return null;
+  }
+}
+
+function extractOpenAiAuthNamespace(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  const ns = payload[OPENAI_AUTH_CLAIM];
+  if (!ns || typeof ns !== 'object' || Array.isArray(ns)) return null;
+  return ns;
+}
+
+function extractChatgptSubscriptionFromPayload(payload) {
+  const ns = extractOpenAiAuthNamespace(payload);
+  if (!ns) return null;
+
+  const planType = normalizeString(ns.chatgpt_plan_type);
+  const activeStart = normalizeString(ns.chatgpt_subscription_active_start);
+  const activeUntil = normalizeString(ns.chatgpt_subscription_active_until);
+  const lastChecked = normalizeString(ns.chatgpt_subscription_last_checked);
+
+  if (!planType && !activeStart && !activeUntil && !lastChecked) return null;
+  return { planType, activeStart, activeUntil, lastChecked };
+}
+
+function mergeSubscription(primary, secondary) {
+  if (!primary && !secondary) return null;
+  const a = primary || {};
+  const b = secondary || {};
+  return {
+    planType: a.planType || b.planType || null,
+    activeStart: a.activeStart || b.activeStart || null,
+    activeUntil: a.activeUntil || b.activeUntil || null,
+    lastChecked: a.lastChecked || b.lastChecked || null
+  };
+}
+
+function isDisplayablePlanType(planType) {
+  const normalized = normalizeString(planType);
+  if (!normalized) return false;
+  const v = normalized.toLowerCase();
+  if (v === 'free' || v === 'none' || v === 'unknown') return false;
+  return true;
+}
+
+function resolveCodexHome({ home, env }) {
+  const explicit = normalizeString(env?.CODEX_HOME);
+  return explicit ? path.resolve(explicit) : path.join(home, '.codex');
+}
+
+function resolveOpencodeDataDir({ home, env }) {
+  const explicit = normalizeString(env?.XDG_DATA_HOME);
+  const base = explicit ? path.resolve(explicit) : path.join(home, '.local', 'share');
+  return path.join(base, 'opencode');
+}
+
+async function detectCodexChatgptSubscription({ home, env }) {
+  const codexHome = resolveCodexHome({ home, env });
+  const authPath = path.join(codexHome, 'auth.json');
+  const auth = await readJson(authPath);
+  if (!auth || typeof auth !== 'object') return null;
+
+  const accessPayload = decodeJwtPayload(auth?.tokens?.access_token);
+  const idPayload = decodeJwtPayload(auth?.tokens?.id_token);
+
+  const accessInfo = extractChatgptSubscriptionFromPayload(accessPayload);
+  const idInfo = extractChatgptSubscriptionFromPayload(idPayload);
+  const merged = mergeSubscription(accessInfo, idInfo);
+  if (!merged || !isDisplayablePlanType(merged.planType)) return null;
+
+  return {
+    tool: 'codex',
+    provider: 'openai',
+    product: 'chatgpt',
+    planType: merged.planType,
+    activeStart: merged.activeStart,
+    activeUntil: merged.activeUntil,
+    lastChecked: merged.lastChecked
+  };
+}
+
+async function detectOpencodeChatgptSubscription({ home, env }) {
+  const dataDir = resolveOpencodeDataDir({ home, env });
+  const authPath = path.join(dataDir, 'auth.json');
+  const auth = await readJson(authPath);
+  if (!auth || typeof auth !== 'object') return null;
+
+  const accessPayload = decodeJwtPayload(auth?.openai?.access);
+  const info = extractChatgptSubscriptionFromPayload(accessPayload);
+  if (!info || !isDisplayablePlanType(info.planType)) return null;
+
+  return {
+    tool: 'opencode',
+    provider: 'openai',
+    product: 'chatgpt',
+    planType: info.planType,
+    activeStart: info.activeStart,
+    activeUntil: info.activeUntil,
+    lastChecked: info.lastChecked
+  };
+}
+
+function probeMacosKeychainGenericPassword({
+  service,
+  securityRunner,
+  timeoutMs
+} = {}) {
+  const svc = normalizeString(service);
+  if (!svc) return false;
+
+  const runner = typeof securityRunner === 'function' ? securityRunner : cp.spawnSync;
+  if (runner === cp.spawnSync && !fs.existsSync(MACOS_SECURITY_BIN)) return false;
+
+  const result = runner(
+    MACOS_SECURITY_BIN,
+    ['find-generic-password', '-s', svc],
+    {
+      stdio: 'ignore',
+      timeout: Number.isFinite(timeoutMs) ? timeoutMs : 2000
+    }
+  );
+
+  if (!result || result.error) return false;
+  return result.status === 0;
+}
+
+function readMacosKeychainPassword({
+  service,
+  securityRunner,
+  timeoutMs
+} = {}) {
+  const svc = normalizeString(service);
+  if (!svc) return null;
+
+  const runner = typeof securityRunner === 'function' ? securityRunner : cp.spawnSync;
+  if (runner === cp.spawnSync && !fs.existsSync(MACOS_SECURITY_BIN)) return null;
+
+  const result = runner(
+    MACOS_SECURITY_BIN,
+    ['find-generic-password', '-s', svc, '-w'],
+    {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: Number.isFinite(timeoutMs) ? timeoutMs : 2000,
+      encoding: 'utf8'
+    }
+  );
+
+  if (!result || result.error) return null;
+  if (result.status !== 0) return null;
+
+  const stdout =
+    typeof result.stdout === 'string'
+      ? result.stdout
+      : Buffer.isBuffer(result.stdout)
+        ? result.stdout.toString('utf8')
+        : '';
+  const trimmed = stdout.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function detectClaudeCodeCredentialsPresence({
+  platform,
+  securityRunner
+} = {}) {
+  if (platform !== 'darwin') return null;
+
+  for (const service of CLAUDE_CODE_KEYCHAIN_SERVICES) {
+    const present = probeMacosKeychainGenericPassword({
+      service,
+      securityRunner
+    });
+    if (!present) continue;
+
+    // Existence-only probe: do not read secrets or infer paid tier.
+    return {
+      tool: 'claude',
+      provider: 'anthropic',
+      product: 'credentials',
+      planType: 'present'
+    };
+  }
+
+  return null;
+}
+
+function extractClaudeKeychainSubscription(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null;
+
+  const oauth = payload.claudeAiOauth;
+  if (!oauth || typeof oauth !== 'object' || Array.isArray(oauth)) return null;
+
+  const subscriptionType = normalizeScalarToString(oauth.subscriptionType);
+  const rateLimitTier = normalizeScalarToString(oauth.rateLimitTier);
+
+  if (!subscriptionType) return null;
+  return { subscriptionType, rateLimitTier };
+}
+
+function detectClaudeCodeSubscriptionDetails({
+  platform,
+  securityRunner
+} = {}) {
+  if (platform !== 'darwin') return null;
+
+  for (const service of CLAUDE_CODE_KEYCHAIN_SERVICES) {
+    const raw = readMacosKeychainPassword({
+      service,
+      securityRunner
+    });
+    if (!raw) continue;
+
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch (_e) {
+      continue;
+    }
+
+    const info = extractClaudeKeychainSubscription(payload);
+    if (!info) continue;
+
+    return {
+      tool: 'claude',
+      provider: 'anthropic',
+      product: 'subscription',
+      planType: info.subscriptionType,
+      rateLimitTier: info.rateLimitTier
+    };
+  }
+
+  return null;
+}
+
+async function collectLocalSubscriptions({
+  home = os.homedir(),
+  env = process.env,
+  platform = process.platform,
+  securityRunner,
+  probeKeychain = false,
+  probeKeychainDetails = false
+} = {}) {
+  const out = [];
+
+  const codex = await detectCodexChatgptSubscription({ home, env });
+  if (codex) out.push(codex);
+
+  const opencode = await detectOpencodeChatgptSubscription({ home, env });
+  if (opencode) out.push(opencode);
+
+  if (probeKeychainDetails) {
+    const claude = detectClaudeCodeSubscriptionDetails({ platform, securityRunner });
+    if (claude) out.push(claude);
+    else if (probeKeychain) {
+      const present = detectClaudeCodeCredentialsPresence({ platform, securityRunner });
+      if (present) out.push(present);
+    }
+  } else if (probeKeychain) {
+    const claude = detectClaudeCodeCredentialsPresence({ platform, securityRunner });
+    if (claude) out.push(claude);
+  }
+
+  // Gemini: no stable local subscription/tier signal found yet.
+  return out;
+}
+
+module.exports = {
+  collectLocalSubscriptions
+};

package/src/lib/uploader.js

@@ -8,26 +8,79 @@ const { ingestHourly } = require('./vibeusage-api');
 const DEFAULT_SOURCE = 'codex';
 const DEFAULT_MODEL = 'unknown';
 const BUCKET_SEPARATOR = '|';
-
-async function drainQueueToCloud({ baseUrl, deviceToken, queuePath, queueStatePath, maxBatches, batchSize, onProgress }) {
+const MAX_INGEST_BUCKETS = 500;
+
+async function drainQueueToCloud({
+  baseUrl,
+  deviceToken,
+  deviceSubscriptions,
+  queuePath,
+  queueStatePath,
+  projectQueuePath,
+  projectQueueStatePath,
+  maxBatches,
+  batchSize,
+  onProgress
+}) {
   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');
+  }
+  if (projectQueueEnabled) {
+    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 };
+  let projectOffset = Number(projectState.offset || 0);
   let inserted = 0;
   let skipped = 0;
   let attempted = 0;
 
   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')
+    : [];
 
   for (let batch = 0; batch < maxBatches; batch++) {
-    const res = await readBatch(queuePath, offset, maxBuckets);
-    if (res.buckets.length === 0) break;
+    const hasHourly = queueSize > offset;
+    const hasProject = projectQueueEnabled && projectQueueSize > projectOffset;
+    let hourlyLimit = 0;
+    let projectLimit = 0;
+
+    if (hasHourly && hasProject) {
+      hourlyLimit = Math.ceil(totalLimit / 2);
+      projectLimit = totalLimit - hourlyLimit;
+    } else if (hasHourly) {
+      hourlyLimit = totalLimit;
+    } else if (hasProject) {
+      projectLimit = totalLimit;
+    }
 
-    attempted += res.buckets.length;
-    const ingest = await ingestHourly({ baseUrl, deviceToken, hourly: res.buckets });
+    const res =
+      hourlyLimit > 0 ? await readBatch(queuePath, offset, hourlyLimit) : { buckets: [], nextOffset: offset };
+    const projectRes =
+      projectLimit > 0
+        ? await readProjectBatch(projectQueuePath, projectOffset, projectLimit)
+        : { buckets: [], nextOffset: projectOffset };
+    if (res.buckets.length === 0 && projectRes.buckets.length === 0) break;
+
+    attempted += res.buckets.length + projectRes.buckets.length;
+    const ingest = await ingestHourly({
+      baseUrl,
+      deviceToken,
+      hourly: res.buckets,
+      project_hourly: projectRes.buckets,
+      device_subscriptions: batch === 0 ? normalizedSubscriptions : undefined
+    });
     inserted += ingest.inserted || 0;
     skipped += ingest.skipped || 0;
 
@@ -35,13 +88,20 @@ async function drainQueueToCloud({ baseUrl, deviceToken, queuePath, queueStatePa
     state.offset = offset;
     state.updatedAt = new Date().toISOString();
     await writeJson(queueStatePath, state);
+    if (projectQueuePath) {
+      projectOffset = projectRes.nextOffset;
+      projectState.offset = projectOffset;
+      projectState.updatedAt = new Date().toISOString();
+      await writeJson(projectStatePath, projectState);
+    }
 
     if (cb) {
+      const combinedOffset = offset + projectOffset;
       cb({
         batch: batch + 1,
         maxBatches,
-        offset,
-        queueSize,
+        offset: combinedOffset,
+        queueSize: queueSize + projectQueueSize,
         inserted,
         skipped
       });
@@ -88,6 +148,46 @@ async function readBatch(queuePath, startOffset, maxBuckets) {
   return { buckets: Array.from(bucketMap.values()), nextOffset: offset };
 }
 
+async function readProjectBatch(queuePath, startOffset, maxBuckets) {
+  if (!queuePath) return { buckets: [], nextOffset: startOffset };
+  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;
+    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;
+    bucket.project_key = projectKey;
+    bucket.project_ref = projectRef;
+    bucketMap.set(projectBucketKey(projectKey, source, 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);
@@ -101,6 +201,10 @@ function bucketKey(source, model, hourStart) {
   return `${source}${BUCKET_SEPARATOR}${model}${BUCKET_SEPARATOR}${hourStart}`;
 }
 
+function projectBucketKey(projectKey, source, hourStart) {
+  return `${projectKey}${BUCKET_SEPARATOR}${source}${BUCKET_SEPARATOR}${hourStart}`;
+}
+
 function normalizeSource(value) {
   if (typeof value !== 'string') return null;
   const trimmed = value.trim().toLowerCase();

package/src/lib/vibeusage-api.js

@@ -62,13 +62,18 @@ async function exchangeLinkCode({ baseUrl, linkCode, requestId, deviceName, plat
   return { token, deviceId, userId: data?.user_id || null };
 }
 
-async function ingestHourly({ baseUrl, deviceToken, hourly }) {
+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;
+  }
+
   const data = await invokeFunctionWithRetry({
     baseUrl,
     accessToken: deviceToken,
     slug: 'vibeusage-ingest',
     method: 'POST',
-    body: { hourly },
+    body,
     errorPrefix: 'Ingest failed',
     retry: { maxRetries: 3, baseDelayMs: 500, maxDelayMs: 5000 }
   });

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

@@ -0,0 +1,88 @@
+const crypto = require('node:crypto');
+
+const GITHUB_HOST = 'github.com';
+const GITHUB_API_BASE = 'https://api.github.com';
+
+function parseGitHubRepoId(projectRef) {
+  if (typeof projectRef !== 'string') return null;
+  let parsed;
+  try {
+    parsed = new URL(projectRef);
+  } catch (_err) {
+    return null;
+  }
+  if (!parsed.hostname || parsed.hostname.toLowerCase() !== GITHUB_HOST) return null;
+  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();
+  if (!owner || !repo) return null;
+  return { owner, repo, repoId: `${owner}/${repo}` };
+}
+
+function hashRepoRoot(repoRoot) {
+  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;
+  if (res.status === 429) return true;
+  if (body && typeof body.message === 'string' && body.message.toLowerCase().includes('rate limit')) {
+    return true;
+  }
+  return false;
+}
+
+async function resolveGitHubPublicStatus(projectRef, fetchImpl) {
+  const parsed = parseGitHubRepoId(projectRef);
+  if (!parsed) {
+    return { status: 'blocked', projectKey: null, projectRef, reason: 'non_github' };
+  }
+  const fetchFn = fetchImpl || fetch;
+  const apiUrl = `${GITHUB_API_BASE}/repos/${parsed.repoId}`;
+
+  let res;
+  let body = null;
+  try {
+    res = await fetchFn(apiUrl, {
+      headers: {
+        Accept: 'application/vnd.github+json',
+        'User-Agent': 'vibeusage-cli'
+      }
+    });
+  } catch (_err) {
+    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';
+    return {
+      status: isPublic ? 'public_verified' : 'blocked',
+      projectKey: parsed.repoId,
+      projectRef,
+      reason: isPublic ? 'public' : 'private'
+    };
+  }
+
+  if (res.status === 404) {
+    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: 'unknown' };
+}
+
+module.exports = {
+  parseGitHubRepoId,
+  hashRepoRoot,
+  resolveGitHubPublicStatus
+};