tokentracker-cli 0.95.0 → 0.95.2

package/src/lib/rollout.js

@@ -5761,6 +5761,384 @@ async function parseQoderDbIncremental({
   return { messagesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
 }
 
+// ── Qoder (new) — ~/.qoder/projects JSONL (com.qoder.app.stable, 2026-08+) ──
+//
+// Qoder 2026-08 (app 0.1.2+) migrated from SharedClientCache/cache/db/local.db
+// to Electron main.sqlite + ~/.qoder/projects/<slug>/<sessionId>.jsonl.
+// The new transcript's message.usage no longer carries prompt_tokens — it is a
+// credit-billed SDK: {input_tokens:0, output_tokens:0, credits:3.2, billable:true}.
+// Only rows with authoritative token fields are counted: credit-only usage
+// without tokens is intentionally not counted (usage stays unsupported, no
+// token delta) because there is no first-party evidence for a credit→token
+// rate. Cost was never estimated — no authoritative credit→USD rate is
+// published, so total_cost_usd stays 0.
+// Old local.db is kept as a legacy fallback; both sources now use distinct
+// cursor namespaces (qoder vs qoderNew) via disjoint messageKey prefixes
+// (row: vs jsonl:) but upload under the same source="qoder".
+
+function resolveQoderProjectsDir({ home = os.homedir(), env = process.env, platform = process.platform, deps = {} } = {}) {
+  const override = typeof env.QODER_PROJECTS_DIR === "string" && env.QODER_PROJECTS_DIR.trim()
+    ? path.resolve(env.QODER_PROJECTS_DIR.trim())
+    : null;
+  if (override) return override;
+  // QODER_HOME points at the app support dir for the legacy DB; the new
+  // projects dir is always ~/.qoder regardless of QODER_HOME.
+  // On Windows also probe WSL distro home (same pattern as other providers).
+  if (platform === "win32" && !env.QODER_PROJECTS_DIR) {
+    const discoverWslHome = deps.discoverWslHome || wsl.discoverWslHome;
+    const wslRoot = wsl.shouldProbeWsl(env) ? discoverWslHome(".qoder", { ...deps, env }) : null;
+    if (wslRoot) {
+      const wslProjects = path.join(wslRoot, "projects");
+      if ((deps.existsSync || fssync.existsSync)(wslProjects)) return wslProjects;
+    }
+  }
+  return path.join(home, ".qoder", "projects");
+}
+
+function resolveQoderCnProjectsDir({ home = os.homedir(), env = process.env, platform = process.platform, deps = {} } = {}) {
+  const override = typeof env.QODER_CN_PROJECTS_DIR === "string" && env.QODER_CN_PROJECTS_DIR.trim()
+    ? path.resolve(env.QODER_CN_PROJECTS_DIR.trim())
+    : null;
+  if (override) return override;
+  // CN and international currently share ~/.qoder; keep a distinct override for
+  // future split without double-counting by default.
+  if (platform === "win32" && !env.QODER_CN_PROJECTS_DIR) {
+    const discoverWslHome = deps.discoverWslHome || wsl.discoverWslHome;
+    const wslRoot = wsl.shouldProbeWsl(env) ? discoverWslHome(".qoder", { ...deps, env }) : null;
+    if (wslRoot) {
+      const wslProjects = path.join(wslRoot, "projects");
+      if ((deps.existsSync || fssync.existsSync)(wslProjects)) return wslProjects;
+    }
+  }
+  return path.join(home, ".qoder", "projects");
+}
+
+async function listQoderNewSessionFiles(projectsDir) {
+  const out = [];
+  if (!projectsDir || !fssync.existsSync(projectsDir)) return out;
+  async function walk(dir) {
+    const entries = await safeReadDir(dir);
+    for (const e of entries) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        await walk(p);
+      } else if (e.isFile() && e.name.endsWith(".jsonl")) {
+        out.push(p);
+      }
+    }
+  }
+  await walk(projectsDir);
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
+function qoderNewModelFromRecord(record) {
+  const msgModel = record?.message?.model;
+  const direct = typeof msgModel === "string" ? msgModel.trim() : "";
+  return normalizeModelInput(direct) || "qoder-agent";
+}
+
+function qoderNewMessageKey(record, filePath, lineIndex = 0) {
+  const msgId = normalizeMessageKeyPart(record?.message?.id)
+    || normalizeMessageKeyPart(record?.uuid)
+    || normalizeMessageKeyPart(record?.id)
+    || null;
+  const sessionId = normalizeMessageKeyPart(record?.sessionId || record?.session_id);
+  // Prefix to avoid collision with legacy row: keys; fallback includes line index
+  // so multiple no-id records in the same file remain distinct.
+  const fallbackSuffix = Number.isFinite(lineIndex) ? `${filePath}:${lineIndex}` : filePath;
+  if (sessionId && msgId) return `jsonl:${sessionId}|${msgId}`;
+  if (msgId) return `jsonl:${msgId}`;
+  if (sessionId) return `jsonl:${sessionId}|${record?.uuid || fallbackSuffix}`;
+  return `jsonl:${fallbackSuffix}|${record?.uuid || ""}`;
+}
+
+function qoderNewTimestampMs(record) {
+  return coerceEpochMs(record?.timestamp)
+    || coerceEpochMs(record?.message?.timestamp)
+    || parseIsoTimestampMs(record?.timestamp)
+    || parseIsoTimestampMs(record?.message?.timestamp)
+    || 0;
+}
+
+function normalizeQoderNewTokens(usage) {
+  if (!usage || typeof usage !== "object") return null;
+  const credits = Number(usage.credits ?? usage.original_credits ?? 0);
+  let input = Number(usage.input_tokens ?? 0);
+  let cached = Number(usage.cache_read_input_tokens ?? usage.cached_tokens ?? 0);
+  let cacheCreation = Number(usage.cache_creation_input_tokens ?? 0);
+  let output = Number(usage.output_tokens ?? 0);
+  // Guard against malformed numbers (NaN/Infinity/negative) — align with
+  // legacy normalizeQoderTokens which returns null on such input.
+  if (!Number.isFinite(input) || input < 0) input = 0;
+  if (!Number.isFinite(cached) || cached < 0) cached = 0;
+  if (!Number.isFinite(cacheCreation) || cacheCreation < 0) cacheCreation = 0;
+  if (!Number.isFinite(output) || output < 0) output = 0;
+  // Only rows with authoritative token fields are counted; anything else
+  // falls through to null (unsupported, no token delta).
+  if (input > 0 || cached > 0 || cacheCreation > 0 || output > 0) {
+    const inp = Math.max(0, Math.trunc(input));
+    const cach = Math.max(0, Math.trunc(cached));
+    const out = Math.max(0, Math.trunc(output));
+    const cc = Math.max(0, Math.trunc(cacheCreation));
+    return {
+      input_tokens: inp,
+      cached_input_tokens: cach,
+      cache_creation_input_tokens: cc,
+      output_tokens: out,
+      reasoning_output_tokens: 0,
+      total_tokens: inp + cach + cc + out,
+      billable_total_tokens: inp + cach + cc + out,
+      credits: Number.isFinite(credits) && credits > 0 ? credits : 0,
+      usage_precision: null,
+    };
+  }
+  // Credit-only usage without authoritative token fields is intentionally
+  // not counted (no token delta): there is no first-party evidence for a
+  // credit→token rate. The caller still counts billable messages as
+  // conversation activity.
+  return null;
+}
+
+async function parseQoderNewIncremental({
+  sessionFiles,
+  cursors,
+  queuePath,
+  projectQueuePath,
+  onProgress,
+  sourceKey = "qoder",
+  cursorKey = "qoderNew",
+  publicRepoResolver,
+} = {}) {
+  await ensureDir(path.dirname(queuePath));
+  const files = Array.isArray(sessionFiles) ? sessionFiles : [];
+  // One-time migration: pre-#549 stored JSONL keys under the legacy "qoder"
+  // cursor (same namespace as SQLite). Move them to the new isolated namespace
+  // so history is not double-counted and legacy multi-install state is preserved.
+  if (cursorKey === "qoderNew" && cursors?.qoder && !cursors?.qoderNew) {
+    const legacy = normalizeQoderState(cursors.qoder);
+    const jsonlEntries = Object.entries(legacy.messages).filter(([k]) => k.startsWith("jsonl:"));
+    if (jsonlEntries.length > 0) {
+      const migrated = {};
+      for (const [k, v] of jsonlEntries) {
+        migrated[k] = v;
+        delete legacy.messages[k];
+      }
+      cursors.qoderNew = { messages: migrated, updatedAt: legacy.updatedAt || new Date().toISOString() };
+    }
+  }
+  if (cursorKey === "qoderCnNew" && cursors?.["qoder-cn"] && !cursors?.["qoderCnNew"]) {
+    const legacy = normalizeQoderState(cursors["qoder-cn"]);
+    const jsonlEntries = Object.entries(legacy.messages).filter(([k]) => k.startsWith("jsonl:"));
+    if (jsonlEntries.length > 0) {
+      const migrated = {};
+      for (const [k, v] of jsonlEntries) {
+        migrated[k] = v;
+        delete legacy.messages[k];
+      }
+      cursors["qoderCnNew"] = { messages: migrated, updatedAt: legacy.updatedAt || new Date().toISOString() };
+    }
+  }
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const qoderState = normalizeQoderState(cursors?.[cursorKey]);
+  const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
+  const projectState = projectEnabled ? normalizeProjectState(cursors?.projectHourly) : null;
+  const projectTouchedBuckets = projectEnabled ? new Set() : null;
+  const projectMetaCache = projectEnabled ? new Map() : null;
+  const publicRepoCache = projectEnabled ? new Map() : null;
+  const touchedBuckets = new Set();
+  const cb = typeof onProgress === "function" ? onProgress : null;
+
+  // Build current snapshot from all JSONL files
+  const currentByKey = new Map();
+  const fileCount = files.length;
+  for (let fileIdx = 0; fileIdx < files.length; fileIdx++) {
+    const filePath = files[fileIdx];
+    let raw;
+    try {
+      raw = await fs.readFile(filePath, "utf8");
+    } catch (_e) {
+      continue;
+    }
+    const lines = raw.split("\n");
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+      const line = lines[lineIdx];
+      if (!line.trim()) continue;
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch (_e) {
+        continue;
+      }
+      if (record?.type !== "assistant") continue;
+      const msg = record?.message;
+      if (!msg || msg.role !== "assistant") continue;
+      // Skip synthetic sub-agent streaming chunks that carry no usage
+      const usage = msg.usage;
+      if (!usage || typeof usage !== "object") continue;
+      const base = normalizeQoderNewTokens(usage);
+      // Allow billable zero-token messages to still count conversation (no token delta)
+      const isBillable = usage.billable !== false;
+      if (!base && !isBillable) continue;
+      const timestampMs = qoderNewTimestampMs(record);
+      if (!timestampMs) continue;
+      const bucketStart = toUtcHalfHourStart(new Date(timestampMs).toISOString());
+      if (!bucketStart) continue;
+      const messageKey = qoderNewMessageKey(record, filePath, lineIdx);
+      if (!messageKey) continue;
+      const model = qoderNewModelFromRecord(record);
+      const totals = base ? {
+        input_tokens: base.input_tokens,
+        cached_input_tokens: base.cached_input_tokens,
+        cache_creation_input_tokens: base.cache_creation_input_tokens,
+        output_tokens: base.output_tokens,
+        reasoning_output_tokens: 0,
+        total_tokens: base.total_tokens,
+        billable_total_tokens: base.billable_total_tokens,
+        total_cost_usd: 0,
+        usage_precision: base.usage_precision || undefined,
+        conversation_count: 1,
+      } : {
+        input_tokens: 0,
+        cached_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        output_tokens: 0,
+        reasoning_output_tokens: 0,
+        total_tokens: 0,
+        billable_total_tokens: 0,
+        total_cost_usd: 0,
+        conversation_count: 1,
+      };
+      let projectKey = null;
+      let projectRef = null;
+      if (projectEnabled) {
+        const rawCwd = typeof record?.cwd === "string" ? record.cwd.trim() : "";
+        if (rawCwd) {
+          const startDir = wsl.mapWslCwdToUnc(rawCwd, filePath);
+          const context = await resolveProjectContextForPath({
+            startDir,
+            projectMetaCache,
+            publicRepoCache,
+            publicRepoResolver,
+            projectState,
+          });
+          projectKey = context?.projectKey || null;
+          projectRef = context?.projectRef || null;
+        }
+      }
+      currentByKey.set(messageKey, {
+        totals,
+        bucketStart,
+        model,
+        projectKey,
+        projectRef,
+        filePath,
+      });
+    }
+    if (cb && (fileIdx % 50 === 0 || fileIdx === files.length - 1)) {
+      cb({
+        index: fileIdx + 1,
+        total: fileCount,
+        messagesProcessed: currentByKey.size,
+        eventsAggregated: 0,
+        bucketsQueued: 0,
+      });
+    }
+  }
+
+  let messagesProcessed = currentByKey.size;
+  let eventsAggregated = 0;
+
+  // Subtract contributions that disappeared or changed
+  for (const [key, prev] of Object.entries(qoderState.messages)) {
+    if (!key.startsWith("jsonl:")) continue;
+    const cur = currentByKey.get(key);
+    const unchanged = cur
+      && totalsKey(prev.totals) === totalsKey(cur.totals)
+      && prev.bucketStart === cur.bucketStart
+      && prev.model === cur.model
+      && (prev.projectKey || null) === (cur.projectKey || null)
+      && (prev.totals?.total_cost_usd || 0) === (cur.totals.total_cost_usd || 0);
+    if (unchanged) continue;
+    if (prev.totals && prev.bucketStart && prev.model) {
+      const oldBucket = getHourlyBucket(hourlyState, sourceKey, prev.model, prev.bucketStart);
+      subtractTotals(oldBucket.totals, prev.totals);
+      touchedBuckets.add(bucketKey(sourceKey, prev.model, prev.bucketStart));
+      if (projectEnabled && prev.projectKey) {
+        const oldProjectBucket = getProjectBucket(projectState, prev.projectKey, sourceKey, prev.bucketStart, prev.projectRef || null);
+        subtractTotals(oldProjectBucket.totals, prev.totals);
+        projectTouchedBuckets.add(projectBucketKey(prev.projectKey, sourceKey, prev.bucketStart));
+      }
+    }
+    if (cur) {
+      const bucket = getHourlyBucket(hourlyState, sourceKey, cur.model, cur.bucketStart);
+      addTotals(bucket.totals, cur.totals);
+      if (cur.totals.usage_precision) bucket.usage_precision = cur.totals.usage_precision;
+      // addTotals handles total_cost_usd via USD_TICKS, but credits cost is small; ensure it accumulates
+      touchedBuckets.add(bucketKey(sourceKey, cur.model, cur.bucketStart));
+      if (projectEnabled && cur.projectKey) {
+        const projectBucket = getProjectBucket(projectState, cur.projectKey, sourceKey, cur.bucketStart, cur.projectRef);
+        addTotals(projectBucket.totals, cur.totals);
+        if (cur.totals.usage_precision) projectBucket.usage_precision = cur.totals.usage_precision;
+        projectTouchedBuckets.add(projectBucketKey(cur.projectKey, sourceKey, cur.bucketStart));
+      }
+      qoderState.messages[key] = {
+        totals: cur.totals,
+        conversationCount: cur.totals.conversation_count,
+        bucketStart: cur.bucketStart,
+        model: cur.model,
+        projectKey: cur.projectKey,
+        projectRef: cur.projectRef,
+        updatedAt: new Date().toISOString(),
+      };
+      eventsAggregated += 1;
+    } else {
+      delete qoderState.messages[key];
+      eventsAggregated += 1;
+    }
+  }
+
+  // Add brand-new keys
+  for (const [key, cur] of currentByKey.entries()) {
+    if (qoderState.messages[key]) continue;
+    const bucket = getHourlyBucket(hourlyState, sourceKey, cur.model, cur.bucketStart);
+    addTotals(bucket.totals, cur.totals);
+    if (cur.totals.usage_precision) bucket.usage_precision = cur.totals.usage_precision;
+    touchedBuckets.add(bucketKey(sourceKey, cur.model, cur.bucketStart));
+    if (projectEnabled && cur.projectKey) {
+      const projectBucket = getProjectBucket(projectState, cur.projectKey, sourceKey, cur.bucketStart, cur.projectRef);
+      addTotals(projectBucket.totals, cur.totals);
+      if (cur.totals.usage_precision) projectBucket.usage_precision = cur.totals.usage_precision;
+      projectTouchedBuckets.add(projectBucketKey(cur.projectKey, sourceKey, cur.bucketStart));
+    }
+    qoderState.messages[key] = {
+      totals: cur.totals,
+      conversationCount: cur.totals.conversation_count,
+      bucketStart: cur.bucketStart,
+      model: cur.model,
+      projectKey: cur.projectKey,
+      projectRef: cur.projectRef,
+      updatedAt: new Date().toISOString(),
+    };
+    eventsAggregated += 1;
+  }
+
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const projectBucketsQueued = projectEnabled
+    ? await enqueueTouchedProjectBuckets({ projectQueuePath, projectState, projectTouchedBuckets })
+    : 0;
+  const updatedAt = new Date().toISOString();
+  hourlyState.updatedAt = updatedAt;
+  qoderState.updatedAt = updatedAt;
+  cursors.hourly = hourlyState;
+  cursors[cursorKey] = qoderState;
+  if (projectState) {
+    projectState.updatedAt = updatedAt;
+    cursors.projectHourly = projectState;
+  }
+  return { messagesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
+}
+
 // ── Claude Science (Anthropic's local research workbench, issue #246) ──
 //
 // Claude Science keeps all of its state in a SQLite database named
@@ -19864,6 +20242,10 @@ module.exports = {
   resolveQoderDbPaths,
   resolveQoderCnDbPaths,
   readQoderDbMessages,
+  resolveQoderProjectsDir,
+  resolveQoderCnProjectsDir,
+  listQoderNewSessionFiles,
+  parseQoderNewIncremental,
   resolveKiroBasePath,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
@@ -20007,6 +20389,7 @@ module.exports = {
   normalizeGeminiTokens,
   normalizeOpencodeTokens,
   normalizeQoderTokens,
+  normalizeQoderNewTokens,
   sameGeminiTotals,
   diffGeminiTotals,
   // Exposed so the queue-repair migration can mutate cursors state in the

package/dashboard/dist/assets/DialogDescription-DDM4aanX.js

@@ -1 +0,0 @@
-import{r as n,z as a}from"./__vite-browser-external-Dnxl50k1.js";import{u as p}from"./DialogTitle-BiRcejlu.js";import{u as c}from"./composite-C79LNbex.js";const x=n.forwardRef(function(e,r){const{render:l,className:u,style:m,id:s,...t}=e,i=p(),o=c(s);return i.useSyncedValueWithCleanup("descriptionElementId",o),a("p",e,{ref:r,props:[{id:o},t]})});export{x as D};

package/dashboard/dist/assets/use-reduced-motion-AQE0ummK.js

@@ -1 +0,0 @@
-import{r as o}from"./__vite-browser-external-Dnxl50k1.js";import{h as r,i as t,p as s}from"./react-D2AD6Pk2.js";function i(){!r.current&&t();const[e]=o.useState(s.current);return e}export{i as u};