vibeusage 0.2.21 → 0.2.22

package/src/commands/sync.js

@@ -1,9 +1,9 @@
-const os = require('node:os');
-const path = require('node:path');
-const fs = require('node:fs/promises');
-const cp = require('node:child_process');
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+const cp = require("node:child_process");
 
-const { ensureDir, readJson, writeJson, openLock } = require('../lib/fs');
+const { ensureDir, readJson, writeJson, openLock } = require("../lib/fs");
 const {
   listRolloutFiles,
   listClaudeProjectFiles,
@@ -13,22 +13,23 @@ const {
   parseClaudeIncremental,
   parseGeminiIncremental,
   parseOpencodeIncremental,
-  parseOpenclawIncremental
-} = 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');
+  parseOpenclawIncremental,
+} = 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 { purgeProjectUsage } = require('../lib/project-usage-purge');
-const { resolveTrackerPaths } = require('../lib/tracker-paths');
-const { resolveRuntimeConfig } = require('../lib/runtime-config');
+  recordUploadFailure,
+} = require("../lib/upload-throttle");
+const { purgeProjectUsage } = require("../lib/project-usage-purge");
+const { resolveTrackerPaths } = require("../lib/tracker-paths");
+const { resolveRuntimeConfig } = require("../lib/runtime-config");
+const { checkAndActivate } = require("../lib/activation-check");
 
 async function cmdSync(argv) {
   const opts = parseArgs(argv);
@@ -40,42 +41,44 @@ async function cmdSync(argv) {
     await writeOpenclawSignal(trackerDir);
   }
 
-  const lockPath = path.join(trackerDir, 'sync.lock');
+  const lockPath = path.join(trackerDir, "sync.lock");
   const lock = await openLock(lockPath, { quietIfLocked: opts.auto });
   if (!lock) return;
 
   let progress = null;
   try {
     progress = !opts.auto ? createProgress({ stream: process.stdout }) : null;
-    const configPath = path.join(trackerDir, 'config.json');
-    const cursorsPath = path.join(trackerDir, 'cursors.json');
-    const queuePath = path.join(trackerDir, 'queue.jsonl');
-    const queueStatePath = path.join(trackerDir, 'queue.state.json');
-    const projectQueuePath = path.join(trackerDir, 'project.queue.jsonl');
-    const projectQueueStatePath = path.join(trackerDir, 'project.queue.state.json');
-    const uploadThrottlePath = path.join(trackerDir, 'upload.throttle.json');
+    const configPath = path.join(trackerDir, "config.json");
+    const cursorsPath = path.join(trackerDir, "cursors.json");
+    const queuePath = path.join(trackerDir, "queue.jsonl");
+    const queueStatePath = path.join(trackerDir, "queue.state.json");
+    const projectQueuePath = path.join(trackerDir, "project.queue.jsonl");
+    const projectQueueStatePath = path.join(trackerDir, "project.queue.state.json");
+    const uploadThrottlePath = path.join(trackerDir, "upload.throttle.json");
 
     const config = await readJson(configPath);
     const cursors = (await readJson(cursorsPath)) || { version: 1, files: {}, updatedAt: null };
     const uploadThrottle = normalizeUploadState(await readJson(uploadThrottlePath));
     let uploadThrottleState = uploadThrottle;
 
-    const codexHome = process.env.CODEX_HOME || path.join(home, '.codex');
-    const codeHome = process.env.CODE_HOME || path.join(home, '.code');
-    const claudeProjectsDir = path.join(home, '.claude', 'projects');
-    const geminiHome = process.env.GEMINI_HOME || path.join(home, '.gemini');
-    const geminiTmpDir = path.join(geminiHome, 'tmp');
-    const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, '.local', 'share');
-    const opencodeHome = process.env.OPENCODE_HOME || path.join(xdgDataHome, 'opencode');
-    const opencodeStorageDir = path.join(opencodeHome, 'storage');
+    const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+    const codeHome = process.env.CODE_HOME || path.join(home, ".code");
+    const claudeProjectsDir = path.join(home, ".claude", "projects");
+    const geminiHome = process.env.GEMINI_HOME || path.join(home, ".gemini");
+    const geminiTmpDir = path.join(geminiHome, "tmp");
+    const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+    const opencodeHome = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
+    const opencodeStorageDir = path.join(opencodeHome, "storage");
 
     // OpenClaw hook integration: allow a hook to request incremental parsing for a single session jsonl.
     // We still parse all regular sources so model/source attribution stays complete (e.g. Kimi sessions).
-    const openclawSignal = opts.fromOpenclaw ? resolveOpenclawSignal({ home, env: process.env }) : null;
+    const openclawSignal = opts.fromOpenclaw
+      ? resolveOpenclawSignal({ home, env: process.env })
+      : null;
 
     const sources = [
-      { source: 'codex', sessionsDir: path.join(codexHome, 'sessions') },
-      { source: 'every-code', sessionsDir: path.join(codeHome, 'sessions') }
+      { source: "codex", sessionsDir: path.join(codexHome, "sessions") },
+      { source: "every-code", sessionsDir: path.join(codeHome, "sessions") },
     ];
 
     const rolloutFiles = [];
@@ -89,10 +92,14 @@ async function cmdSync(argv) {
       }
     }
 
