tokentracker-cli 1.5.12 → 1.5.14

package/src/commands/init.js

@@ -11,7 +11,9 @@ const {
   readJson,
   writeJson,
   chmod600IfPossible,
+  openLock,
 } = require("../lib/fs");
+const { copyRuntimeTree, ensureRuntimeDirectory } = require("../lib/runtime-copy");
 const { resolveMimoNativeDbPath } = require("../lib/install-resolver");
 const { resolveDumateDbPaths } = require("../lib/dumate");
 const { expandHome } = require("../lib/scan-roots");
@@ -2291,7 +2293,7 @@ async function installLocalTrackerApp({ appDir }) {
   // Copy the current package's runtime (bin + src) into ~/.tokentracker so notify can run sync without npx.
   const packageRoot = path.resolve(__dirname, "../..");
   const srcFrom = path.join(packageRoot, "src");
-  const binFrom = path.join(packageRoot, "bin", "tracker.js");
+  const binFrom = path.join(packageRoot, "bin");
   const packageJsonFrom = path.join(packageRoot, "package.json");
   const nodeModulesFrom = path.join(packageRoot, "node_modules");
   const dashboardDistFrom = path.join(packageRoot, "dashboard", "dist");
@@ -2308,17 +2310,31 @@ async function installLocalTrackerApp({ appDir }) {
   const nodeModulesTo = path.join(appDir, "node_modules");
   const dashboardDistTo = path.join(appDir, "dashboard", "dist");
 
-  await fs.rm(appDir, { recursive: true, force: true }).catch(() => {});
-  await ensureDir(appDir);
-  await fs.cp(srcFrom, srcTo, { recursive: true });
-  await ensureDir(binToDir);
-  await fs.copyFile(binFrom, binTo);
-  await fs.chmod(binTo, 0o755).catch(() => {});
-  await fs.copyFile(packageJsonFrom, path.join(appDir, "package.json")).catch(() => {});
-  if (await isDir(dashboardDistFrom)) {
-    await fs.cp(dashboardDistFrom, dashboardDistTo, { recursive: true });
+  // Serialize installers: init and desktop startup can overlap. In particular,
+  // one refresh must not prune another writer's atomic temporary files.
+  await ensureDir(path.dirname(appDir));
+  const deadline = Date.now() + 120_000;
+  let lock;
+  while (!(lock = await openLock(`${appDir}.install.lock`, { quietIfLocked: true }))) {
+    if (Date.now() >= deadline) throw new Error("Timed out waiting for local runtime installation");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  try {
+    await ensureRuntimeDirectory(appDir);
+    await copyRuntimeTree(srcFrom, srcTo);
+    await copyRuntimeTree(binFrom, binToDir);
+    await fs.chmod(binTo, 0o755).catch(() => {});
+    if (await isDir(dashboardDistFrom)) {
+      await ensureRuntimeDirectory(path.dirname(dashboardDistTo));
+      await copyRuntimeTree(dashboardDistFrom, dashboardDistTo);
+    } else {
+      await fs.rm(path.dirname(dashboardDistTo), { recursive: true, force: true });
+    }
+    await copyRuntimeDependencies({ from: nodeModulesFrom, to: nodeModulesTo });
+    await copyRuntimeTree(packageJsonFrom, path.join(appDir, "package.json"));
+  } finally {
+    await lock.release();
   }
-  await copyRuntimeDependencies({ from: nodeModulesFrom, to: nodeModulesTo });
 }
 
 async function pathsPointToSameLocation(a, b) {
@@ -2427,15 +2443,13 @@ function readFirstSyncTotals(trackerDir) {
 }
 
 async function copyRuntimeDependencies({ from, to }) {
-  try {
-    const st = await fs.stat(from);
-    if (!st.isDirectory()) return;
-  } catch (_e) {
+  if (!(await isDir(from))) {
+    await fs.rm(to, { recursive: true, force: true });
     return;
   }
 
   try {
-    await fs.cp(from, to, { recursive: true });
+    await copyRuntimeTree(from, to);
   } catch (_e) {
     // Best-effort: missing dependencies will fall back to npx at notify time.
   }

package/src/commands/serve.js

@@ -83,32 +83,9 @@ async function cmdServe(argv) {
   // the setup never commits cursors.json (#961).
   const { trackerDir, binDir } = await resolveTrackerPaths();
 
-  try {
-    const { installLocalTrackerApp, repairRuntimeIntegrations } = require("./init");
-    await installLocalTrackerApp({ appDir: path.join(trackerDir, "app") });
-    const repairResult = await repairRuntimeIntegrations({ trackerDir, binDir, safeMode: true });
-    for (const warning of repairResult?.warnings || []) {
-      process.stdout.write(
-        `Runtime integration repair warning (${warning.integration}): ${warning.error}\n`,
-      );
-    }
-  } catch (e) {
-    process.stdout.write(`Runtime refresh warning: ${e?.message || e}\n`);
-  }
-
-  // Optional sync for non-first-run launches. First-run init still owns its
-  // inline first sync below, after the listener is up.
+  // All runtime maintenance and initial sync run after listen. The dashboard
+  // is served from this package, not the hook runtime installed in trackerDir.
   const needsFirstRunSetup = !fssync.existsSync(path.join(trackerDir, "cursors.json"));
-  if (opts.sync && !needsFirstRunSetup) {
-    process.stdout.write("Syncing local data...\n");
-    try {
-      const { cmdSync } = require("./sync");
-      await cmdSync(["--auto"]);
-      process.stdout.write("Sync done.\n");
-    } catch (e) {
-      process.stdout.write(`Sync warning: ${e?.message || e}\n`);
-    }
-  }
 
   // Resolve paths
   const queuePath = resolveQueuePath();
@@ -240,6 +217,32 @@ async function cmdServe(argv) {
     }
   }
 
+  // A large Windows runtime copy can take tens of seconds. Health probes and
+  // the dashboard must already work while maintenance is in progress.
+  try {
+    const { installLocalTrackerApp, repairRuntimeIntegrations } = require("./init");
+    await installLocalTrackerApp({ appDir: path.join(trackerDir, "app") });
+    const repairResult = await repairRuntimeIntegrations({ trackerDir, binDir, safeMode: true });
+    for (const warning of repairResult?.warnings || []) {
+      process.stdout.write(
+        `Runtime integration repair warning (${warning.integration}): ${warning.error}\n`,
+      );
+    }
+  } catch (e) {
+    process.stdout.write(`Runtime refresh warning: ${e?.message || e}\n`);
+  }
+
+  if (opts.sync && !needsFirstRunSetup) {
+    process.stdout.write("Syncing local data...\n");
+    try {
+      const { cmdSync } = require("./sync");
+      await cmdSync(["--auto"]);
+      process.stdout.write("Sync done.\n");
+    } catch (e) {
+      process.stdout.write(`Sync warning: ${e?.message || e}\n`);
+    }
+  }
+
   // First-time setup AFTER the listener is accepting health probes. Init still
   // runs inline (including first sync) so the dashboard fills in, but native
   // hosts can mark the server Running without racing that sync (#961).

package/src/commands/sync.js

@@ -315,7 +315,7 @@ const DROID_DUP_SESSION_REPAIR_KEY = "droidDupSessionInflationRepair_2026_06";
 const CODEX_COLD_SCAN_AUDIT_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const NOTIFY_LOCK_WAIT_MS = 130_000;
 const NOTIFY_LOCK_POLL_MS = 5_000;
-// Local API sync requests have a 120-second child-process budget. Reserve at
+// Local API sync requests answer within a 120-second wait window. Reserve at
 // least 30 seconds for parsing, persistence, and the response after contention.
 const PRIORITY_LOCK_WAIT_MS = 90_000;
 const PRIORITY_LOCK_POLL_MS = 250;
@@ -1854,7 +1854,7 @@ async function cmdSync(argv, context = {}) {
     if (sourceAllowed("dsh")) {
       await migrateLegacyDeepseekHarnessSource({ cursors, queuePath, queueStatePath });
       const dshSessionFiles = await resolveDshSessionFiles(process.env);
-      if (dshSessionFiles.length > 0) {
+      if (dshSessionFiles.length > 0 || cursors.dsh) {
         if (progress?.enabled) {
           progress.start(
             `Parsing DeepSeek Harness ${renderBar(0)} 0/${formatNumber(
@@ -1873,7 +1873,7 @@ async function cmdSync(argv, context = {}) {
             warnProviderParseFailure(
               "DeepSeek Harness",
               new Error(
-                `${dshResult.deferredMigrations} artifact migration(s) deferred; inspect cursors.dsh.deferredMigrations and retry after the replacement is complete`,
+                `${dshResult.deferredMigrations} accounting repair/artifact migration(s) deferred; inspect cursors.dsh.deferredMigrations, restore unavailable history or complete the replacement, then retry`,
               ),
               opts,
             );

package/src/lib/cursor-store.js

@@ -1850,9 +1850,13 @@ async function fingerprintFile(filePath) {
   }
 }
 
+// Legacy cursors.json is re-imported only when its content may have changed.
+// ctime moves on metadata-only events (chmod, xattr, backup tools); comparing
+// it re-imported a stale snapshot over newer v2 state and forced a full
+// re-read of every session log.
 function sameFingerprint(left, right) {
   if (!left || !right) return left === right;
-  return ["dev", "ino", "size", "mtimeNs", "ctimeNs"]
+  return ["dev", "ino", "size", "mtimeNs"]
     .every((key) => String(left[key]) === String(right[key]));
 }
 

package/src/lib/local-api.js

@@ -26,7 +26,9 @@ const { negotiateEncoding } = require("./accept-encoding");
 const { createLocalUsageTransfer, MAX_BYTES: LOCAL_USAGE_MAX_BYTES } = require("./local-usage-transfer");
 const { fetchProviderServiceStatus } = require("./provider-status");
 
-const SYNC_TIMEOUT_MS = 120_000;
+// How long a local-sync request waits for its sync child before answering.
+// Native clients give up at 130s (macOS) so the server must answer first.
+const SYNC_RESPONSE_WAIT_MS = 120_000;
 // A failed account-view request should not stall every dashboard refresh
 // while an expired session or unreachable backend keeps timing out. The first
 // request still falls back normally; subsequent fan-out requests reuse that
@@ -910,15 +912,9 @@ function runSyncCommand(extraEnv = {}, opts = {}) {
     const finish = (fn, v) => {
       if (settled) return;
       settled = true;
-      clearTimeout(tid);
       opts.signal?.removeEventListener("abort", cancel);
       fn(v);
     };
-    let timedOut = false;
-    const tid = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-    }, SYNC_TIMEOUT_MS);
     child.stdout?.on("data", (c) => {
       stdout += c;
     });
@@ -929,7 +925,6 @@ function runSyncCommand(extraEnv = {}, opts = {}) {
       finish(reject, Object.assign(e, { stdout: trimOutput(stdout), stderr: trimOutput(stderr) }));
     });
     child.on("close", (code) => {
-      if (timedOut) { finish(reject, Object.assign(new Error("Sync timed out"), { code: "SYNC_TIMEOUT", stdout: trimOutput(stdout), stderr: trimOutput(stderr) })); return; }
       if (opts.signal?.aborted) { finish(reject, Object.assign(new Error("Account session changed"), { code: "auth_session_changed", status: 409 })); return; }
       const r = { code: code ?? 1, stdout: trimOutput(stdout), stderr: trimOutput(stderr) };
       if (code === 0) {
@@ -948,6 +943,23 @@ function runSyncCommand(extraEnv = {}, opts = {}) {
   });
 }
 
+// The sync child owns its own lifetime: it holds the sync lock and commits its
+// cursors only after the whole scan finishes. Killing it when the HTTP caller
+// stops waiting discarded that progress, so a backlog longer than one wait
+// window was rescanned and killed on every attempt and never landed. The
+// caller gets an answer after `waitMs`; the child keeps running to completion
+// and only an explicit abort (account session change) terminates it.
+function waitForSyncResponse(syncPromise, waitMs = SYNC_RESPONSE_WAIT_MS) {
+  let tid;
+  const expired = new Promise((_, reject) => {
+    tid = setTimeout(() => reject(Object.assign(
+      new Error("Sync is still running in the background"),
+      { code: "SYNC_RUNNING", status: 503 },
+    )), waitMs);
+  });
+  return Promise.race([syncPromise, expired]).finally(() => clearTimeout(tid));
+}
+
 // ---------------------------------------------------------------------------
 // Project detection helpers
 // ---------------------------------------------------------------------------
@@ -2577,13 +2589,15 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
           waitForLock:
             !drain && !background && Boolean(extraEnv.TOKENTRACKER_DEVICE_TOKEN),
         });
-        controller.done = syncPromise.catch(() => {});
-        const result = await syncPromise.catch((error) => {
+        // The controller tracks the child, not this request: an account switch
+        // must still be able to stop a sync that outlived its HTTP wait.
+        controller.done = syncPromise.catch(() => {}).finally(() => activeCloudSyncs.delete(controller));
+        const result = await waitForSyncResponse(syncPromise).catch((error) => {
           if (uploadGeneration !== localCloudGeneration) throw Object.assign(new Error("Account session changed"), { code: "auth_session_changed", status: 409 });
           const failure = currentCloudUploadFailure(syncStartedAt, { backoff: auto && drain, deviceToken: extraEnv.TOKENTRACKER_DEVICE_TOKEN, attemptId: extraEnv.TOKENTRACKER_LOCAL_SYNC_ATTEMPT_ID });
           if (failure) Object.assign(error, failure);
           throw error;
-        }).finally(() => activeCloudSyncs.delete(controller));
+        });
         if (extraEnv.TOKENTRACKER_DEVICE_TOKEN && uploadGeneration !== localCloudGeneration) throw Object.assign(new Error("Account session changed"), { code: "auth_session_changed", status: 409 });
         const failure = currentCloudUploadFailure(syncStartedAt, { deviceToken: extraEnv.TOKENTRACKER_DEVICE_TOKEN, attemptId: extraEnv.TOKENTRACKER_LOCAL_SYNC_ATTEMPT_ID });
         if (failure) throw Object.assign(new Error("Cloud upload failed"), failure);