tokentracker-cli 1.4.10 → 1.4.12

package/src/lib/rollout.js

@@ -14107,6 +14107,279 @@ async function parseLmstudioIncremental({
   return { recordsProcessed, eventsAggregated, bucketsQueued };
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// OpenSquilla
+//
+// Read only the finalized usage ledger's model rows. Transcript entries and
+// message content are not needed for token attribution and are never selected.
+// ─────────────────────────────────────────────────────────────────────────────
+
+const OPENSQUILLA_SOURCE = "opensquilla";
+
+function resolveOpenSquillaPath(value, home) {
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (!raw) return null;
+  if (raw === "~") return path.resolve(home);
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return path.resolve(home, raw.slice(2));
+  }
+  return path.resolve(raw);
+}
+
+function resolveOpenSquillaDbPaths(env = process.env, deps = {}) {
+  const home = deps.home || env.HOME || env.USERPROFILE || os.homedir();
+  const platform = deps.platform || process.platform;
+  const dbOverride = resolveOpenSquillaPath(env.TOKENTRACKER_OPENSQUILLA_DB, home);
+  if (dbOverride) return [dbOverride];
+
+  const gatewayStateDir = resolveOpenSquillaPath(env.OPENSQUILLA_GATEWAY_STATE_DIR, home);
+  if (gatewayStateDir) return [path.join(gatewayStateDir, "sessions.db")];
+
+  const stateHome = resolveOpenSquillaPath(env.OPENSQUILLA_STATE_DIR, home);
+  if (stateHome) return [path.join(stateHome, "state", "sessions.db")];
+
+  const profileHomeOverride = typeof env.OPENSQUILLA_HOME === "string"
+    ? env.OPENSQUILLA_HOME.trim()
+    : "";
+  const profileOverride = typeof env.OPENSQUILLA_PROFILE === "string"
+    ? env.OPENSQUILLA_PROFILE.trim()
+    : "";
+  if (profileHomeOverride || profileOverride) {
+    const profilesRoot = resolveOpenSquillaPath(
+      profileHomeOverride || path.join(home, ".opensquilla", "profiles"),
+      home,
+    );
+    const profile = profileOverride || "default";
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(profile)) return [];
+    return [path.join(profilesRoot, profile, "state", "sessions.db")];
+  }
+
+  const paths = [path.join(home, ".opensquilla", "state", "sessions.db")];
+  let userDataRoot;
+  if (platform === "win32") {
+    userDataRoot = env.APPDATA || path.join(home, "AppData", "Roaming");
+  } else if (platform === "darwin") {
+    userDataRoot = path.join(home, "Library", "Application Support");
+  } else {
+    userDataRoot = env.XDG_CONFIG_HOME || path.join(home, ".config");
+  }
+  paths.unshift(path.join(
+    userDataRoot,
+    "@opensquilla",
+    "desktop-electron",
+    "opensquilla",
+    "state",
+    "sessions.db",
+  ));
+
+  const seen = new Set();
+  return paths.filter((dbPath) => {
+    const resolved = path.resolve(dbPath);
+    const key = platform === "win32" ? resolved.toLowerCase() : resolved;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+async function readOpenSquillaUsageRows(dbPath, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return [];
+  const options = {
+    label: "OpenSquilla",
+    maxBuffer: 32 * 1024 * 1024,
+    timeout: 30_000,
+    ...sqliteOptions,
+    readOnly: true,
+    throwOnReadFailure: true,
+  };
+  const tables = new Set(
+    (await readSqliteJsonRowsAsync(
+      dbPath,
+      "SELECT name FROM sqlite_master WHERE type='table' AND name IN ('usage_events','usage_event_items')",
+      options,
+    )).map((row) => row?.name).filter(Boolean),
+  );
+  if (!tables.has("usage_events") || !tables.has("usage_event_items")) return [];
+  const sql = [
+    "SELECT e.event_id, e.completed_at_ms, i.ordinal,",
+    "COALESCE(i.model, e.model) AS model, i.input_tokens, i.output_tokens,",
+    "i.reasoning_tokens, i.cache_read_tokens, i.cache_write_tokens, i.total_tokens",
+    "FROM usage_events AS e",
+    "JOIN usage_event_items AS i ON i.event_id = e.event_id",
+    "WHERE e.status = 'finalized' AND e.completed_at_ms IS NOT NULL",
+    "ORDER BY e.completed_at_ms, e.event_id, i.ordinal",
+  ].join(" ");
+  return readSqliteJsonRowsAsync(dbPath, sql, options);
+}
+
+function normalizeOpenSquillaUsageRow(row) {
+  const eventId = typeof row?.event_id === "string" ? row.event_id.trim() : "";
+  if (!eventId || row?.ordinal == null) return null;
+
+  // OpenSquilla stores input as a cache-inclusive total and reasoning as an
+  // output subset; normalize both before writing TokenTracker queue rows.
+  const totals = normalizeLocalStudioTokens({
+    input_tokens: row.input_tokens,
+    output_tokens: row.output_tokens,
+    reasoning_tokens: row.reasoning_tokens,
+    cached_tokens: row.cache_read_tokens,
+    cache_creation_input_tokens: row.cache_write_tokens,
+    total_tokens: row.total_tokens,
+  });
+  const timestampMs = coerceEpochMs(row.completed_at_ms);
+  const bucketStart = timestampMs
+    ? toUtcHalfHourStart(new Date(timestampMs).toISOString())
+    : null;
+  if (!totals || !bucketStart) return null;
+
+  return {
+    key: "opensquilla:" + eventId + ":" + String(toNonNegativeInt(row.ordinal)),
+    model: normalizeModelInput(row.model) || DEFAULT_MODEL,
+    bucketStart,
+    totals,
+  };
+}
+
+async function parseOpenSquillaIncremental({
+  dbPaths,
+  cursors,
+  queuePath,
+  onProgress,
+  env,
+  sqliteOptions,
+} = {}) {
+  await ensureDir(path.dirname(queuePath));
+  const priorState = cursors.opensquilla && typeof cursors.opensquilla === "object"
+    ? cursors.opensquilla
+    : {};
+  // Copy before mutate so a failed queue append leaves committed cursors intact.
+  const messages = priorState.messages && typeof priorState.messages === "object"
+    ? { ...priorState.messages }
+    : {};
+  const fingerprints = priorState.fingerprints && typeof priorState.fingerprints === "object"
+    ? { ...priorState.fingerprints }
+    : {};
+  const requestedPaths = Array.isArray(dbPaths) && dbPaths.length
+    ? dbPaths
+    : resolveOpenSquillaDbPaths(env || process.env);
+  const seenPaths = new Set();
+  const availablePaths = requestedPaths.filter((dbPath) => {
+    if (typeof dbPath !== "string" || !dbPath.trim() || !fssync.existsSync(dbPath)) return false;
+    const resolved = path.resolve(dbPath);
+    const key = process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    if (seenPaths.has(key)) return false;
+    seenPaths.add(key);
+    return true;
+  });
+  // No currently readable DB is treated as temporary unavailability — keep
+  // prior observations rather than wiping totals.
+  if (availablePaths.length === 0) {
+    cursors.opensquilla = { ...priorState, messages, fingerprints, updatedAt: new Date().toISOString() };
+    return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+  }
+
+  const pathFingerprints = new Map();
+  let databaseChanged = false;
+  const currentPathKeys = new Set();
+  for (const dbPath of availablePaths) {
+    const key = path.resolve(dbPath);
+    currentPathKeys.add(key);
+    const fingerprint = sqliteSidecarFingerprint(dbPath);
+    pathFingerprints.set(key, fingerprint);
+    if (!fingerprints[key] || !sameSqliteFingerprint(fingerprint, fingerprints[key])) {
+      databaseChanged = true;
+    }
+  }
+  // A removed Desktop/CLI DB must also trigger reconciliation so orphaned
+  // observations can be retracted (fingerprint-only checks would miss this).
+  for (const key of Object.keys(fingerprints)) {
+    if (!currentPathKeys.has(key)) {
+      databaseChanged = true;
+      break;
+    }
+  }
+  if (!databaseChanged) {
+    return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+  }
+
+  // The Desktop profile is first in the default path list. If a migrated CLI
+  // profile retains the same event IDs, prefer the active Desktop copy and
+  // count each model row only once.
+  const rowsByEventItem = new Map();
+  for (const dbPath of availablePaths) {
+    const dbRows = await readOpenSquillaUsageRows(dbPath, sqliteOptions);
+    for (const row of dbRows) {
+      const eventId = typeof row?.event_id === "string" ? row.event_id.trim() : "";
+      if (!eventId || row?.ordinal == null) continue;
+      const key = eventId + ":" + String(toNonNegativeInt(row.ordinal));
+      if (!rowsByEventItem.has(key)) rowsByEventItem.set(key, row);
+    }
+  }
+  const rows = Array.from(rowsByEventItem.values());
+  // structuredClone so a failed enqueueTouchedBuckets cannot leave mutated
+  // totals committed while opensquilla.messages stays unchanged (retry would
+  // subtract again). Same pattern as TRAE / session reconcilers.
+  const hourlyState = structuredClone(normalizeHourlyState(cursors?.hourly));
+  const touchedBuckets = new Set();
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  let eventsAggregated = 0;
+  const currentKeys = new Set();
+  for (let index = 0; index < rows.length; index++) {
+    const event = normalizeOpenSquillaUsageRow(rows[index]);
+    if (event) currentKeys.add(event.key);
+    if (event && reconcilePassiveUsageEvent({
+      event,
+      source: OPENSQUILLA_SOURCE,
+      messages,
+      hourlyState,
+      touchedBuckets,
+    })) eventsAggregated += 1;
+    if (cb) {
+      cb({
+        index: index + 1,
+        total: rows.length,
+        recordsProcessed: index + 1,
+        eventsAggregated,
+        bucketsQueued: touchedBuckets.size,
+      });
+    }
+  }
+
+  // Retract observations that disappeared with a removed database (or were
+  // deleted from the remaining DB). Overlapping event IDs keep Desktop-first
+  // totals via reconcilePassiveUsageEvent above.
+  for (const key of Object.keys(messages)) {
+    if (!key.startsWith("opensquilla:") || currentKeys.has(key)) continue;
+    const previous = messages[key];
+    if (previous?.model && previous?.bucketStart && previous?.totals) {
+      const oldBucket = getHourlyBucket(
+        hourlyState,
+        OPENSQUILLA_SOURCE,
+        previous.model,
+        previous.bucketStart,
+      );
+      subtractTotals(oldBucket.totals, previous.totals);
+      touchedBuckets.add(bucketKey(OPENSQUILLA_SOURCE, previous.model, previous.bucketStart));
+    }
+    delete messages[key];
+    eventsAggregated += 1;
+  }
+
+  const nextFingerprints = {};
+  for (const dbPath of availablePaths) {
+    const key = path.resolve(dbPath);
+    const before = pathFingerprints.get(key);
+    const after = sqliteSidecarFingerprint(dbPath);
+    nextFingerprints[key] = sameSqliteFingerprint(before, after) ? after : before;
+  }
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const updatedAt = new Date().toISOString();
+  hourlyState.updatedAt = updatedAt;
+  cursors.hourly = hourlyState;
+  cursors.opensquilla = { messages, fingerprints: nextFingerprints, updatedAt };
+  return { recordsProcessed: rows.length, eventsAggregated, bucketsQueued };
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Unsloth Studio
 //
@@ -25865,6 +26138,10 @@ module.exports = {
   normalizeLocalStudioTokens,
   readLmstudioFileRecords,
   parseLmstudioIncremental,
+  resolveOpenSquillaDbPaths,
+  readOpenSquillaUsageRows,
+  normalizeOpenSquillaUsageRow,
+  parseOpenSquillaIncremental,
   resolveUnslothDbPath,
   readUnslothUsageRows,
   normalizeUnslothUsageRow,

package/src/lib/session-analytics.js

@@ -38,6 +38,7 @@ const { readCursorStateSummary } = require("./cursor-store");
 const { USD_TICKS_PER_USD, normalizeGrokUsage } = require("./grok-usage");
 const wsl = require("./wsl-probe");
 const { discoverKimiWireFiles, kimiSessionDependencies, readKimiSessions } = require("./kimi-session");
+const { discoverOmpSessionFiles, ompSessionDependencies, readOmpSessions } = require("./omp-session");
 const {
   appendUniqueDirs,
   dedupeDirsByRealpath,
@@ -89,7 +90,8 @@ const {
 // v25 adds Kimi wire sessions, including official/legacy migration dedup.
 // v26 retains Codex Ultrafast (service_tier ultrafast) subset columns so
 // date-filtered session views and cached sidecars keep the 6x premium.
-const SIDECAR_VERSION = 26;
+// v27 adds oh-my-pi (omp) sessions from ~/.omp/agent/sessions/**/*.jsonl.
+const SIDECAR_VERSION = 27;
 const EDIT_TOOLS = new Set([
   "apply_patch",
   "edit",
@@ -1948,6 +1950,26 @@ async function scanKimiSessions(filePaths) {
   }));
 }
 
+async function scanOmpSessions(filePaths) {
+  // Batch the whole OMP inventory so fork copies that reuse entry ids are
+  // counted once across sessions (same contract as the hourly seenIds set).
+  const rows = await readOmpSessions(Array.isArray(filePaths) ? filePaths : [filePaths]);
+  return rows.map(({ identity, files, title, ...row }) => finalizeRecord({
+    ...row,
+    title: cleanSessionTitle(title),
+    version: SIDECAR_VERSION,
+    source: "omp",
+    session_hash: sessionHash("omp", identity),
+    project_key: projectKey(row.project_ref, files[0]),
+    ...sessionStorageUsage(files),
+  }));
+}
+
+async function scanOmpSession(filePath) {
+  const rows = await scanOmpSessions([filePath]);
+  return rows[0] || null;
+}
+
 async function discoverSessionFiles(home, env = process.env, deps = {}) {
   const grokHome = resolveGrokHome(home);
   // config.scanRoots (#657): read from the tracker config unless the caller
@@ -2040,7 +2062,12 @@ async function discoverSessionFiles(home, env = process.env, deps = {}) {
     return roots;
   });
   const kimi = discoverKimiWireFiles(dedupeDirsByRealpath(kimiRoots), incomplete);
-  return { claude, codex: groupCodexFiles([...codex, ...archived]), grok, zcode, opencode, kimi, incomplete };
+  const usingMachineHome = path.resolve(home) === path.resolve((deps.homedir || os.homedir)());
+  const ompEnv = usingMachineHome
+    ? { ...env, HOME: home }
+    : { HOME: home, OMP_HOME: path.join(home, ".omp") };
+  const omp = discoverOmpSessionFiles(ompEnv, incomplete);
+  return { claude, codex: groupCodexFiles([...codex, ...archived]), grok, zcode, opencode, kimi, omp, incomplete };
 }
 
 // Warn once per unreadable directory per process: the dashboard polls this
@@ -2144,6 +2171,9 @@ function analyticsEntryStatKey(source, filePath) {
   if (source === "kimi") {
     return `${sessionStat}|metadata:${filesSignature(kimiSessionDependencies(filePaths))}`;
   }
+  if (source === "omp") {
+    return `${sessionStat}|metadata:${filesSignature(ompSessionDependencies([filePaths].flat()))}`;
+  }
   if (source === "grok") {
     const primary = filePaths[0];
     return `${sessionStat}|summary:${sessionFileStatKey(grokSummaryPathFor(primary)) || "missing"}|signals:${sessionFileStatKey(grokSignalsPathFor(primary)) || "missing"}`;
@@ -2185,13 +2215,15 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
   const retryOpencodeScan = fs.existsSync(incompleteOpencodePath);
   const incompleteKimiPath = `${metaPath}.kimi-incomplete`;
   const retryKimiScan = fs.existsSync(incompleteKimiPath);
+  const incompleteOmpPath = `${metaPath}.omp-incomplete`;
+  const retryOmpScan = fs.existsSync(incompleteOmpPath);
   let previousMeta = null;
   if (!force) {
     try {
       previousMeta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
       const checkedAt = Date.parse(previousMeta.checked_at || previousMeta.generated_at || "");
       if (
-        !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && previousMeta.version === SIDECAR_VERSION &&
+        !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && !retryOmpScan && previousMeta.version === SIDECAR_VERSION &&
         Number.isFinite(checkedAt) &&
         Date.now() - checkedAt < Math.max(0, Number(cacheTtlMs) || 0)
       ) {
@@ -2223,13 +2255,15 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     ...discovered.codex.flat().map(codexTitleIndexPathFor).filter(Boolean),
     ...discovered.kimi,
     ...kimiSessionDependencies(discovered.kimi),
+    ...discovered.omp,
+    ...ompSessionDependencies(discovered.omp),
     ...discovered.grok,
     ...discovered.grok.map(grokSummaryPathFor),
     ...discovered.grok.map(grokSignalsPathFor),
     // db + its WAL sidecars: the trio is one logical file for change detection.
     ...[...(discovered.zcode || []), ...(discovered.opencode || [])].flatMap((dbPath) => [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]),
   ]);
-  if (!force && !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && previousMeta?.version === SIDECAR_VERSION && previousMeta.signature === signature) {
+  if (!force && !retryZcodeScan && !retryOpencodeScan && !retryKimiScan && !retryOmpScan && previousMeta?.version === SIDECAR_VERSION && previousMeta.signature === signature) {
     await writeAtomic(metaPath, `${JSON.stringify({ ...previousMeta, checked_at: new Date().toISOString() })}\n`);
     return readSidecar(sidecarPath);
   }
@@ -2252,6 +2286,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     ...(discovered.zcode.length ? [{ source: "zcode", filePath: discovered.zcode, scan: scanZcodeSessions }] : []),
     ...(discovered.opencode.length ? [{ source: "opencode", filePath: discovered.opencode, scan: scanOpencodeSessions }] : []),
     ...(discovered.kimi.length ? [{ source: "kimi", filePath: discovered.kimi, scan: scanKimiSessions }] : []),
+    ...(discovered.omp.length ? [{ source: "omp", filePath: discovered.omp, scan: scanOmpSessions }] : []),
   ];
   // Files we could not turn into a row (permission denied, half-written line,
   // vanished mid-scan). Swallowing these silently made sessions disappear with
@@ -2260,6 +2295,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
   let incompleteZcodeScan = false;
   let incompleteOpencodeScan = false;
   let incompleteKimiScan = false;
+  let incompleteOmpScan = false;
   for (const entry of entries) {
     const cacheKey = sessionFileCacheKey(entry.source, entry.filePath);
     const statKey = analyticsEntryStatKey(entry.source, entry.filePath);
@@ -2268,11 +2304,12 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
       if (entry.source === "zcode") incompleteZcodeScan = true;
       if (entry.source === "opencode") incompleteOpencodeScan = true;
       if (entry.source === "kimi") incompleteKimiScan = true;
+      if (entry.source === "omp") incompleteOmpScan = true;
       continue;
     }
     let rows = null;
-    if (!force && !(entry.source === "zcode" && retryZcodeScan) && !(entry.source === "opencode" && retryOpencodeScan) && !(entry.source === "kimi" && retryKimiScan) && previousFiles[cacheKey]?.stat_key === statKey) {
-      if (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi") {
+    if (!force && !(entry.source === "zcode" && retryZcodeScan) && !(entry.source === "opencode" && retryOpencodeScan) && !(entry.source === "kimi" && retryKimiScan) && !(entry.source === "omp" && retryOmpScan) && previousFiles[cacheKey]?.stat_key === statKey) {
+      if (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi" || entry.source === "omp") {
         // One db scans to many cached rows; recover them all from the previous
         // pass. An empty recovery means the sidecar lost its rows — rescan.
         const cached = previousRows.filter((row) => row?.source === entry.source);
@@ -2293,6 +2330,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
         if (entry.source === "zcode") incompleteZcodeScan = true;
         if (entry.source === "opencode") incompleteOpencodeScan = true;
         if (entry.source === "kimi") incompleteKimiScan = true;
+        if (entry.source === "omp") incompleteOmpScan = true;
         if (!process.env.NODE_TEST_CONTEXT) {
           console.warn(`[session-analytics] skipped ${entry.source} session file: ${error?.message || error}`);
         }
@@ -2306,7 +2344,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
       // so key each by the db path plus its session id; a bare session id as a
       // separate path element would be path.resolve()d against the process cwd
       // and never match across runs.
-      row._cache_key = (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi") && (row.session_id || row.session_hash)
+      row._cache_key = (entry.source === "zcode" || entry.source === "opencode" || entry.source === "kimi" || entry.source === "omp") && (row.session_id || row.session_hash)
         ? `${cacheKey}#${sessionHash(entry.source, row.session_id || row.session_hash)}`
         : cacheKey;
       sessions.push(row);
@@ -2330,10 +2368,14 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     await writeAtomic(incompleteKimiPath, "1\n");
     sessions.push(...readSidecar(sidecarPath).filter((row) => row.source === "kimi" && row.version === SIDECAR_VERSION));
   }
+  if (incompleteOmpScan) {
+    await writeAtomic(incompleteOmpPath, "1\n");
+    sessions.push(...readSidecar(sidecarPath).filter((row) => row.source === "omp" && row.version === SIDECAR_VERSION));
+  }
   sessions.sort((a, b) => String(b.ended_at || "").localeCompare(String(a.ended_at || "")));
   // A failed database scan is an incomplete inventory. Keep the last complete
   // snapshot and signature so an unchanged database is retried next build.
-  if (incompleteDirs.length === 0 && !incompleteZcodeScan && !incompleteOpencodeScan && !incompleteKimiScan) {
+  if (incompleteDirs.length === 0 && !incompleteZcodeScan && !incompleteOpencodeScan && !incompleteKimiScan && !incompleteOmpScan) {
     const content = sessions.map(serializeSessionRecord).join("\n") + (sessions.length ? "\n" : "");
     await writeAtomic(sidecarPath, content);
     const generatedAt = new Date().toISOString();
@@ -2347,6 +2389,7 @@ async function buildSessionAnalyticsInternal({ home = os.homedir(), force = fals
     await fsp.rm(incompleteZcodePath, { force: true });
     await fsp.rm(incompleteOpencodePath, { force: true });
     await fsp.rm(incompleteKimiPath, { force: true });
+    await fsp.rm(incompleteOmpPath, { force: true });
   }
   // Non-enumerable so the array still behaves exactly like a plain row list
   // for every existing caller (map/filter/JSON of the rows is unaffected).
@@ -2632,6 +2675,7 @@ function resumeCommandFor(source, sessionId) {
   // Grok Build: `grok --resume <session-id>` (also accepts a title). The
   // command must still be run from the session's project_ref cwd.
   if (source === "grok") return `grok --resume ${id}`;
+  if (source === "omp") return `omp --resume ${id}`;
   return null;
 }
 
@@ -2973,6 +3017,8 @@ module.exports = {
   scanZcodeSessions,
   scanOpencodeSessions,
   scanKimiSessions,
+  scanOmpSessions,
+  scanOmpSession,
   buildSessionAnalytics,
   summarizeSessions,
   listSessionsForBrowser,

package/src/lib/trae-cn-config.js

@@ -2,7 +2,8 @@
 
 /**
  * TRAE Work CN (国内版) config + usage fetch. Phase A: macOS + Windows + test-injected
- * paths only. Resolves the CN home, reads the `iCubeAuthInfo://icube.cloudide`
+ * paths only. Resolves the CN app data directory (TRAE Work CN or the classic
+ * Trae CN client), reads the `iCubeAuthInfo://icube.cloudide`
  * blob from User/globalStorage/storage.json (plaintext JSON or Base64 tc v5),
  * and talks to the TRAE CN usage API. JWTs / refresh tokens are never
  * persisted, never logged, and never put into error messages; a
@@ -31,7 +32,7 @@ function isTraeCnUsageEnabled(env = process.env) {
   const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
   return normalized === "1" || normalized === "true";
 }
-const TRAE_CN_APP_DIR = "TRAE SOLO CN";
+const TRAE_CN_APP_DIRS = ["TRAE SOLO CN", "Trae CN"];
 const TRAE_CN_AUTH_KEY = "iCubeAuthInfo://icube.cloudide";
 
 const TRAE_CN_USAGE_URL = "https://api.trae.cn/trae/api/v1/pay/query_user_usage_group_by_session";
@@ -77,30 +78,46 @@ const TRAE_CN_KG = Buffer.from([
 // Path resolution
 // ---------------------------------------------------------------------------
 
-function resolveTraeCnHome({ env = process.env, home = os.homedir(), platform = process.platform } = {}) {
-  const override = env[TRAE_CN_HOME_ENV];
-  if (typeof override === "string" && override.trim()) {
-    return path.resolve(override.trim());
-  }
+function traeCnDataParent({ env = process.env, home = os.homedir(), platform = process.platform } = {}) {
   if (platform === "darwin") {
-    return path.join(home, "Library", "Application Support", TRAE_CN_APP_DIR);
+    return path.join(home, "Library", "Application Support");
   }
   if (platform === "win32") {
-    // Windows keeps the CN Work app under the roaming profile, mirroring the
-    // macOS Application Support layout (APPDATA/TRAE SOLO CN/User/...).
-    const appData =
-      typeof env.APPDATA === "string" && env.APPDATA.trim()
-        ? env.APPDATA.trim()
-        : path.join(home, "AppData", "Roaming");
-    return path.join(appData, TRAE_CN_APP_DIR);
+    // Windows keeps the CN app under the roaming profile, mirroring the
+    // macOS Application Support layout (<parent>/<app dir>/User/...).
+    return typeof env.APPDATA === "string" && env.APPDATA.trim()
+      ? env.APPDATA.trim()
+      : path.join(home, "AppData", "Roaming");
   }
-  // No verified CN Work app-data layout on other platforms yet.
+  // No verified CN app-data layout on other platforms yet.
   return null;
 }
 
 function resolveTraeCnStoragePath(options = {}) {
-  const home = resolveTraeCnHome(options);
-  return home ? path.join(home, "User", "globalStorage", "storage.json") : null;
+  const env = options.env ?? process.env;
+  const override = env[TRAE_CN_HOME_ENV];
+  if (typeof override === "string" && override.trim()) {
+    return path.join(path.resolve(override.trim()), "User", "globalStorage", "storage.json");
+  }
+  const parent = traeCnDataParent({ env, home: options.home ?? os.homedir(), platform: options.platform ?? process.platform });
+  if (!parent) return null;
+  for (const dir of TRAE_CN_APP_DIRS) {
+    const candidate = path.join(parent, dir, "User", "globalStorage", "storage.json");
+    try {
+      // Any successful stat means this client dir is the discovery hit —
+      // including a non-file path (e.g. a directory named storage.json).
+      // Hand that to the reader so EISDIR surfaces as TRAE_CN_STORAGE_UNREADABLE
+      // instead of silently skipping to the next client or reporting absent.
+      fs.statSync(candidate);
+      return candidate;
+    } catch (err) {
+      // Permission failures must reach the reader's diagnostics, not
+      // masquerade as an absent installation and silently drop an entire
+      // usage history (same discovery policy as trae-db.js).
+      if (err.code !== "ENOENT" && err.code !== "ENOTDIR") return candidate;
+    }
+  }
+  return null;
 }
 
 // ---------------------------------------------------------------------------
@@ -524,7 +541,7 @@ module.exports = {
   TRAE_CN_HOME_ENV,
   TRAE_CN_USAGE_ENV,
   isTraeCnUsageEnabled,
-  TRAE_CN_APP_DIR,
+  TRAE_CN_APP_DIRS,
   TRAE_CN_AUTH_KEY,
   TRAE_CN_USAGE_URL,
   TRAE_CN_USAGE_TYPE,
@@ -532,7 +549,6 @@ module.exports = {
   TRAE_CN_USAGE_MAX_PAGES,
   TRAE_CN_USAGE_DELAY_MS,
   TRAE_CN_MAGIC,
-  resolveTraeCnHome,
   resolveTraeCnStoragePath,
   traeCnHardcodedKdfSecret,
   deriveTraeCnKeyIv,

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

@@ -1 +0,0 @@
-import{r as n,J as a}from"./__vite-browser-external-ClVJNQu3.js";import{u as p}from"./DialogTitle-Cd_k-Nyw.js";import{u as c}from"./composite-CdExmgTx.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-DatTtp2N.js

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