-    const openclawFiles = openclawSignal?.sessionFile ? [{ path: openclawSignal.sessionFile, source: 'openclaw' }] : [];
+    const openclawFiles = openclawSignal?.sessionFile
+      ? [{ path: openclawSignal.sessionFile, source: "openclaw" }]
+      : [];
 
     if (progress?.enabled) {
-      progress.start(`Parsing ${renderBar(0)} 0/${formatNumber(rolloutFiles.length)} files | buckets 0`);
+      progress.start(
+        `Parsing ${renderBar(0)} 0/${formatNumber(rolloutFiles.length)} files | buckets 0`,
+      );
     }
 
     const parseResult = await parseRolloutIncremental({
@@ -105,10 +112,10 @@ async function cmdSync(argv) {
         const pct = p.total > 0 ? p.index / p.total : 1;
         progress.update(
           `Parsing ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
-            p.bucketsQueued
-          )}`
+            p.bucketsQueued,
+          )}`,
         );
-      }
+      },
     });
 
     let openclawResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
@@ -119,7 +126,7 @@ async function cmdSync(argv) {
         cursors,
         queuePath,
         projectQueuePath,
-        source: 'openclaw'
+        source: "openclaw",
       });
     }
 
@@ -128,7 +135,7 @@ async function cmdSync(argv) {
       signal: openclawSignal,
       cursors,
       queuePath,
-      projectQueuePath
+      projectQueuePath,
     });
     openclawResult.filesProcessed += openclawFallback.filesProcessed;
     openclawResult.eventsAggregated += openclawFallback.eventsAggregated;
@@ -138,7 +145,9 @@ async function cmdSync(argv) {
     let claudeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (claudeFiles.length > 0) {
       if (progress?.enabled) {
-        progress.start(`Parsing Claude ${renderBar(0)} 0/${formatNumber(claudeFiles.length)} files | buckets 0`);
+        progress.start(
+          `Parsing Claude ${renderBar(0)} 0/${formatNumber(claudeFiles.length)} files | buckets 0`,
+        );
       }
       claudeResult = await parseClaudeIncremental({
         projectFiles: claudeFiles,
@@ -150,11 +159,11 @@ async function cmdSync(argv) {
           const pct = p.total > 0 ? p.index / p.total : 1;
           progress.update(
             `Parsing Claude ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
-              p.bucketsQueued
-            )}`
+              p.bucketsQueued,
+            )}`,
           );
         },
-        source: 'claude'
+        source: "claude",
       });
     }
 
