tokentracker-cli 0.2.23

package/src/lib/runtime-config.js

@@ -0,0 +1,132 @@
+const DEFAULT_BASE_URL = "https://5tmappuk.us-east.insforge.app";
+const DEFAULT_DASHBOARD_URL = "https://www.tokentracker.cc";
+const DEFAULT_HTTP_TIMEOUT_MS = 20_000;
+
+function resolveRuntimeConfig({ cli = {}, config = {}, env = process.env, defaults = {} } = {}) {
+  const baseUrl = pickString(
+    cli.baseUrl,
+    config.baseUrl,
+    env?.VIBEUSAGE_INSFORGE_BASE_URL,
+    defaults.baseUrl,
+    DEFAULT_BASE_URL,
+  );
+  const dashboardUrl = pickString(
+    cli.dashboardUrl,
+    config.dashboardUrl,
+    env?.VIBEUSAGE_DASHBOARD_URL,
+    defaults.dashboardUrl,
+    DEFAULT_DASHBOARD_URL,
+  );
+  const deviceToken = pickString(
+    cli.deviceToken,
+    config.deviceToken,
+    env?.VIBEUSAGE_DEVICE_TOKEN,
+    defaults.deviceToken,
+    null,
+  );
+  const httpTimeoutMs = pickHttpTimeoutMs(
+    cli.httpTimeoutMs,
+    config.httpTimeoutMs,
+    env?.VIBEUSAGE_HTTP_TIMEOUT_MS,
+    defaults.httpTimeoutMs,
+    DEFAULT_HTTP_TIMEOUT_MS,
+  );
+  const debug = pickBoolean(cli.debug, config.debug, env?.VIBEUSAGE_DEBUG, defaults.debug, false);
+  const insforgeAnonKey = pickString(
+    cli.insforgeAnonKey,
+    config.insforgeAnonKey,
+    env?.VIBEUSAGE_INSFORGE_ANON_KEY,
+    defaults.insforgeAnonKey,
+    "",
+  );
+  if (insforgeAnonKey.value == null) insforgeAnonKey.value = "";
+  const autoRetryNoSpawn = pickBoolean(
+    cli.autoRetryNoSpawn,
+    config.autoRetryNoSpawn,
+    env?.VIBEUSAGE_AUTO_RETRY_NO_SPAWN,
+    defaults.autoRetryNoSpawn,
+    false,
+  );
+
+  return {
+    baseUrl: baseUrl.value,
+    dashboardUrl: dashboardUrl.value,
+    deviceToken: deviceToken.value,
+    httpTimeoutMs: httpTimeoutMs.value,
+    debug: debug.value,
+    insforgeAnonKey: insforgeAnonKey.value,
+    autoRetryNoSpawn: autoRetryNoSpawn.value,
+    sources: {
+      baseUrl: baseUrl.source,
+      dashboardUrl: dashboardUrl.source,
+      deviceToken: deviceToken.source,
+      httpTimeoutMs: httpTimeoutMs.source,
+      debug: debug.source,
+      insforgeAnonKey: insforgeAnonKey.source,
+      autoRetryNoSpawn: autoRetryNoSpawn.source,
+    },
+  };
+}
+
+function pickString(...candidates) {
+  return pickValue(candidates, normalizeString);
+}
+
+function pickBoolean(...candidates) {
+  return pickValue(candidates, normalizeBoolean);
+}
+
+function pickHttpTimeoutMs(...candidates) {
+  return pickValue(candidates, normalizeHttpTimeoutMs);
+}
+
+function pickValue(candidates, normalize) {
+  const labels = ["cli", "config", "env", "default", "default"];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const value = normalize(candidates[i]);
+    if (value !== undefined) {
+      return { value, source: labels[i] || "default" };
+    }
+  }
+  return { value: null, source: "default" };
+}
+
+function normalizeString(value) {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  return trimmed;
+}
+
+function normalizeBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed) return undefined;
+    if (trimmed === "1" || trimmed === "true") return true;
+    if (trimmed === "0" || trimmed === "false") return false;
+  }
+  return undefined;
+}
+
+function normalizeHttpTimeoutMs(value) {
+  if (value == null || value === "") return undefined;
+  const n = Number(value);
+  if (!Number.isFinite(n)) return undefined;
+  if (n <= 0) return 0;
+  return clampInt(n, 1000, 120_000);
+}
+
+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)));
+}
+
+module.exports = {
+  DEFAULT_BASE_URL,
+  DEFAULT_DASHBOARD_URL,
+  DEFAULT_HTTP_TIMEOUT_MS,
+  resolveRuntimeConfig,
+};

package/src/lib/static-server.js

@@ -0,0 +1,59 @@
+const fs = require("node:fs");
+const fsPromises = require("node:fs/promises");
+const path = require("node:path");
+
+const MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".xml": "application/xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json",
+};
+
+/**
+ * Serve a static file from baseDir. Returns true if served, false otherwise.
+ * For SPA: caller should fall back to index.html when this returns false.
+ */
+async function serveStaticFile(baseDir, pathname, res) {
+  const safePath = path.normalize(pathname).replace(/^(\.\.[/\\])+/, "");
+  const filePath = path.join(baseDir, safePath);
+
+  // prevent directory traversal
+  if (!filePath.startsWith(baseDir)) return false;
+
+  try {
+    const stat = await fsPromises.stat(filePath);
+    if (!stat.isFile()) return false;
+
+    const ext = path.extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    const isHtml = ext === ".html";
+
+    res.writeHead(200, {
+      "Content-Type": contentType,
+      "Content-Length": stat.size,
+      "Cache-Control": isHtml ? "no-cache" : "public, max-age=31536000, immutable",
+    });
+
+    const stream = fs.createReadStream(filePath);
+    stream.pipe(res);
+    return true;
+  } catch (_e) {
+    return false;
+  }
+}
+
+module.exports = { serveStaticFile };

package/src/lib/subscriptions.js

@@ -0,0 +1,319 @@
+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 { resolveTrackerPaths } = require("./tracker-paths");
+const { probeOpenclawSessionPluginState } = require("./openclaw-session-plugin");
+
+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);
+  }
+
+  const openclaw = await detectOpenclawSessionIntegration({ home, env });
+  if (openclaw) out.push(openclaw);
+
+  // Gemini: no stable local subscription/tier signal found yet.
+  return out;
+}
+
+async function detectOpenclawSessionIntegration({ home, env }) {
+  const { trackerDir } = await resolveTrackerPaths({ home });
+  let state = null;
+  try {
+    state = await probeOpenclawSessionPluginState({ home, trackerDir, env });
+  } catch (_err) {
+    return null;
+  }
+
+  if (!state?.configured) return null;
+
+  return {
+    tool: "openclaw",
+    provider: "openclaw",
+    product: "session_plugin",
+    planType: "enabled",
+  };
+}
+
+module.exports = {
+  collectLocalSubscriptions,
+};

package/src/lib/tracker-paths.js

@@ -0,0 +1,15 @@
+const os = require("node:os");
+const path = require("node:path");
+
+async function resolveTrackerPaths({ home = os.homedir() } = {}) {
+  const rootDir = path.join(home, ".tokentracker");
+  return {
+    rootDir,
+    trackerDir: path.join(rootDir, "tracker"),
+    binDir: path.join(rootDir, "bin"),
+  };
+}
+
+module.exports = {
+  resolveTrackerPaths,
+};

package/src/lib/upload-throttle.js

@@ -0,0 +1,148 @@
+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,
+};