@vibe-cafe/vibe-usage 0.10.2 → 0.10.4

package/README.md

@@ -60,7 +60,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
 | pi | `~/.pi/agent/sessions/` |
 | Qwen Code | `~/.qwen/tmp/` |
-| Kimi Code | Current `~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` remains supported |
+| Kimi Code | Current `~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), data root resolved via `$KIMI_CODE_HOME` like the CLI itself, with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/api.js

@@ -10,6 +10,17 @@ const INITIAL_DELAY = 1000;
 // guaranteeing no uncompressed request ever leaves the client.
 const GZIP_MIN_BYTES = 0;
 
+export function retryDelayMs(attempt, random = Math.random) {
+  const ceiling = INITIAL_DELAY * 2 ** attempt;
+  // Equal jitter keeps a real backoff floor while preventing every desktop
+  // client from retrying a shared outage on the same 1s / 2s boundaries.
+  return Math.round(ceiling / 2 + random() * ceiling / 2);
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
 export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
   let lastError;
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
@@ -22,8 +33,7 @@ export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
         throw err;
       }
       if (attempt < MAX_RETRIES - 1) {
-        const delay = INITIAL_DELAY * 2 ** attempt;
-        await new Promise(r => setTimeout(r, delay));
+        await sleep(retryDelayMs(attempt));
       }
     }
   }
@@ -222,13 +232,36 @@ function _jsonRequest(apiUrl, path, method, body, timeoutMs) {
 
 /**
  * GET user settings from the vibecafe API.
- * Returns null on any failure (network, auth, timeout) — caller should fail-safe.
+ * Returns null after transient failures are exhausted. A 401 remains distinct
+ * so callers can surface invalid credentials instead of calling it an outage.
  * @param {string} apiUrl
  * @param {string} apiKey
  * @returns {Promise<{uploadProject: boolean} | null>}
  */
-export function fetchSettings(apiUrl, apiKey) {
-  return new Promise((resolve) => {
+export async function fetchSettings(apiUrl, apiKey, retry = {}) {
+  const wait = retry.sleep ?? sleep;
+  const random = retry.random ?? Math.random;
+
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      return await fetchSettingsOnce(apiUrl, apiKey);
+    } catch (err) {
+      if (err.message === 'UNAUTHORIZED') throw err;
+      // Retrying a permanent client response cannot make it valid. 429 is the
+      // exception: it is transient load shedding and benefits from backoff.
+      if (err.statusCode >= 400 && err.statusCode < 500 && err.statusCode !== 429) {
+        return null;
+      }
+      if (attempt < MAX_RETRIES - 1) {
+        await wait(retryDelayMs(attempt, random));
+      }
+    }
+  }
+  return null;
+}
+
+function fetchSettingsOnce(apiUrl, apiKey) {
+  return new Promise((resolve, reject) => {
     const url = new URL('/api/usage/settings', apiUrl);
     const mod = url.protocol === 'https:' ? https : http;
 
@@ -242,20 +275,31 @@ export function fetchSettings(apiUrl, apiKey) {
       let data = '';
       res.on('data', (chunk) => { data += chunk; });
       res.on('end', () => {
+        if (res.statusCode === 401) {
+          reject(new Error('UNAUTHORIZED'));
+          return;
+        }
         if (res.statusCode < 200 || res.statusCode >= 300) {
-          resolve(null);
+          const err = new Error(`HTTP ${res.statusCode}: ${data}`);
+          err.statusCode = res.statusCode;
+          reject(err);
           return;
         }
         try {
-          resolve(JSON.parse(data));
+          const settings = JSON.parse(data);
+          if (typeof settings?.uploadProject !== 'boolean') {
+            reject(new Error('Invalid settings response'));
+            return;
+          }
+          resolve(settings);
         } catch {
-          resolve(null);
+          reject(new Error('Invalid settings response'));
         }
       });
     });
 
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(new Error('Settings request timed out')); });
     req.end();
   });
 }

package/src/parsers/kimi-code.js

@@ -27,14 +27,25 @@ import { aggregateToBuckets, extractSessions } from './index.js';
  *    with a different envelope (StatusUpdate.payload.token_usage, float-second
  *    `timestamp`) and the model in ~/.kimi/config.toml. Kept for users who have
  *    not migrated; see parseLegacyKimi() below.
+ *
+ * Both stores are always parsed and merged. `kimi migrate` translates legacy
+ * context.jsonl into the new wire format but DROPS the `_usage` records, so
+ * historical token usage only ever exists in the legacy store — parsing both
+ * cannot double-count, while skipping legacy whenever ~/.kimi-code has any
+ * session silently loses a migrated user's entire history.
  */
 
 // ---------------------------------------------------------------------------
 // Current format: ~/.kimi-code
 // ---------------------------------------------------------------------------
 
-// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook).
-const KIMI_CODE_DIR = process.env.VIBE_USAGE_KIMI_CODE_DIR?.trim() || join(homedir(), '.kimi-code');
+// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook). Otherwise resolve
+// the data root the same way the CLI itself does: $KIMI_CODE_HOME, then
+// ~/.kimi-code. Ignoring KIMI_CODE_HOME means users with a custom home get
+// zero usage parsed.
+const KIMI_CODE_DIR = process.env.VIBE_USAGE_KIMI_CODE_DIR?.trim()
+  || process.env.KIMI_CODE_HOME?.trim()
+  || join(homedir(), '.kimi-code');
 const KIMI_CODE_SESSIONS_DIR = join(KIMI_CODE_DIR, 'sessions');
 const KIMI_CODE_SESSION_INDEX = join(KIMI_CODE_DIR, 'session_index.jsonl');
 
@@ -362,7 +373,8 @@ function parseLegacyKimi() {
 
       const tokenUsage = payload.token_usage;
       if (!tokenUsage) continue;
-      if (!tokenUsage.input_other && !tokenUsage.output) continue;
+      if (!tokenUsage.input_other && !tokenUsage.output
+        && !tokenUsage.input_cache_read && !tokenUsage.input_cache_creation) continue;
 
       const messageId = payload.message_id;
       if (messageId) {
@@ -370,14 +382,21 @@ function parseLegacyKimi() {
         seenMessageIds.add(messageId);
       }
 
-      const ts = lastTimestamp ? new Date(lastTimestamp) : new Date();
+      // No valid timestamp → skip instead of stamping "now": this parser is
+      // stateless, so a "now" fallback would re-key the same record into a
+      // fresh 30-min bucket on every sync (duplicates).
+      if (!lastTimestamp) continue;
+      const ts = new Date(lastTimestamp);
+      if (isNaN(ts.getTime())) continue;
 
       entries.push({
         source: 'kimi-code',
         model: currentModel,
         project,
         timestamp: ts,
-        inputTokens: tokenUsage.input_other || 0,
+        // Cache creation is billed non-cached input, matching the current
+        // parser and the common bucket model used by the other parsers.
+        inputTokens: (tokenUsage.input_other || 0) + (tokenUsage.input_cache_creation || 0),
         outputTokens: tokenUsage.output || 0,
         cachedInputTokens: tokenUsage.input_cache_read || 0,
         reasoningOutputTokens: 0,
@@ -389,9 +408,13 @@ function parseLegacyKimi() {
 }
 
 export async function parse() {
-  // Prefer the current ~/.kimi-code layout; fall back to legacy ~/.kimi only
-  // when no kimi-code sessions exist, so migrated users aren't double-counted.
+  // Always parse both stores and merge (see the header comment): legacy usage
+  // is never carried into ~/.kimi-code by `kimi migrate`, so a migrated user's
+  // history exists only in ~/.kimi.
   const current = parseKimiCode();
-  if (current) return current;
-  return parseLegacyKimi();
+  const legacy = parseLegacyKimi();
+  return {
+    buckets: [...(current?.buckets ?? []), ...legacy.buckets],
+    sessions: [...(current?.sessions ?? []), ...legacy.sessions],
+  };
 }

package/src/sync.js

@@ -18,6 +18,15 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
+export function resolveUploadProjectSetting(settings) {
+  if (typeof settings?.uploadProject !== 'boolean') {
+    const error = new Error('SETTINGS_UNAVAILABLE');
+    error.code = 'SETTINGS_UNAVAILABLE';
+    throw error;
+  }
+  return settings.uploadProject;
+}
+
 export async function runSync({ throws = false, quiet = false, surface = 'cli' } = {}) {
   const config = loadConfig();
   if (!config?.apiKey) {
@@ -32,6 +41,26 @@ export async function runSync({ throws = false, quiet = false, surface = 'cli' }
     saveConfig(config);
   }
 
+  // Privacy is a required input, not an optional hint. If the settings API is
+  // unavailable, treating it as `false` changes every project-bearing item's
+  // incremental identity to `unknown` and can trigger a full-history upload.
+  // Resolve it before parsing or loading upload state so failure is a true
+  // no-op: no data upload and no state mutation.
+  const apiUrl = config.apiUrl || 'https://vibecafe.ai';
+  let uploadProject;
+  try {
+    const settings = await fetchSettings(apiUrl, config.apiKey);
+    uploadProject = resolveUploadProjectSetting(settings);
+  } catch (err) {
+    if (err.message === 'UNAUTHORIZED') {
+      console.error(failure('API Key 无效，请运行 `npx @vibe-cafe/vibe-usage init` 重新配置。'));
+    } else {
+      console.error(failure('暂时无法读取上传设置，本次同步已安全取消（未上传数据）。请稍后重试。'));
+    }
+    if (throws) throw err;
+    process.exit(1);
+  }
+
   const allBuckets = [];
   const allSessions = [];
   const parserResults = [];
@@ -116,11 +145,6 @@ export async function runSync({ throws = false, quiet = false, surface = 'cli' }
   for (const b of allBuckets) if (!b.hostname) b.hostname = host;
   for (const s of allSessions) if (!s.hostname) s.hostname = host;
 
-  // Privacy: check if user allows project name upload
-  const apiUrl = config.apiUrl || 'https://vibecafe.ai';
-  const settings = await fetchSettings(apiUrl, config.apiKey);
-  const uploadProject = settings?.uploadProject === true;
-
   if (!quiet) {
     if (uploadProject) {
       console.log(dim('  项目名: 上传（可在 Web 设置中关闭）'));