@@ -162,7 +171,9 @@ async function cmdSync(argv) {
     let geminiResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (geminiFiles.length > 0) {
       if (progress?.enabled) {
-        progress.start(`Parsing Gemini ${renderBar(0)} 0/${formatNumber(geminiFiles.length)} files | buckets 0`);
+        progress.start(
+          `Parsing Gemini ${renderBar(0)} 0/${formatNumber(geminiFiles.length)} files | buckets 0`,
+        );
       }
       geminiResult = await parseGeminiIncremental({
         sessionFiles: geminiFiles,
@@ -174,11 +185,11 @@ async function cmdSync(argv) {
           const pct = p.total > 0 ? p.index / p.total : 1;
           progress.update(
             `Parsing Gemini ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
-              p.bucketsQueued
-            )}`
+              p.bucketsQueued,
+            )}`,
           );
         },
-        source: 'gemini'
+        source: "gemini",
       });
     }
 
@@ -186,7 +197,9 @@ async function cmdSync(argv) {
     let opencodeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (opencodeFiles.length > 0) {
       if (progress?.enabled) {
-        progress.start(`Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`);
+        progress.start(
+          `Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`,
+        );
       }
       opencodeResult = await parseOpencodeIncremental({
         messageFiles: opencodeFiles,
@@ -198,23 +211,23 @@ async function cmdSync(argv) {
           const pct = p.total > 0 ? p.index / p.total : 1;
           progress.update(
             `Parsing Opencode ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total
-            )} files | buckets ${formatNumber(p.bucketsQueued)}`
+              p.total,
+            )} files | buckets ${formatNumber(p.bucketsQueued)}`,
           );
         },
