tokentracker-cli 0.5.0 → 0.5.2

package/src/commands/sync.js

@@ -22,16 +22,10 @@ const {
   parseCursorApiIncremental,
   parseKiroIncremental,
 } = require("../lib/rollout");
-const { drainQueueToCloud } = require("../lib/uploader");
-const { collectLocalSubscriptions } = require("../lib/subscriptions");
 const { createProgress, renderBar, formatNumber, formatBytes } = require("../lib/progress");
-const { syncHeartbeat } = require("../lib/vibeusage-api");
 const {
-  DEFAULTS: UPLOAD_DEFAULTS,
   normalizeState: normalizeUploadState,
   decideAutoUpload,
-  recordUploadSuccess,
-  recordUploadFailure,
 } = require("../lib/upload-throttle");
 const {
   isCursorInstalled,
@@ -347,118 +341,26 @@ async function cmdSync(argv) {
     progress?.stop();
 
     const runtime = resolveRuntimeConfig({ config: config || {}, env: process.env });
-    const deviceToken = runtime.deviceToken;
-    const baseUrl = runtime.baseUrl;
 
-    let uploadResult = null;
+    let uploadResult = { inserted: 0, skipped: 0 };
     let uploadAttempted = false;
-    if (deviceToken) {
-      const beforeState = (await readJson(queueStatePath)) || { offset: 0 };
-      const projectBeforeState = (await readJson(projectQueueStatePath)) || { offset: 0 };
-      const queueSize = await safeStatSize(queuePath);
-      const projectQueueSize = await safeStatSize(projectQueuePath);
-      const pendingBytes =
-        Math.max(0, queueSize - Number(beforeState.offset || 0)) +
-        Math.max(0, projectQueueSize - Number(projectBeforeState.offset || 0));
-      let maxBatches = opts.auto ? 3 : opts.drain ? 10_000 : 10;
-      let batchSize = UPLOAD_DEFAULTS.batchSize;
-      let allowUpload = pendingBytes > 0;
-      let autoDecision = null;
-
-      if (opts.auto) {
-        autoDecision = decideAutoUpload({
-          nowMs: Date.now(),
-          pendingBytes,
-          state: uploadThrottle,
-        });
-        allowUpload = allowUpload && autoDecision.allowed;
-        maxBatches = autoDecision.allowed ? autoDecision.maxBatches : 0;
-        batchSize = autoDecision.batchSize;
-        if (!autoDecision.allowed && pendingBytes > 0 && autoDecision.blockedUntilMs > 0) {
-          const reason = deriveAutoSkipReason({ decision: autoDecision, state: uploadThrottle });
-          await scheduleAutoRetry({
-            trackerDir,
-            retryAtMs: autoDecision.blockedUntilMs,
-            reason,
-            pendingBytes,
-            source: "auto-throttled",
-            autoRetryNoSpawn: runtime.autoRetryNoSpawn,
-          });
-        }
-      }
 
-      if (progress?.enabled && pendingBytes > 0 && allowUpload) {
-        const totalSize = queueSize + projectQueueSize;
-        const totalOffset =
-          Number(beforeState.offset || 0) + Number(projectBeforeState.offset || 0);
-        const pct = totalSize > 0 ? totalOffset / totalSize : 0;
-        progress.start(
-          `Uploading ${renderBar(pct)} ${formatBytes(totalOffset)}/${formatBytes(totalSize)} | inserted 0 skipped 0`,
-        );
-      }
-
-      if (allowUpload && maxBatches > 0) {
-        uploadAttempted = true;
-        const deviceSubscriptions = await collectLocalSubscriptions({
-          home,
-          env: process.env,
-          probeKeychain: true,
-          probeKeychainDetails: true,
+    if (runtime.deviceToken && runtime.baseUrl) {
+      uploadAttempted = true;
+      try {
+        uploadResult = await drainQueueToCloud({
+          baseUrl: runtime.baseUrl,
+          deviceToken: runtime.deviceToken,
+          queuePath,
+          queueStatePath,
+          maxBatches: opts.drain ? 100 : 5,
+          batchSize: 200,
         });
-        try {
-          uploadResult = await drainQueueToCloud({
-            baseUrl,
-            deviceToken,
-            deviceSubscriptions,
-            queuePath,
-            queueStatePath,
-            projectQueuePath,
-            projectQueueStatePath,
-            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: uploadThrottleState });
-            uploadThrottleState = next;
-            await writeJson(uploadThrottlePath, next);
-          }
-        } catch (e) {
-          const next = recordUploadFailure({
-            nowMs: Date.now(),
-            state: uploadThrottleState,
-            error: e,
-          });
-          uploadThrottleState = next;
-          await writeJson(uploadThrottlePath, next);
-          if (opts.auto && pendingBytes > 0) {
-            const retryAtMs = Math.max(next.nextAllowedAtMs || 0, next.backoffUntilMs || 0);
-            if (retryAtMs > 0) {
-              await scheduleAutoRetry({
-                trackerDir,
-                retryAtMs,
-                reason: "backoff",
-                pendingBytes,
-                source: "auto-error",
-                autoRetryNoSpawn: runtime.autoRetryNoSpawn,
-              });
-            }
-          }
-          throw e;
+      } catch (e) {
+        if (!opts.auto) {
+          process.stderr.write(`Upload error: ${e?.message || e}\n`);
         }
-      } else {
-        uploadResult = { inserted: 0, skipped: 0 };
       }
-
-      progress?.stop();
     }
 
     const afterState = (await readJson(queueStatePath)) || { offset: 0 };
@@ -485,14 +387,6 @@ async function cmdSync(argv) {
       }
     }
 
-    await maybeSendHeartbeat({
-      baseUrl,
-      deviceToken,
-      trackerDir,
-      uploadResult,
-      pendingBytes,
-    });
-
     if (!opts.auto) {
       const totalParsed =
         parseResult.filesProcessed +
@@ -515,10 +409,10 @@ async function cmdSync(argv) {
           "Sync finished:",
           `- Parsed files: ${totalParsed}`,
           `- New 30-min buckets queued: ${totalBuckets}`,
-          deviceToken
+          runtime.deviceToken
             ? `- Uploaded: ${uploadResult.inserted} inserted, ${uploadResult.skipped} skipped`
             : "- Uploaded: skipped (no device token)",
-          deviceToken && pendingBytes > 0 && !opts.drain
+          runtime.deviceToken && pendingBytes > 0 && !opts.drain
             ? `- Remaining: ${formatBytes(pendingBytes)} pending (run sync again, or use --drain)`
             : null,
           "",
@@ -714,34 +608,6 @@ async function safeStatSize(p) {
   }
 }
 
-async function maybeSendHeartbeat({
-  baseUrl,
-  deviceToken,
-  trackerDir,
-  uploadResult,
-  pendingBytes,
-}) {
-  if (!deviceToken || !uploadResult) return;
-  if (pendingBytes > 0) return;
-  if (Number(uploadResult.inserted || 0) !== 0) return;
-
-  const heartbeatPath = path.join(trackerDir, "sync.heartbeat.json");
-  const heartbeatState = await readJson(heartbeatPath);
-  const lastPingAt = Date.parse(heartbeatState?.lastPingAt || "");
-  const nowMs = Date.now();
-  if (Number.isFinite(lastPingAt) && nowMs - lastPingAt < HEARTBEAT_MIN_INTERVAL_MS) return;
-
-  try {
-    await syncHeartbeat({ baseUrl, deviceToken });
-    await writeJson(heartbeatPath, {
-      lastPingAt: new Date(nowMs).toISOString(),
-      minIntervalMinutes: HEARTBEAT_MIN_INTERVAL_MINUTES,
-    });
-  } catch (_e) {
-    // best-effort heartbeat; ignore failures
-  }
-}
-
 function deriveAutoSkipReason({ decision, state }) {
   if (!decision || decision.reason !== "throttled") return decision?.reason || "unknown";
   const backoffUntilMs = Number(state?.backoffUntilMs || 0);
@@ -790,7 +656,7 @@ async function scheduleAutoRetry({
   spawnAutoRetryProcess({
     retryPath,
     trackerBinPath: path.join(trackerDir, "app", "bin", "tracker.js"),
-    fallbackPkg: "vibeusage",
+    fallbackPkg: "tokentracker-cli",
     delayMs,
   });
   return { scheduled: true, retryAtMs: retryMs };
@@ -856,7 +722,94 @@ async function writeOpenclawSignal(trackerDir) {
   }
 }
 
-const HEARTBEAT_MIN_INTERVAL_MINUTES = 30;
-const HEARTBEAT_MIN_INTERVAL_MS = HEARTBEAT_MIN_INTERVAL_MINUTES * 60 * 1000;
 const AUTO_RETRY_FILENAME = "auto.retry.json";
 const AUTO_RETRY_MAX_DELAY_MS = 2 * 60 * 60 * 1000;
+
+const readline = require("node:readline");
+
+const INGEST_SLUG = "tokentracker-ingest";
+const MAX_INGEST_BUCKETS = 500;
+
+async function drainQueueToCloud({ baseUrl, deviceToken, queuePath, queueStatePath, maxBatches = 5, batchSize = 200 }) {
+  const state = (await readJson(queueStatePath)) || { offset: 0 };
+  let offset = Number(state.offset || 0);
+  let inserted = 0;
+  let skipped = 0;
+
+  const queueSize = await safeStatSize(queuePath);
+  const limit = Math.min(Math.max(1, Math.floor(Number(batchSize || 200))), MAX_INGEST_BUCKETS);
+
+  for (let batch = 0; batch < maxBatches; batch++) {
+    if (offset >= queueSize) break;
+    const result = await readQueueBatch(queuePath, offset, limit);
+    if (result.buckets.length === 0) break;
+
+    const root = baseUrl.replace(/\/$/, "");
+    const anonKey = process.env.TOKENTRACKER_INSFORGE_ANON_KEY || "";
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${deviceToken}`,
+    };
+    if (anonKey) headers.apikey = anonKey;
+    const res = await fetch(`${root}/functions/${INGEST_SLUG}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ hourly: result.buckets }),
+    });
+
+    const rawText = await res.text().catch(() => "");
+    let data = {};
+    try { data = JSON.parse(rawText); } catch { data = {}; }
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}: ${rawText.substring(0, 500)}`);
+    }
+
+    inserted += Number(data?.inserted || 0);
+    skipped += Number(data?.skipped || 0);
+
+    offset = result.nextOffset;
+    state.offset = offset;
+    state.updatedAt = new Date().toISOString();
+    await writeJson(queueStatePath, state);
+  }
+
+  return { inserted, skipped };
+}
+
+async function readQueueBatch(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 = (typeof bucket?.source === "string" ? bucket.source.trim().toLowerCase() : "") || "codex";
+    const model = (typeof bucket?.model === "string" ? bucket.model.trim() : "") || "unknown";
+    bucket.source = source;
+    bucket.model = model;
+    bucketMap.set(`${source}|${model}|${hourStart}`, bucket);
+    linesRead += 1;
+    if (linesRead >= maxBuckets) break;
+  }
+
+  rl.close();
+  stream.close?.();
+  return { buckets: Array.from(bucketMap.values()), nextOffset: offset };
+}

package/src/lib/activation-check.js

@@ -5,7 +5,7 @@ const { readJson } = require("./fs");
 
 /**
  * 跨 AI CLI 自动激活检测
- * 在 vibeusage 各种命令执行时顺带检测并完成配置
+ * 在 tokentracker 各种命令执行时顺带检测并完成配置
  */
 
 const AI_CLIS = [
@@ -84,7 +84,7 @@ async function checkAndActivate({ home = os.homedir(), silent = true, autoConfig
         });
         
         if (!silent) {
-          console.log(`⏳ 检测到 ${cli.displayName} 未配置，运行 'vibeusage init' 以配置`);
+          console.log(`⏳ 检测到 ${cli.displayName} 未配置，运行 'tokentracker init' 以配置`);
         }
       }
     } catch (err) {
@@ -115,7 +115,7 @@ async function checkCodexConfigured({ home }) {
   try {
     const content = await fs.readFile(configPath, "utf8");
     // 检查是否已配置 notify
-    return content.includes("vibeusage") || content.includes("notify");
+    return content.includes("tokentracker") || content.includes("notify");
   } catch {
     return false;
   }
@@ -125,9 +125,9 @@ async function configureCodex({ home, silent }) {
   try {
     // 使用现有的 codex-config 模块
     const { upsertCodexNotify } = require("./codex-config");
-    const notifyCmd = path.join(home, ".vibeusage", "bin", "notify.cjs");
+    const notifyCmd = path.join(home, ".tokentracker", "bin", "notify.cjs");
     const codexConfigPath = path.join(home, ".codex", "config.toml");
-    const notifyOriginalPath = path.join(home, ".vibeusage", "backups", "codex-notify-original.json");
+    const notifyOriginalPath = path.join(home, ".tokentracker", "backups", "codex-notify-original.json");
     
     await upsertCodexNotify({
       codexConfigPath,
@@ -157,10 +157,10 @@ async function checkClaudeCodeConfigured({ home }) {
   const settingsPath = path.join(home, ".claude", "settings.json");
   try {
     const settings = await readJson(settingsPath);
-    // 检查是否已有 vibeusage 相关的 hook
+    // 检查是否已有 tokentracker 相关的 hook
     const hooks = settings?.hooks?.SessionStart || [];
-    return hooks.some(h => 
-      h.hooks?.some(hook => hook.command?.includes("vibeusage"))
+    return hooks.some(h =>
+      h.hooks?.some(hook => hook.command?.includes("tokentracker"))
     );
   } catch {
     return false;
@@ -178,8 +178,8 @@ async function configureClaudeCode({ home, silent }) {
     
     // 检查是否已存在
     const exists = settings.hooks.SessionStart.some(h => 
-      h.matcher === "startup" && 
-      h.hooks?.some(hook => hook.command?.includes("vibeusage activate-if-needed"))
+      h.matcher === "startup" &&
+      h.hooks?.some(hook => hook.command?.includes("tokentracker activate-if-needed"))
     );
     
     if (!exists) {
@@ -187,7 +187,7 @@ async function configureClaudeCode({ home, silent }) {
         matcher: "startup",
         hooks: [{
           type: "command",
-          command: "vibeusage activate-if-needed --silent 2>/dev/null || true"
+          command: "tokentracker activate-if-needed --silent 2>/dev/null || true"
         }]
       });
       
@@ -216,7 +216,7 @@ async function checkOpencodeConfigured({ home }) {
   const pluginDir = path.join(home, ".config", "opencode", "plugins");
   try {
     const files = await fs.readdir(pluginDir);
-    return files.some(f => f.includes("vibeusage"));
+    return files.some(f => f.includes("tokentracker"));
   } catch {
     return false;
   }
@@ -227,11 +227,11 @@ async function configureOpencode({ home, silent }) {
     const pluginDir = path.join(home, ".config", "opencode", "plugins");
     await fs.mkdir(pluginDir, { recursive: true });
     
-    const pluginPath = path.join(pluginDir, "vibeusage-activation.js");
-    const pluginCode = `export const VibeusageActivation = async ({ $ }) => {
+    const pluginPath = path.join(pluginDir, "tokentracker-activation.js");
+    const pluginCode = `export const TokentrackerActivation = async ({ $ }) => {
   return {
     "session.created": async () => {
-      await $'vibeusage activate-if-needed --silent'.quiet().nothrow();
+      await $'tokentracker activate-if-needed --silent'.quiet().nothrow();
     }
   };
 };`;
@@ -260,7 +260,7 @@ async function checkEveryCodeConfigured({ home }) {
   const configPath = path.join(home, ".code", "config.toml");
   try {
     const content = await fs.readFile(configPath, "utf8");
-    return content.includes("vibeusage");
+    return content.includes("tokentracker");
   } catch {
     return false;
   }
@@ -277,11 +277,11 @@ async function configureEveryCode({ home, silent }) {
       content = "";
     }
     
-    const notifyCmd = path.join(home, ".vibeusage", "bin", "notify.cjs");
+    const notifyCmd = path.join(home, ".tokentracker", "bin", "notify.cjs");
     const notifyLine = `notify = ["/usr/bin/env", "node", "${notifyCmd}"]`;
-    
-    if (!content.includes("vibeusage")) {
-      content = content.trim() + "\n\n# vibeusage integration\n" + notifyLine + "\n";
+
+    if (!content.includes("tokentracker")) {
+      content = content.trim() + "\n\n# tokentracker integration\n" + notifyLine + "\n";
       await fs.writeFile(configPath, content, "utf8");
     }
     return true;
@@ -329,7 +329,7 @@ async function configureOpenclaw({ home, silent }) {
     const result = await installOpenclawSessionPlugin({
       home,
       trackerDir,
-      packageName: "vibeusage",
+      packageName: "tokentracker-cli",
       env: process.env,
     });
     

package/src/lib/browser-auth.js

@@ -6,7 +6,7 @@ const { DEFAULT_BASE_URL } = require("./runtime-config");
 
 async function beginBrowserAuth({ baseUrl, dashboardUrl, timeoutMs, open }) {
   const nonce = crypto.randomBytes(16).toString("hex");
-  const callbackPath = `/vibeusage/callback/${nonce}`;
+  const callbackPath = `/tokentracker/callback/${nonce}`;
   const authUrl = dashboardUrl ? new URL("/", dashboardUrl) : new URL("/auth/sign-up", baseUrl);
   const postAuthRedirect = resolvePostAuthRedirect({ dashboardUrl, authUrl });
   const { callbackUrl, waitForCallback } = await startLocalCallbackServer({

package/src/lib/doctor.js

@@ -56,8 +56,6 @@ function buildRuntimeChecks(runtime = {}) {
     ? Number(runtime.httpTimeoutMs)
     : null;
   const debug = Boolean(runtime.debug);
-  const insforgeAnonKey =
-    typeof runtime.insforgeAnonKey === "string" && runtime.insforgeAnonKey.trim() ? "set" : "unset";
   const autoRetryNoSpawn = Boolean(runtime.autoRetryNoSpawn);
 
   checks.push({
@@ -115,17 +113,6 @@ function buildRuntimeChecks(runtime = {}) {
     },
   });
 
-  checks.push({
-    id: "runtime.insforge_anon_key",
-    status: "ok",
-    detail: insforgeAnonKey === "set" ? "anon key set" : "anon key unset",
-    critical: false,
-    meta: {
-      anon_key: insforgeAnonKey,
-      source: runtime?.sources?.insforgeAnonKey || null,
-    },
-  });
-
   checks.push({
     id: "runtime.auto_retry_no_spawn",
     status: "ok",

package/src/lib/gemini-config.js

@@ -5,7 +5,7 @@ const fs = require("node:fs/promises");
 const { ensureDir, readJson, writeJson } = require("./fs");
 
 const DEFAULT_EVENT = "SessionEnd";
-const DEFAULT_HOOK_NAME = "vibeusage-tracker";
+const DEFAULT_HOOK_NAME = "tokentracker";
 const DEFAULT_MATCHER = "exit|clear|logout|prompt_input_exit|other";
 
 function resolveGeminiConfigDir({ home = os.homedir(), env = process.env } = {}) {

package/src/lib/local-api.js

@@ -281,10 +281,27 @@ function trimOutput(value, max = 4000) {
   return t.length <= max ? t : t.slice(t.length - max);
 }
 
-function runSyncCommand() {
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        if (!raw.trim()) return resolve({});
+        resolve(JSON.parse(raw));
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function runSyncCommand(extraEnv = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(process.execPath, [TRACKER_BIN, "sync"], {
-      env: process.env,
+      env: { ...process.env, ...extraEnv },
       stdio: ["ignore", "pipe", "pipe"],
     });
     let stdout = "";
@@ -443,14 +460,79 @@ function createLocalApiHandler({ queuePath }) {
   return async function handleLocalApi(req, res, url) {
     const p = url.pathname;
 
+    // --- auth proxy: forward /api/auth/* to InsForge cloud ---
+    if (p.startsWith("/api/auth/")) {
+      let insforgeBase = process.env.TOKENTRACKER_INSFORGE_BASE_URL
+        || process.env.INSFORGE_BASE_URL
+        || "";
+      if (!insforgeBase) {
+        try {
+          const cfgPath = path.join(os.homedir(), ".tokentracker", "tracker", "config.json");
+          const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+          insforgeBase = cfg?.baseUrl || "";
+        } catch { /* ignore */ }
+      }
+      if (!insforgeBase) {
+        json(res, { error: "InsForge base URL not configured" }, 500);
+        return true;
+      }
+      try {
+        const targetUrl = `${insforgeBase.replace(/\/$/, "")}${p}${url.search || ""}`;
+        const proxyHeaders = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+          if (key === "host" || key === "connection") continue;
+          proxyHeaders[key] = value;
+        }
+        const bodyChunks = [];
+        for await (const chunk of req) bodyChunks.push(chunk);
+        const body = bodyChunks.length > 0 ? Buffer.concat(bodyChunks) : undefined;
+        const proxyRes = await fetch(targetUrl, {
+          method: req.method || "GET",
+          headers: proxyHeaders,
+          body,
+          credentials: "include",
+          redirect: "manual",
+        });
+        res.writeHead(proxyRes.status, Object.fromEntries(
+          [...proxyRes.headers.entries()].filter(([k]) =>
+            !["transfer-encoding", "connection"].includes(k.toLowerCase())
+          ).map(([k, v]) => {
+            // Rewrite cookie domain to localhost
+            if (k.toLowerCase() === "set-cookie") {
+              return [k, v.replace(/;\s*[Dd]omain=[^;]*/g, "; Domain=localhost")];
+            }
+            return [k, v];
+          })
+        ));
+        const resBody = await proxyRes.arrayBuffer();
+        res.end(Buffer.from(resBody));
+      } catch (e) {
+        json(res, { error: `Auth proxy error: ${e?.message || e}` }, 502);
+      }
+      return true;
+    }
+
     // --- local-sync (POST) ---
-    if (p === "/functions/vibeusage-local-sync") {
+    if (p === "/functions/tokentracker-local-sync") {
       if (String(req.method || "GET").toUpperCase() !== "POST") {
         json(res, { ok: false, error: "Method Not Allowed" }, 405);
         return true;
       }
       try {
-        const result = await runSyncCommand();
+        let body = {};
+        try {
+          body = await readJsonBody(req);
+        } catch {
+          body = {};
+        }
+        const extraEnv = {};
+        if (typeof body.deviceToken === "string" && body.deviceToken.trim()) {
+          extraEnv.TOKENTRACKER_DEVICE_TOKEN = body.deviceToken.trim();
+        }
+        if (typeof body.insforgeBaseUrl === "string" && /^https?:\/\//i.test(body.insforgeBaseUrl.trim())) {
+          extraEnv.TOKENTRACKER_INSFORGE_BASE_URL = body.insforgeBaseUrl.trim();
+        }
+        const result = await runSyncCommand(extraEnv);
         json(res, { ok: true, ...result });
       } catch (e) {
         json(res, { ok: false, error: e?.message, code: e?.code ?? null, stdout: e?.stdout || "", stderr: e?.stderr || "" }, 500);
@@ -459,7 +541,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- usage-summary ---
-    if (p === "/functions/vibeusage-usage-summary") {
+    if (p === "/functions/tokentracker-usage-summary") {
       const from = url.searchParams.get("from") || "";
       const to = url.searchParams.get("to") || "";
       const rows = readQueueData(qp);
@@ -524,7 +606,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- usage-daily ---
-    if (p === "/functions/vibeusage-usage-daily") {
+    if (p === "/functions/tokentracker-usage-daily") {
       const from = url.searchParams.get("from") || "";
       const to = url.searchParams.get("to") || "";
       const rows = readQueueData(qp);
@@ -534,7 +616,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- usage-heatmap ---
-    if (p === "/functions/vibeusage-usage-heatmap") {
+    if (p === "/functions/tokentracker-usage-heatmap") {
       const weeks = parseInt(url.searchParams.get("weeks") || "52", 10);
       const rows = readQueueData(qp);
       const daily = aggregateByDay(rows);
@@ -577,7 +659,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- usage-model-breakdown ---
-    if (p === "/functions/vibeusage-usage-model-breakdown") {
+    if (p === "/functions/tokentracker-usage-model-breakdown") {
       const from = url.searchParams.get("from") || "";
       const to = url.searchParams.get("to") || "";
       const rows = readQueueData(qp).filter((r) => {
@@ -639,7 +721,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- project-usage-summary ---
-    if (p === "/functions/vibeusage-project-usage-summary") {
+    if (p === "/functions/tokentracker-project-usage-summary") {
       const projectMap = new Map();
       scanCodexProjects(projectMap);
       scanClaudeProjects(projectMap);
@@ -676,7 +758,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- user-status (stub) ---
-    if (p === "/functions/vibeusage-user-status") {
+    if (p === "/functions/tokentracker-user-status") {
       json(res, {
         user_id: "local-user", email: "local@localhost", name: "Local User", is_public: false,
         created_at: new Date().toISOString(),
@@ -686,7 +768,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- usage-hourly (stub for day-view) ---
-    if (p === "/functions/vibeusage-usage-hourly") {
+    if (p === "/functions/tokentracker-usage-hourly") {
       const day = url.searchParams.get("day") || new Date().toISOString().slice(0, 10);
       const timeZoneContext = getTimeZoneContext(url);
       const rows = readQueueData(qp);
@@ -696,7 +778,7 @@ function createLocalApiHandler({ queuePath }) {
     }
 
     // --- usage-monthly (stub for trend view) ---
-    if (p === "/functions/vibeusage-usage-monthly") {
+    if (p === "/functions/tokentracker-usage-monthly") {
       const from = url.searchParams.get("from") || "";
       const to = url.searchParams.get("to") || "";
       const rows = readQueueData(qp);