tokentracker-cli 0.87.14 → 0.87.16

package/src/commands/status.js

@@ -66,6 +66,7 @@ const {
   resolveRoocodeTaskFiles,
   resolveZedDbPath,
   resolveQoderDbPaths,
+  resolveQoderCnDbPaths,
   resolveClaudeScienceDbPaths,
   resolveAnythingllmDbPath,
   resolveGooseDbPath,
@@ -118,6 +119,7 @@ async function cmdStatus(argv = []) {
   const throttlePath = path.join(trackerDir, "sync.throttle");
   const uploadThrottlePath = path.join(trackerDir, "upload.throttle.json");
   const autoRetryPath = path.join(trackerDir, "auto.retry.json");
+  const syncSkipPath = path.join(trackerDir, "sync.skip.json");
   const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
   const codexConfigPath = path.join(codexHome, "config.toml");
   const codeHome = process.env.CODE_HOME || path.join(home, ".code");
@@ -153,6 +155,9 @@ async function cmdStatus(argv = []) {
     await readJson(uploadThrottlePath),
   );
   const autoRetry = await readJson(autoRetryPath);
+  // Written by sync whenever it had to skip a run. Present here so a stalled
+  // parse has a visible cause instead of only a frozen "Last parse".
+  const syncSkip = await readJson(syncSkipPath);
 
   const queueSize = await safeStatSize(queuePath);
   const pendingBytes = Math.max(0, queueSize - (queueState.offset || 0));
@@ -212,6 +217,11 @@ async function cmdStatus(argv = []) {
   const lastUploadError = uploadThrottle.lastError
     ? `${uploadThrottle.lastErrorAt || "unknown"} ${uploadThrottle.lastError}`
     : null;
+  const syncSkipLine = syncSkip?.at
+    ? `- Last sync skipped: ${syncSkip.at} (${syncSkip.reason || "unknown"}${
+        syncSkip.detail ? `, ${syncSkip.detail}` : ""
+      })`
+    : null;
   const autoRetryAt = parseEpochMsToIso(autoRetry?.retryAtMs || null);
   const autoRetryLine = autoRetryAt
     ? `- Auto retry after: ${autoRetryAt} (${autoRetry?.reason || "scheduled"}, pending ${Number(
@@ -428,6 +438,16 @@ async function cmdStatus(argv = []) {
   const qoderInstalled = qoderActive.length > 0;
   const qoderDbPath = qoderActive.join(" | ");
 
+  // Qoder CN (国内版) — same schema, separate Application Support/QoderCN dir.
+  const qoderCnPaths = resolveQoderCnDbPaths({
+    home,
+    env: process.env,
+    platform: process.platform,
+  });
+  const qoderCnActive = formatResolvedPaths(qoderCnPaths);
+  const qoderCnInstalled = qoderCnActive.length > 0;
+  const qoderCnDbPath = qoderCnActive.join(" | ");
+
   // Claude Science — token usage lives on the `frames` table of operon-cli.db.
   // Unlike the native/WSL pair other providers resolve to, this is an open-ended
   // list: multi-org installs keep one DB per org (and on Windows they all sit
@@ -731,6 +751,7 @@ async function cmdStatus(argv = []) {
       next_upload_after: nextUpload || null,
       backoff_until: backoffUntil || null,
       last_upload_error: lastUploadError || null,
+      last_sync_skipped: syncSkip?.at ? syncSkip : null,
       auto_retry: autoRetry || null,
       hooks: {
         codex_notify: notifyConfigured,
@@ -802,6 +823,9 @@ async function cmdStatus(argv = []) {
         qoder: qoderInstalled
           ? { installed: true, detail: qoderDbPath }
           : { installed: false },
+        "qoder-cn": qoderCnInstalled
+          ? { installed: true, detail: qoderCnDbPath }
+          : { installed: false },
         "claude-science": claudeScienceInstalled
           ? { installed: true, detail: claudeScienceDbPath }
           : { installed: false },
@@ -875,6 +899,7 @@ async function cmdStatus(argv = []) {
       `- Next upload after: ${nextUpload || "never"}`,
       `- Backoff until: ${backoffUntil || "never"}`,
       lastUploadError ? `- Last upload error: ${lastUploadError}` : null,
+      syncSkipLine,
       autoRetryLine,
       `- Codex notify: ${notifyConfigured ? JSON.stringify(codexNotify) : "unset"}`,
       `- Every Code notify: ${everyCodeConfigured ? JSON.stringify(everyCodeNotify) : "unset"}`,
@@ -926,6 +951,9 @@ async function cmdStatus(argv = []) {
       qoderInstalled
         ? `- Qoder: passive reader (${qoderDbPath})`
         : null,
+      qoderCnInstalled
+        ? `- Qoder CN: passive reader (${qoderCnDbPath})`
+        : null,
       claudeScienceInstalled
         ? `- Claude Science: passive reader (${claudeScienceDbPath})`
         : null,
@@ -1133,6 +1161,12 @@ function renderLightTable(summary) {
   push("Next upload after", summary.next_upload_after);
   push("Backoff until", summary.backoff_until);
   if (summary.last_upload_error) push("Last upload error", summary.last_upload_error);
+  if (summary.last_sync_skipped) {
+    push(
+      "Last sync skipped",
+      `${summary.last_sync_skipped.at} (${summary.last_sync_skipped.reason || "unknown"})`,
+    );
+  }
 
   for (const [name, state] of Object.entries(summary.hooks || {})) {
     push(`Hook · ${name}`, state ? "set" : "unset");

package/src/commands/sync.js

@@ -14,6 +14,7 @@ const {
   writeJson,
   chmod600IfPossible,
   openLock,
+  inspectLock,
 } = require("../lib/fs");
 const { physicalJsonlRecords } = require("../lib/jsonl-lines");
 const {
@@ -28,6 +29,7 @@ const {
   readMimoDbMessages,
   readZcodeDbMessages,
   resolveQoderDbPaths,
+  resolveQoderCnDbPaths,
   readQoderDbMessages,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
@@ -277,6 +279,7 @@ const AUTO_SYNC_SOURCES = new Set([
   "openclaw",
   "pi",
   "qoder",
+  "qoder-cn",
   "roocode",
   "workbuddy",
   "zcode",
@@ -397,6 +400,38 @@ async function acquireSyncLock(
   }
 }
 
+const SYNC_SKIP_MARKER = "sync.skip.json";
+
+// A skipped sync used to exit 0 with no output whatsoever, so lock debris left
+// by a killed run stalled every parse for a day with no visible signal and
+// nothing for `tokentracker status` to report (issue #431). Leave a queryable
+// marker that separates ordinary contention (`lock_busy`) from a lease whose
+// owner is gone (`lock_debris`, the state that needs attention).
+async function recordSyncSkip(trackerDir, lockPath) {
+  const holder = await inspectLock(lockPath);
+  const reason = holder.exists && holder.pid && !holder.alive ? "lock_debris" : "lock_busy";
+  const detail = !holder.exists
+    ? "sync lock could not be acquired"
+    : holder.pid
+      ? `sync lock held by pid ${holder.pid} (${holder.alive ? "running" : "not running"})`
+      : "sync lock has no owner record";
+  await writeJson(path.join(trackerDir, SYNC_SKIP_MARKER), {
+    reason,
+    detail,
+    at: new Date().toISOString(),
+    lockPath,
+  });
+  return `Sync skipped: ${reason} — ${detail}\n`;
+}
+
+async function clearSyncSkip(trackerDir) {
+  try {
+    await fs.unlink(path.join(trackerDir, SYNC_SKIP_MARKER));
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+  }
+}
+
 async function cmdSync(argv, context = {}) {
   const opts = parseArgs(argv);
   const diagnostics = context && typeof context === "object" ? context.diagnostics : null;
@@ -417,7 +452,13 @@ async function cmdSync(argv, context = {}) {
 
   const lockPath = path.join(trackerDir, "sync.lock");
   const lock = await acquireSyncLock(lockPath, opts, lockWaitOptions);
-  if (!lock) return;
+  if (!lock) {
+    // Warn on stderr so the notice reaches interactive and background runs
+    // alike without disturbing anything that parses sync's stdout.
+    process.stderr.write(await recordSyncSkip(trackerDir, lockPath));
+    return;
+  }
+  await clearSyncSkip(trackerDir);
 
   let progress = null;
   try {
@@ -1159,6 +1200,57 @@ async function cmdSync(argv, context = {}) {
       }
     }
 
+    // ── Qoder CN (国内版) — same SharedClientCache/local.db schema, separate
+    // Application Support/QoderCN data directory. Tracked as its own source
+    // with its own cursor namespace: the two DBs each number rowids from 1, so
+    // a shared cursor would mis-dedup across installs.
+    let qoderCnResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (sourceAllowed("qoder-cn")) {
+      const qoderCnPaths = resolveQoderCnDbPaths({
+        home,
+        env: process.env,
+        platform: process.platform,
+      });
+      if (qoderCnPaths.native || qoderCnPaths.wsl) {
+        if (progress?.enabled) {
+          progress.start(`Parsing Qoder CN ${renderBar(0)} | buckets 0`);
+        }
+        try {
+          const result = await multiInstallParse({
+            paths: qoderCnPaths,
+            parserFn: async ({ dbPath, ...rest }) => {
+              const dbMessages = await readQoderDbMessages(dbPath, { label: "Qoder CN" });
+              const parsed = await parseQoderDbIncremental({
+                dbMessages,
+                dbPath,
+                sourceKey: "qoder-cn",
+                cursorKey: "qoder-cn",
+                ...rest,
+              });
+              return {
+                recordsProcessed: parsed.messagesProcessed || 0,
+                eventsAggregated: parsed.eventsAggregated || 0,
+                bucketsQueued: parsed.bucketsQueued || 0,
+              };
+            },
+            providerName: "qoder-cn",
+            cursors,
+            queuePath,
+            projectQueuePath,
+            getParams: (dbPath) => ({ dbPath }),
+            onProgress: makeProviderProgress("Qoder CN"),
+          });
+          qoderCnResult = {
+            recordsProcessed: result.recordsProcessed || 0,
+            eventsAggregated: result.eventsAggregated || 0,
+            bucketsQueued: result.bucketsQueued || 0,
+          };
+        } catch (err) {
+          warnProviderParseFailure("Qoder CN", err, opts);
+        }
+      }
+    }
+
     // ── Claude Science (Anthropic's local research workbench, issue #246) ──
     // Per-frame token usage lives on the `frames` table of operon-cli.db.
     // Passive, incremental, subtract-on-change. There can be more than one DB:
@@ -2392,6 +2484,7 @@ async function cmdSync(argv, context = {}) {
       antigravityResult.filesProcessed +
       opencodeResult.filesProcessed +
       qoderResult.recordsProcessed +
+      qoderCnResult.recordsProcessed +
       claudeScienceResult.recordsProcessed +
       cursorResult.recordsProcessed +
       kiroResult.recordsProcessed +
@@ -2423,6 +2516,7 @@ async function cmdSync(argv, context = {}) {
       antigravityResult.bucketsQueued +
       opencodeResult.bucketsQueued +
       qoderResult.bucketsQueued +
+      qoderCnResult.bucketsQueued +
       claudeScienceResult.bucketsQueued +
       cursorResult.bucketsQueued +
       kiroResult.bucketsQueued +

package/src/lib/diagnostics.js

@@ -79,6 +79,7 @@ async function collectTrackerDiagnostics({
   const throttlePath = path.join(trackerDir, "sync.throttle");
   const uploadThrottlePath = path.join(trackerDir, "upload.throttle.json");
   const autoRetryPath = path.join(trackerDir, "auto.retry.json");
+  const syncSkipPath = path.join(trackerDir, "sync.skip.json");
   const codexConfigPath = path.join(codexHome, "config.toml");
   const codeConfigPath = path.join(codeHome, "config.toml");
   const claudeConfigPath = path.join(home, ".claude", "settings.json");
@@ -96,6 +97,7 @@ async function collectTrackerDiagnostics({
   const queueState = (await readJson(queueStatePath)) || { offset: 0 };
   const uploadThrottle = normalizeUploadState(await readJson(uploadThrottlePath));
   const autoRetry = await readJson(autoRetryPath);
+  const syncSkip = await readJson(syncSkipPath);
 
   const queueSize = await safeStatSize(queuePath);
   const offsetBytes = Number(queueState.offset || 0);
@@ -271,6 +273,14 @@ async function collectTrackerDiagnostics({
           }
         : null,
     },
+    sync_skip: syncSkip?.at
+      ? {
+          at: syncSkip.at,
+          reason: typeof syncSkip.reason === "string" ? syncSkip.reason : null,
+          detail: typeof syncSkip.detail === "string" ? syncSkip.detail : null,
+          lock_path: redactValue(syncSkip.lockPath, home),
+        }
+      : null,
     auto_retry: autoRetryAt
       ? {
           next_retry_at: autoRetryAt,

package/src/lib/fs.js

@@ -51,6 +51,7 @@ async function chmod600IfPossible(filePath) {
 const LOCK_STALE_MS = 5 * 60 * 1000; // 5 minutes
 const LOCK_HEARTBEAT_MS = 30 * 1000;
 const MAX_RECLAIM_DEPTH = 4;
+const MAX_RECLAIM_SWEEP_DEPTH = 64;
 const TRANSITION_GUARD_RETRY_MS = 5;
 const TRANSITION_GUARD_ATTEMPTS = 1000;
 
@@ -124,6 +125,66 @@ async function existingLockCanBeReclaimed(lockPath) {
   }
 }
 
+async function inspectLock(lockPath) {
+  let raw = null;
+  try {
+    raw = await fs.readFile(lockPath, "utf8");
+  } catch (e) {
+    if (e?.code === "ENOENT") return { exists: false, pid: null, alive: false };
+    return { exists: true, pid: null, alive: true };
+  }
+  const owner = parseLockOwner(raw);
+  if (!owner) return { exists: true, pid: null, alive: true };
+  return { exists: true, pid: owner.pid, alive: isProcessAlive(owner.pid) };
+}
+
+// Drop an abandoned lock file. The rename makes the removal atomic, so two
+// sweepers racing on the same debris cannot delete a lease installed in
+// between: only the winner of the rename removes anything.
+async function removeAbandonedLockFile(lockPath) {
+  if (!(await existingLockCanBeReclaimed(lockPath))) return false;
+  const quarantinePath = `${lockPath}.stale.${process.pid}.${crypto.randomUUID()}`;
+  try {
+    await fs.rename(lockPath, quarantinePath);
+  } catch (_e) {
+    return false;
+  }
+  const owner = parseLockOwner(await fs.readFile(quarantinePath, "utf8").catch(() => ""));
+  if (owner) {
+    await fs.unlink(heartbeatPathFor(lockPath, owner.token)).catch(() => {});
+  }
+  await fs.unlink(quarantinePath).catch(() => {});
+  return true;
+}
+
+// A sync killed while it held a transition guard leaves `${lockPath}.reclaim`
+// behind, and the next reclaimer then nests its own guard on top of that
+// orphan. Four nested levels exhaust MAX_RECLAIM_DEPTH, after which every
+// acquisition gives up forever instead of healing (issue #431). Recursion
+// cannot clean the chain — each level needs a guard one level deeper — so sweep
+// it iteratively. Only levels whose owner is dead or whose heartbeat expired are
+// removed, deepest first: dropping a shallow guard while a deeper orphan
+// survives would just rebuild the same clogged chain on the next attempt.
+async function sweepAbandonedReclaimGuards(lockPath) {
+  const chain = [];
+  let guardPath = lockPath;
+  for (let depth = 0; depth < MAX_RECLAIM_SWEEP_DEPTH; depth += 1) {
+    guardPath = `${guardPath}.reclaim`;
+    try {
+      await fs.access(guardPath);
+    } catch (_e) {
+      break;
+    }
+    chain.push(guardPath);
+  }
+
+  let removed = 0;
+  for (let index = chain.length - 1; index >= 0; index -= 1) {
+    if (await removeAbandonedLockFile(chain[index])) removed += 1;
+  }
+  return removed > 0;
+}
+
 function startLockHeartbeat(handle, heartbeatHandle) {
   const beat = async () => {
     try {
@@ -210,6 +271,7 @@ async function openLock(
     beforeReleaseUnlink = null,
     reclaimDepth = 0,
     serializeRelease = true,
+    sweptReclaimGuards = false,
   } = {},
 ) {
   try {
@@ -264,7 +326,22 @@ async function openLock(
           reclaimDepth: reclaimDepth + 1,
           serializeRelease: false,
         });
-        if (!reclaimGuard) return null;
+        if (!reclaimGuard) {
+          // Either a live reclaimer holds the guard (nothing to do) or the guard
+          // chain is clogged with abandoned guards. Sweeping the latter is the
+          // only escape, and it is attempted once per acquisition. beforeReclaim
+          // already ran, so the retry must not invoke it a second time.
+          if (!sweptReclaimGuards && (await sweepAbandonedReclaimGuards(lockPath))) {
+            return openLock(lockPath, {
+              quietIfLocked,
+              beforeReleaseUnlink,
+              reclaimDepth,
+              serializeRelease,
+              sweptReclaimGuards: true,
+            });
+          }
+          return null;
+        }
 
         let quarantinePath = null;
         try {
@@ -326,4 +403,5 @@ module.exports = {
   writeJson,
   chmod600IfPossible,
   openLock,
+  inspectLock,
 };