@vibe-cafe/vibe-usage 0.14.3 → 0.14.4

package/README.md

@@ -144,6 +144,7 @@ To relabel old history, the maintainer needs the old bucket keys, raw per-tool t
 - Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
 - Incremental upload: every parser emits a complete local snapshot, then only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Upload state remains in `~/.vibe-usage/state.json`; failed or still-indexing parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
 - Incremental Codex parsing: a versioned, disposable cache under `~/.vibe-usage/cache/codex/` stores per-rollout aggregate results and parser continuation state. Unchanged rollouts require no raw-log reads; an ordinary append reads only the new tail; forks, sub-agents, replacements, truncations, and failed safety checks fall back to the full correctness path. Multi-file sessions have a combined cache that rebuilds when any segment changes. A bounded rolling audit occasionally re-reads one historical file or continuation group. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting
+- Interactive `sync` shows a live status line (`正在读取上传设置` → `正在扫描本地日志 12/35 · 已用时 2m10s`) while it reads backend settings and scans/indexes local logs. A first sync, a cold Codex index rebuild, or a slow `cursor.com` export can take minutes, so that line is what separates a slow sync from a hung one. It is printed only on a TTY — the Mac and Windows apps read the piped stdout as the result text and must keep receiving plain output. Interrupting a sync is safe: finished batches are already committed, and the Codex index checkpoints and resumes on the next run
 - The Codex parser cache contains derived aggregates and replay metadata, not raw prompt or response text. It is independent of upload state and can be deleted safely (the next sync rebuilds it). `reset` intentionally keeps it so the required full re-upload does not also require a full disk rescan. Set `VIBE_USAGE_CODEX_CACHE=0` to disable the optimization for diagnosis
 - SQLite-backed tools are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node the CLI falls back to the system `sqlite3` executable
 - Continuous syncing is on by default: the first run installs a background service (see [Background sync](#background-sync)); the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app) is the menu-bar alternative

package/package.json

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

package/src/output.js

@@ -52,6 +52,65 @@ export function hint(msg) {
   console.log(dim(`提示: ${msg}`));
 }
 
+/**
+ * One redrawn status line for a phase that would otherwise leave the terminal
+ * blank for minutes: the settings round-trip (a timing-out endpoint re-trying),
+ * the local log scan, and a cold Codex index build. Without it the sync header
+ * is the last thing on screen, and "still working" is indistinguishable from
+ * "hung" — exactly how a slow first sync reads.
+ *
+ * TTY-only for the same reason as hint(): the Mac (`SyncEngine.swift`) and
+ * Windows (`sync_engine.rs`) apps run `sync` through a pipe and treat stdout as
+ * the result text, so a pipe must never receive these lines.
+ * `VIBE_USAGE_FORCE_PROGRESS=1` forces them on for tests, and
+ * `VIBE_USAGE_PROGRESS_INTERVAL_MS` overrides the redraw interval.
+ *
+ * `label` is a function so the caller owns the wording and its elapsed-time
+ * text; it is re-read on every redraw. The interval is unref'ed so a phase that
+ * never reaches `stop()` cannot hold the process open.
+ */
+export function liveStatus({ enabled = true, intervalMs } = {}) {
+  const configuredInterval = Number(process.env.VIBE_USAGE_PROGRESS_INTERVAL_MS);
+  const tickMs = intervalMs ?? (configuredInterval > 0 ? configuredInterval : 5000);
+  const active = enabled
+    && (!!process.stdout.isTTY || process.env.VIBE_USAGE_FORCE_PROGRESS === '1');
+  let label = null;
+  let timer = null;
+  let startedAt = 0;
+
+  function draw() {
+    if (label === null) return;
+    process.stdout.write(`\r${dim(`  ${label(Date.now() - startedAt)}`)}\x1b[K`);
+  }
+
+  return {
+    /** Show the line, or retarget it to the next phase. */
+    start(nextLabel) {
+      if (!active) return;
+      label = nextLabel;
+      startedAt = Date.now();
+      draw();
+      if (timer === null) {
+        timer = setInterval(draw, tickMs);
+        unrefTimer(timer);
+      }
+    },
+    /** Erase the line before regular output continues on it. */
+    stop() {
+      if (!active || label === null) return;
+      clearInterval(timer);
+      timer = null;
+      label = null;
+      process.stdout.write('\r\x1b[K');
+    },
+  };
+}
+
+/** Bun's timer objects and Node's both expose unref; tests run on either. */
+function unrefTimer(timer) {
+  if (typeof timer?.unref === 'function') timer.unref();
+}
+
 /** Print a blank line. */
 export const nl = () => console.log();
 

package/src/sync.js

@@ -11,7 +11,7 @@ import { aggregateToBuckets } from './parsers/aggregate.js';
 import { normalizeParserResult } from './parsers/contract.js';
 import { extraRootList } from './extra-roots.js';
 import { planKikiMigration } from './kiki-migration.js';
-import { success, failure, warn, arrow, link, dim } from './output.js';
+import { success, failure, warn, arrow, link, dim, liveStatus } from './output.js';
 
 const BATCH_SIZE = 100;
 const SESSION_BATCH_SIZE = 500;
@@ -44,6 +44,11 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
+/** Elapsed-time suffix for the live status line (`formatDuration` rounds 0 to `0s`). */
+function phaseElapsed(elapsedMs) {
+  return ` · 已用时 ${formatDuration(elapsedMs / 1000)}`;
+}
+
 export function resolveUploadProjectSetting(settings) {
   if (typeof settings?.uploadProject !== 'boolean') {
     const error = new Error('SETTINGS_UNAVAILABLE');
@@ -127,6 +132,13 @@ export async function runSync({
   // Built from the same `apiUrl` the ingest calls below use, so the recorded
   // target and the actual target can never drift apart.
   const identity = stateIdentity({ apiUrl, apiKey: config.apiKey });
+  // Both the settings round-trip and the log scan below can run for minutes on
+  // a cold or proxied machine (a timing-out endpoint retrying, a cold Codex
+  // index, a 120s Cursor export). A live status line keeps that work
+  // distinguishable from a hang; it never reaches a pipe, so the desktop apps
+  // keep parsing bare result text from stdout.
+  const status = liveStatus({ enabled: !quiet });
+  status.start(elapsedMs => `正在读取上传设置${phaseElapsed(elapsedMs)}`);
   let uploadProject;
   try {
     const settings = await fetchSettings(apiUrl, config.apiKey);
@@ -143,6 +155,7 @@ export async function runSync({
       saveConfig(config);
     }
   } catch (err) {
+    status.stop();
     if (err.message === 'UNAUTHORIZED') {
       console.error(failure('API Key 无效，请运行 `npx @vibe-cafe/vibe-usage init` 重新配置。'));
       if (throws) throw err;
@@ -173,8 +186,11 @@ export async function runSync({
   // Run parsers concurrently (bounded) so one slow parser (Cursor's network
   // fetch, a cold Codex index) can't stall the rest. Results are collected in
   // registry order so output and merged arrays stay deterministic.
+  const parserRegistry = Object.entries(parsers);
+  let parsedSources = 0;
+  status.start(elapsedMs => `正在扫描本地日志 ${parsedSources}/${parserRegistry.length}${phaseElapsed(elapsedMs)}`);
   const parserOutcomes = await mapWithConcurrency(
-    Object.entries(parsers),
+    parserRegistry,
     PARSER_CONCURRENCY,
     async ([source, parse]) => {
       try {
@@ -187,9 +203,12 @@ export async function runSync({
         return { source, result };
       } catch (err) {
         return { source, error: err };
+      } finally {
+        parsedSources++;
       }
     },
   );
+  status.stop();
 
   for (const { source, result, error } of parserOutcomes) {
     if (error) {