-        source: 'opencode'
+        source: "opencode",
       });
     }
 
     if (cursors?.projectHourly?.projects && projectQueuePath && projectQueueStatePath) {
       for (const [projectKey, meta] of Object.entries(cursors.projectHourly.projects)) {
-        if (!meta || typeof meta !== 'object') continue;
-        if (meta.status !== 'blocked' || !meta.purge_pending) continue;
+        if (!meta || typeof meta !== "object") continue;
+        if (meta.status !== "blocked" || !meta.purge_pending) continue;
         await purgeProjectUsage({
           projectKey,
           projectQueuePath,
           projectQueueStatePath,
-          projectState: cursors.projectHourly
+          projectState: cursors.projectHourly,
         });
         meta.purge_pending = false;
         meta.purged_at = new Date().toISOString();
@@ -249,7 +262,7 @@ async function cmdSync(argv) {
         autoDecision = decideAutoUpload({
           nowMs: Date.now(),
           pendingBytes,
-          state: uploadThrottle
+          state: uploadThrottle,
         });
         allowUpload = allowUpload && autoDecision.allowed;
         maxBatches = autoDecision.allowed ? autoDecision.maxBatches : 0;
@@ -261,18 +274,19 @@ async function cmdSync(argv) {
             retryAtMs: autoDecision.blockedUntilMs,
             reason,
             pendingBytes,
-            source: 'auto-throttled',
-            autoRetryNoSpawn: runtime.autoRetryNoSpawn
+            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 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`
+          `Uploading ${renderBar(pct)} ${formatBytes(totalOffset)}/${formatBytes(totalSize)} | inserted 0 skipped 0`,
         );
       }
 
@@ -282,7 +296,7 @@ async function cmdSync(argv) {
           home,
           env: process.env,
           probeKeychain: true,
-          probeKeychainDetails: true
+          probeKeychainDetails: true,
         });
         try {
           uploadResult = await drainQueueToCloud({
@@ -300,10 +314,10 @@ async function cmdSync(argv) {
               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)}`
+                  u.inserted,
+                )} skipped ${formatNumber(u.skipped)}`,
               );
-            }
+            },
           });
           if (uploadResult.attempted > 0) {
             const next = recordUploadSuccess({ nowMs: Date.now(), state: uploadThrottleState });
@@ -311,7 +325,11 @@ async function cmdSync(argv) {
             await writeJson(uploadThrottlePath, next);
           }
         } catch (e) {
-          const next = recordUploadFailure({ nowMs: Date.now(), state: uploadThrottleState, error: e });
+          const next = recordUploadFailure({
+            nowMs: Date.now(),
+            state: uploadThrottleState,
+            error: e,
+          });
           uploadThrottleState = next;
           await writeJson(uploadThrottlePath, next);
           if (opts.auto && pendingBytes > 0) {
@@ -320,10 +338,10 @@ async function cmdSync(argv) {
               await scheduleAutoRetry({
                 trackerDir,
                 retryAtMs,
-                reason: 'backoff',
+                reason: "backoff",
                 pendingBytes,
-                source: 'auto-error',
-                autoRetryNoSpawn: runtime.autoRetryNoSpawn
+                source: "auto-error",
+                autoRetryNoSpawn: runtime.autoRetryNoSpawn,
               });
             }
           }
@@ -352,10 +370,10 @@ async function cmdSync(argv) {
         await scheduleAutoRetry({
           trackerDir,
           retryAtMs,
-          reason: 'backlog',
+          reason: "backlog",
           pendingBytes,
-          source: 'auto-backlog',
-          autoRetryNoSpawn: runtime.autoRetryNoSpawn
+          source: "auto-backlog",
+          autoRetryNoSpawn: runtime.autoRetryNoSpawn,
         });
       }
     }
@@ -365,7 +383,7 @@ async function cmdSync(argv) {
       deviceToken,
       trackerDir,
       uploadResult,
-      pendingBytes
+      pendingBytes,
     });
 
     if (!opts.auto) {
@@ -383,25 +401,28 @@ async function cmdSync(argv) {
         opencodeResult.bucketsQueued;
       process.stdout.write(
         [
-          'Sync finished:',
+          "Sync finished:",
           `- Parsed files: ${totalParsed}`,
           `- New 30-min buckets queued: ${totalBuckets}`,
           deviceToken
             ? `- Uploaded: ${uploadResult.inserted} inserted, ${uploadResult.skipped} skipped`
-            : '- Uploaded: skipped (no device token)',
+            : "- Uploaded: skipped (no device token)",
           deviceToken && pendingBytes > 0 && !opts.drain
             ? `- Remaining: ${formatBytes(pendingBytes)} pending (run sync again, or use --drain)`
             : null,
-          ''
+          "",
         ]
           .filter(Boolean)
-          .join('\n')
+          .join("\n"),
       );
     }
   } finally {
     progress?.stop();
     await lock.release();
     await fs.unlink(lockPath).catch(() => {});
+    
+    // 顺带检测并激活其他 AI CLI 集成（静默执行，不阻塞主流程）
+    checkAndActivate({ home, silent: true }).catch(() => {});
   }
 }
 
@@ -411,15 +432,15 @@ function parseArgs(argv) {
     fromNotify: false,
     fromRetry: false,
     fromOpenclaw: false,
-    drain: false
+    drain: false,
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === '--auto') out.auto = true;
-    else if (a === '--from-notify') out.fromNotify = true;
-    else if (a === '--from-retry') out.fromRetry = true;
-    else if (a === '--from-openclaw') out.fromOpenclaw = true;
-    else if (a === '--drain') out.drain = true;
+    if (a === "--auto") out.auto = true;
+    else if (a === "--from-notify") out.fromNotify = true;
+    else if (a === "--from-retry") out.fromRetry = true;
+    else if (a === "--from-openclaw") out.fromOpenclaw = true;
+    else if (a === "--drain") out.drain = true;
     else throw new Error(`Unknown option: ${a}`);
   }
   return out;
@@ -428,7 +449,7 @@ function parseArgs(argv) {
 module.exports = { cmdSync };
 
 function normalizeString(value) {
-  if (typeof value !== 'string') return null;
+  if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
@@ -440,15 +461,16 @@ function resolveOpenclawSignal({ home, env } = {}) {
   const sessionId = normalizeString(env.VIBEUSAGE_OPENCLAW_PREV_SESSION_ID);
   if (!agentId || !sessionId) return null;
 
-  const openclawHome = normalizeString(env.VIBEUSAGE_OPENCLAW_HOME) || path.join(home || os.homedir(), '.openclaw');
-  const sessionFile = path.join(openclawHome, 'agents', agentId, 'sessions', `${sessionId}.jsonl`);
+  const openclawHome =
+    normalizeString(env.VIBEUSAGE_OPENCLAW_HOME) || path.join(home || os.homedir(), ".openclaw");
+  const sessionFile = path.join(openclawHome, "agents", agentId, "sessions", `${sessionId}.jsonl`);
 
   const prevTotals = {
     totalTokens: normalizeNonNegativeInt(env.VIBEUSAGE_OPENCLAW_PREV_TOTAL_TOKENS),
     inputTokens: normalizeNonNegativeInt(env.VIBEUSAGE_OPENCLAW_PREV_INPUT_TOKENS),
     outputTokens: normalizeNonNegativeInt(env.VIBEUSAGE_OPENCLAW_PREV_OUTPUT_TOKENS),
     model: normalizeString(env.VIBEUSAGE_OPENCLAW_PREV_MODEL),
-    updatedAt: normalizeIsoOrEpoch(env.VIBEUSAGE_OPENCLAW_PREV_UPDATED_AT)
+    updatedAt: normalizeIsoOrEpoch(env.VIBEUSAGE_OPENCLAW_PREV_UPDATED_AT),
   };
 
   return {
@@ -457,40 +479,55 @@ function resolveOpenclawSignal({ home, env } = {}) {
     sessionKey: normalizeString(env.VIBEUSAGE_OPENCLAW_SESSION_KEY),
     openclawHome,
     sessionFile,
-    prevTotals
+    prevTotals,
   };
 }
 
-
-async function applyOpenclawTotalsFallback({ trackerDir, signal, cursors, queuePath, projectQueuePath }) {
+async function applyOpenclawTotalsFallback({
+  trackerDir,
+  signal,
+  cursors,
+  queuePath,
+  projectQueuePath,
+}) {
   const totalTokens = Number(signal?.prevTotals?.totalTokens || 0);
   if (!trackerDir || !signal || totalTokens <= 0) {
     return { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
   }
 
   const sessionKey = `${signal.agentId}:${signal.sessionId}`;
-  const statePath = path.join(trackerDir, 'openclaw.fallback.state.json');
-  const fallbackFilePath = path.join(trackerDir, 'openclaw.fallback.jsonl');
+  const statePath = path.join(trackerDir, "openclaw.fallback.state.json");
+  const fallbackFilePath = path.join(trackerDir, "openclaw.fallback.jsonl");
   const state = (await readJson(statePath)) || { version: 1, sessions: {} };
-  const sessions = state.sessions && typeof state.sessions === 'object' ? state.sessions : {};
-  const prev = sessions[sessionKey] && typeof sessions[sessionKey] === 'object' ? sessions[sessionKey] : null;
+  const sessions = state.sessions && typeof state.sessions === "object" ? state.sessions : {};
+  const prev =
+    sessions[sessionKey] && typeof sessions[sessionKey] === "object" ? sessions[sessionKey] : null;
 
   const current = {
     totalTokens: normalizeNonNegativeInt(signal?.prevTotals?.totalTokens) || 0,
     inputTokens: normalizeNonNegativeInt(signal?.prevTotals?.inputTokens) || 0,
     outputTokens: normalizeNonNegativeInt(signal?.prevTotals?.outputTokens) || 0,
-    model: normalizeString(signal?.prevTotals?.model) || 'unknown',
+    model: normalizeString(signal?.prevTotals?.model) || "unknown",
     updatedAt: normalizeIsoOrEpoch(signal?.prevTotals?.updatedAt) || new Date().toISOString(),
-    seenAt: new Date().toISOString()
+    seenAt: new Date().toISOString(),
   };
 
   let deltaTotal = current.totalTokens;
   let deltaInput = current.inputTokens;
   let deltaOutput = current.outputTokens;
   if (prev) {
-    deltaTotal = Math.max(0, current.totalTokens - (normalizeNonNegativeInt(prev.totalTokens) || 0));
-    deltaInput = Math.max(0, current.inputTokens - (normalizeNonNegativeInt(prev.inputTokens) || 0));
-    deltaOutput = Math.max(0, current.outputTokens - (normalizeNonNegativeInt(prev.outputTokens) || 0));
+    deltaTotal = Math.max(
+      0,
+      current.totalTokens - (normalizeNonNegativeInt(prev.totalTokens) || 0),
+    );
+    deltaInput = Math.max(
+      0,
+      current.inputTokens - (normalizeNonNegativeInt(prev.inputTokens) || 0),
+    );
+    deltaOutput = Math.max(
+      0,
+      current.outputTokens - (normalizeNonNegativeInt(prev.outputTokens) || 0),
+    );
   }
 
   if (deltaTotal > 0 && deltaInput + deltaOutput === 0) {
@@ -508,29 +545,29 @@ async function applyOpenclawTotalsFallback({ trackerDir, signal, cursors, queueP
 
   await ensureDir(path.dirname(fallbackFilePath));
   const syntheticMessage = {
-    type: 'message',
+    type: "message",
     timestamp: current.updatedAt,
     message: {
-      role: 'assistant',
+      role: "assistant",
       model: current.model,
       usage: {
         input: deltaInput,
         output: deltaOutput,
         cacheRead: 0,
         cacheWrite: 0,
-        totalTokens: deltaTotal
-      }
-    }
+        totalTokens: deltaTotal,
+      },
+    },
   };
-  await fs.appendFile(fallbackFilePath, `${JSON.stringify(syntheticMessage)}\n`, 'utf8');
+  await fs.appendFile(fallbackFilePath, `${JSON.stringify(syntheticMessage)}\n`, "utf8");
   await writeJson(statePath, state);
 
   return parseOpenclawIncremental({
-    sessionFiles: [{ path: fallbackFilePath, source: 'openclaw' }],
+    sessionFiles: [{ path: fallbackFilePath, source: "openclaw" }],
     cursors,
     queuePath,
     projectQueuePath,
-    source: 'openclaw'
+    source: "openclaw",
   });
 }
 
@@ -541,7 +578,7 @@ function normalizeNonNegativeInt(value) {
 }
 
 function normalizeIsoOrEpoch(value) {
-  if (typeof value === 'string') {
+  if (typeof value === "string") {
     const trimmed = value.trim();
     if (trimmed.length > 0 && !Number.isNaN(Date.parse(trimmed))) return trimmed;
     const numeric = Number(trimmed);
@@ -569,14 +606,20 @@ async function safeStatSize(p) {
   }
 }
 
-async function maybeSendHeartbeat({ baseUrl, deviceToken, trackerDir, uploadResult, pendingBytes }) {
+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 heartbeatPath = path.join(trackerDir, "sync.heartbeat.json");
   const heartbeatState = await readJson(heartbeatPath);
-  const lastPingAt = Date.parse(heartbeatState?.lastPingAt || '');
+  const lastPingAt = Date.parse(heartbeatState?.lastPingAt || "");
   const nowMs = Date.now();
   if (Number.isFinite(lastPingAt) && nowMs - lastPingAt < HEARTBEAT_MIN_INTERVAL_MS) return;
 
@@ -584,7 +627,7 @@ async function maybeSendHeartbeat({ baseUrl, deviceToken, trackerDir, uploadResu
     await syncHeartbeat({ baseUrl, deviceToken });
     await writeJson(heartbeatPath, {
       lastPingAt: new Date(nowMs).toISOString(),
-      minIntervalMinutes: HEARTBEAT_MIN_INTERVAL_MINUTES
+      minIntervalMinutes: HEARTBEAT_MIN_INTERVAL_MINUTES,
     });
   } catch (_e) {
     // best-effort heartbeat; ignore failures
@@ -592,14 +635,21 @@ async function maybeSendHeartbeat({ baseUrl, deviceToken, trackerDir, uploadResu
 }
 
 function deriveAutoSkipReason({ decision, state }) {
-  if (!decision || decision.reason !== 'throttled') return decision?.reason || 'unknown';
+  if (!decision || decision.reason !== "throttled") return decision?.reason || "unknown";
   const backoffUntilMs = Number(state?.backoffUntilMs || 0);
   const nextAllowedAtMs = Number(state?.nextAllowedAtMs || 0);
-  if (backoffUntilMs > 0 && backoffUntilMs >= nextAllowedAtMs) return 'backoff';
-  return 'throttled';
+  if (backoffUntilMs > 0 && backoffUntilMs >= nextAllowedAtMs) return "backoff";
+  return "throttled";
 }
 
-async function scheduleAutoRetry({ trackerDir, retryAtMs, reason, pendingBytes, source, autoRetryNoSpawn }) {
+async function scheduleAutoRetry({
+  trackerDir,
+  retryAtMs,
+  reason,
+  pendingBytes,
+  source,
+  autoRetryNoSpawn,
+}) {
   const retryMs = coerceRetryMs(retryAtMs);
   if (!retryMs) return { scheduled: false, retryAtMs: 0 };
 
@@ -615,10 +665,10 @@ async function scheduleAutoRetry({ trackerDir, retryAtMs, reason, pendingBytes,
     version: 1,
     retryAtMs: retryMs,
     retryAt: new Date(retryMs).toISOString(),
-    reason: typeof reason === 'string' && reason.length > 0 ? reason : 'throttled',
+    reason: typeof reason === "string" && reason.length > 0 ? reason : "throttled",
     pendingBytes: Math.max(0, Number(pendingBytes || 0)),
     scheduledAt: new Date(nowMs).toISOString(),
-    source: typeof source === 'string' ? source : 'auto'
+    source: typeof source === "string" ? source : "auto",
   };
 
   await writeJson(retryPath, payload);
@@ -631,9 +681,9 @@ async function scheduleAutoRetry({ trackerDir, retryAtMs, reason, pendingBytes,
 
   spawnAutoRetryProcess({
     retryPath,
-    trackerBinPath: path.join(trackerDir, 'app', 'bin', 'tracker.js'),
-    fallbackPkg: 'vibeusage',
-    delayMs
+    trackerBinPath: path.join(trackerDir, "app", "bin", "tracker.js"),
+    fallbackPkg: "vibeusage",
+    delayMs,
   });
   return { scheduled: true, retryAtMs: retryMs };
 }
@@ -646,17 +696,18 @@ async function clearAutoRetry(trackerDir) {
 function spawnAutoRetryProcess({ retryPath, trackerBinPath, fallbackPkg, delayMs }) {
   const script = buildAutoRetryScript({ retryPath, trackerBinPath, fallbackPkg, delayMs });
   try {
-    const child = cp.spawn(process.execPath, ['-e', script], {
+    const child = cp.spawn(process.execPath, ["-e", script], {
       detached: true,
-      stdio: 'ignore',
-      env: process.env
+      stdio: "ignore",
+      env: process.env,
     });
     child.unref();
   } catch (_e) {}
 }
 
 function buildAutoRetryScript({ retryPath, trackerBinPath, fallbackPkg, delayMs }) {
-  return `'use strict';\n` +
+  return (
+    `'use strict';\n` +
     `const fs = require('node:fs');\n` +
     `const cp = require('node:child_process');\n` +
     `const retryPath = ${JSON.stringify(retryPath)};\n` +
@@ -678,7 +729,8 @@ function buildAutoRetryScript({ retryPath, trackerBinPath, fallbackPkg, delayMs
     `    const child = cp.spawn(cmd[0], cmd.slice(1), { detached: true, stdio: 'ignore', env: process.env });\n` +
     `    child.unref();\n` +
     `  } catch (_) {}\n` +
-    `}, delayMs);\n`;
+    `}, delayMs);\n`
+  );
 }
 
 function coerceRetryMs(v) {
@@ -688,9 +740,9 @@ function coerceRetryMs(v) {
 }
 
 async function writeOpenclawSignal(trackerDir) {
-  const openclawSignalPath = path.join(trackerDir, 'openclaw.signal');
+  const openclawSignalPath = path.join(trackerDir, "openclaw.signal");
   try {
-    await fs.writeFile(openclawSignalPath, new Date().toISOString(), 'utf8');
+    await fs.writeFile(openclawSignalPath, new Date().toISOString(), "utf8");
   } catch (_e) {
     // best-effort marker
   }
@@ -698,5 +750,5 @@ 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_FILENAME = "auto.retry.json";
 const AUTO_RETRY_MAX_DELAY_MS = 2 * 60 * 60 * 1000;