tokentracker-cli 0.79.7 → 0.79.9

package/src/commands/serve.js

@@ -22,6 +22,7 @@ const WSL_DEFAULT_PORT = 7681;
 const DEFAULT_MAX_PORT_ATTEMPTS = 20;
 const NPM_PACKAGE_NAME = "tokentracker-cli";
 const LOCAL_BIND_HOST = "127.0.0.1";
+const NATIVE_BACKGROUND_SYNC_INTERVAL_MS = 60_000;
 const STATIC_ASSET_EXTENSIONS = new Set([
   ".css",
   ".gif",
@@ -71,11 +72,13 @@ async function cmdServe(argv) {
   }
 
   try {
-    const { installLocalTrackerApp, repairCodexNotifyIntegration } = require("./init");
+    const { installLocalTrackerApp, repairRuntimeIntegrations } = require("./init");
     await installLocalTrackerApp({ appDir: path.join(trackerDir, "app") });
-    const repairResult = await repairCodexNotifyIntegration({ trackerDir, binDir, safeMode: true });
-    if (repairResult?.skippedReason && repairResult.skippedReason !== "config-missing") {
-      process.stdout.write(`Codex notify repair skipped: ${repairResult.skippedReason}\n`);
+    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`);
@@ -217,6 +220,18 @@ async function cmdServe(argv) {
 
   await maybeShowStarCta({ trackerDir });
 
+  // Native desktop apps keep this server alive even when the dashboard window
+  // is closed. Provider hooks are the fast path, but they can be removed by a
+  // tool update or skipped by a provider. Scan every local source once a
+  // minute as a bounded fallback so the queue cannot remain stale indefinitely.
+  // `--no-sync` still skips the blocking startup sync; this periodic pass is
+  // native-shell-only and uses the lightweight local mode (no cloud upload,
+  // Cursor network request, or deep Codex archive scan).
+  const nativeBackgroundSync = startNativeBackgroundSync({
+    onError: (e) =>
+      process.stdout.write(`Background local sync warning: ${e?.message || e}\n`),
+  });
+
   // Anonymous daily heartbeat (see src/lib/telemetry.js for the privacy
   // contract). Fire-and-forget at startup, then re-checked every 6 hours so
   // long-lived embedded-app servers still count on later days; the shared
@@ -238,6 +253,7 @@ async function cmdServe(argv) {
   // 5. Graceful shutdown
   const shutdown = () => {
     process.stdout.write("\nShutting down...\n");
+    nativeBackgroundSync?.stop();
     server.close(() => process.exit(0));
     setTimeout(() => process.exit(0), 3000);
   };
@@ -248,6 +264,49 @@ async function cmdServe(argv) {
   await new Promise(() => {});
 }
 
+function startNativeBackgroundSync({
+  appShell = process.env.TOKENTRACKER_APP_SHELL,
+  intervalMs = NATIVE_BACKGROUND_SYNC_INTERVAL_MS,
+  runSync,
+  setIntervalFn = setInterval,
+  clearIntervalFn = clearInterval,
+  onError = () => {},
+} = {}) {
+  const normalizedShell = String(appShell || "").trim().toLowerCase();
+  if (normalizedShell !== "macos" && normalizedShell !== "windows") return null;
+
+  const sync = runSync || (async (args) => {
+    const { cmdSync } = require("./sync");
+    await cmdSync(args);
+  });
+  let inFlight = null;
+  const run = () => {
+    if (inFlight) return inFlight;
+    const pending = Promise.resolve()
+      .then(() => sync(["--auto", "--background", "--all-local-sources"]))
+      .catch((error) => {
+        try { onError(error); } catch (_e) {}
+      })
+      .finally(() => {
+        if (inFlight === pending) inFlight = null;
+      });
+    inFlight = pending;
+    return pending;
+  };
+
+  const timer = setIntervalFn(() => {
+    void run();
+  }, intervalMs);
+  timer?.unref?.();
+
+  return {
+    run,
+    stop() {
+      clearIntervalFn(timer);
+    },
+  };
+}
+
 function findPidOnPort(port) {
   try {
     const out = cp.execFileSync("lsof", ["-ti", `tcp:${port}`], { encoding: "utf8", timeout: 5000 });
@@ -455,4 +514,6 @@ module.exports = {
   isRunningUnderWsl,
   resolveDefaultPort,
   shouldServeSpaFallback,
+  startNativeBackgroundSync,
+  NATIVE_BACKGROUND_SYNC_INTERVAL_MS,
 };

package/src/commands/status.js

@@ -8,6 +8,7 @@ const { readJson } = require("../lib/fs");
 const { readCodexNotify, readEveryCodeNotify } = require("../lib/codex-config");
 const {
   isClaudeHookConfigured,
+  areClaudeUsageHooksConfigured,
   buildClaudeHookCommand,
   buildHookCommand,
 } = require("../lib/claude-config");
@@ -155,7 +156,7 @@ async function cmdStatus(argv = []) {
   const everyCodeNotify = await readEveryCodeNotify(codeConfigPath);
   const everyCodeConfigured =
     Array.isArray(everyCodeNotify) && everyCodeNotify.length > 0;
-  const claudeHookConfigured = await isClaudeHookConfigured({
+  const claudeHookConfigured = await areClaudeUsageHooksConfigured({
     settingsPath: claudeSettingsPath,
     hookCommand: claudeHookCommand,
   });

package/src/commands/sync.js

@@ -330,11 +330,18 @@ async function cmdSync(argv) {
 
     const autoSourceScope = resolveAutoSourceScope(opts);
     const isBackgroundLightweightSync = opts.auto && opts.background && !opts.drain;
+    const isBackgroundAllLocalSync = isBackgroundLightweightSync && opts.allLocalSources;
     const isFullSourceScan = !autoSourceScope && !isBackgroundLightweightSync;
     const sourceAllowed = (...sources) => {
       if (isBackgroundLightweightSync) {
         if (autoSourceScope) {
-          return BACKGROUND_AUTO_SYNC_SOURCES.has(autoSourceScope) && sources.includes(autoSourceScope);
+          return (
+            (isBackgroundAllLocalSync || BACKGROUND_AUTO_SYNC_SOURCES.has(autoSourceScope)) &&
+            sources.includes(autoSourceScope)
+          );
+        }
+        if (isBackgroundAllLocalSync) {
+          return sources.some((source) => AUTO_SYNC_SOURCES.has(source));
         }
         return sources.some((source) => BACKGROUND_AUTO_SYNC_SOURCES.has(source));
       }
@@ -1998,6 +2005,7 @@ function parseArgs(argv) {
     source: null,
     drain: false,
     background: false,
+    allLocalSources: false,
     repairGrok: false,
   };
   for (let i = 0; i < argv.length; i++) {
@@ -2013,6 +2021,7 @@ function parseArgs(argv) {
     else if (a.startsWith("--source=")) out.source = normalizeSyncSource(a.slice("--source=".length));
     else if (a === "--drain") out.drain = true;
     else if (a === "--background" || a === "--lightweight") out.background = true;
+    else if (a === "--all-local-sources") out.allLocalSources = true;
     else if (a === "--repair-grok") out.repairGrok = true;
     else throw new Error(`Unknown option: ${a}`);
   }

package/src/commands/uninstall.js

@@ -3,7 +3,12 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { restoreCodexNotify, restoreEveryCodeNotify } = require("../lib/codex-config");
-const { removeClaudeHook, buildClaudeHookCommand, buildHookCommand } = require("../lib/claude-config");
+const {
+  removeClaudeHook,
+  removeClaudeUsageHooks,
+  buildClaudeHookCommand,
+  buildHookCommand,
+} = require("../lib/claude-config");
 const {
   resolveGeminiConfigDir,
   resolveGeminiSettingsPath,
@@ -64,7 +69,10 @@ async function cmdUninstall(argv) {
       })
     : { restored: false, skippedReason: "config-missing" };
   const claudeRemove = claudeConfigExists
-    ? await removeClaudeHook({ settingsPath: claudeSettingsPath, hookCommand: claudeHookCommand })
+    ? await removeClaudeUsageHooks({
+        settingsPath: claudeSettingsPath,
+        hookCommand: claudeHookCommand,
+      })
     : { removed: false, skippedReason: "config-missing" };
   const codebuddyRemove = codebuddyConfigExists
     ? await removeClaudeHook({

package/src/lib/claude-config.js

@@ -4,56 +4,74 @@ const path = require("node:path");
 const { ensureDir, readJson, writeJson } = require("./fs");
 
 const DEFAULT_EVENT = "SessionEnd";
+const CLAUDE_USAGE_EVENTS = ["Stop", DEFAULT_EVENT];
 
 async function upsertClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  return upsertClaudeHooks({ settingsPath, hookCommand, events: [event] });
+}
+
+async function upsertClaudeUsageHooks({ settingsPath, hookCommand }) {
+  return upsertClaudeHooks({ settingsPath, hookCommand, events: CLAUDE_USAGE_EVENTS });
+}
+
+async function upsertClaudeHooks({ settingsPath, hookCommand, events }) {
   const existing = await readJson(settingsPath);
   const settings = normalizeSettings(existing);
   const hooks = normalizeHooks(settings.hooks);
-  const entries = normalizeEntries(hooks[event]);
-
-  const normalized = normalizeEntriesForCommand(entries, hookCommand);
-  if (normalized.changed) {
-    const nextHooks = { ...hooks, [event]: normalized.entries };
-    const nextSettings = { ...settings, hooks: nextHooks };
-    const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
-    return { changed: true, backupPath };
-  }
+  const nextHooks = { ...hooks };
+  let changed = false;
 
-  if (hasHook(entries, hookCommand)) {
-    return { changed: false, backupPath: null };
+  for (const event of normalizeEventList(events)) {
+    const entries = normalizeEntries(hooks[event]);
+    const normalized = normalizeEntriesForCommand(entries, hookCommand);
+    let nextEntries = normalized.entries;
+    if (!hasHook(nextEntries, hookCommand)) {
+      nextEntries = nextEntries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
+      changed = true;
+    }
+    if (normalized.changed) changed = true;
+    if (normalized.changed || nextEntries.length !== entries.length) {
+      nextHooks[event] = nextEntries;
+    }
   }
 
-  const nextEntries = entries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
-  const nextHooks = { ...hooks, [event]: nextEntries };
-  const nextSettings = { ...settings, hooks: nextHooks };
+  if (!changed) return { changed: false, backupPath: null };
 
+  const nextSettings = { ...settings, hooks: nextHooks };
   const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
   return { changed: true, backupPath };
 }
 
 async function removeClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  return removeClaudeHooks({ settingsPath, hookCommand, events: [event] });
+}
+
+async function removeClaudeUsageHooks({ settingsPath, hookCommand }) {
+  return removeClaudeHooks({ settingsPath, hookCommand, events: CLAUDE_USAGE_EVENTS });
+}
+
+async function removeClaudeHooks({ settingsPath, hookCommand, events }) {
   const existing = await readJson(settingsPath);
   if (!existing) return { removed: false, skippedReason: "settings-missing" };
 
   const settings = normalizeSettings(existing);
   const hooks = normalizeHooks(settings.hooks);
-  const entries = normalizeEntries(hooks[event]);
-  if (entries.length === 0) return { removed: false, skippedReason: "hook-missing" };
-
+  const nextHooks = { ...hooks };
   let removed = false;
-  const nextEntries = [];
-  for (const entry of entries) {
-    const res = stripHookFromEntry(entry, hookCommand);
-    if (res.removed) removed = true;
-    if (res.entry) nextEntries.push(res.entry);
+  for (const event of normalizeEventList(events)) {
+    const entries = normalizeEntries(hooks[event]);
+    const nextEntries = [];
+    for (const entry of entries) {
+      const res = stripHookFromEntry(entry, hookCommand);
+      if (res.removed) removed = true;
+      if (res.entry) nextEntries.push(res.entry);
+    }
+    if (nextEntries.length > 0) nextHooks[event] = nextEntries;
+    else delete nextHooks[event];
   }
 
   if (!removed) return { removed: false, skippedReason: "hook-missing" };
 
-  const nextHooks = { ...hooks };
-  if (nextEntries.length > 0) nextHooks[event] = nextEntries;
-  else delete nextHooks[event];
-
   const nextSettings = { ...settings };
   if (Object.keys(nextHooks).length > 0) nextSettings.hooks = nextHooks;
   else delete nextSettings.hooks;
@@ -63,12 +81,26 @@ async function removeClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVE
 }
 
 async function isClaudeHookConfigured({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  return areClaudeHooksConfigured({ settingsPath, hookCommand, events: [event] });
+}
+
+async function areClaudeUsageHooksConfigured({ settingsPath, hookCommand }) {
+  return areClaudeHooksConfigured({
+    settingsPath,
+    hookCommand,
+    events: CLAUDE_USAGE_EVENTS,
+  });
+}
+
+async function areClaudeHooksConfigured({ settingsPath, hookCommand, events }) {
   const settings = await readJson(settingsPath);
   if (!settings || typeof settings !== "object") return false;
   const hooks = settings.hooks;
   if (!hooks || typeof hooks !== "object") return false;
-  const entries = normalizeEntries(hooks[event]);
-  return hasHook(entries, hookCommand);
+  return normalizeEventList(events).every((event) => {
+    const entries = normalizeEntries(hooks[event]);
+    return hasHook(entries, hookCommand);
+  });
 }
 
 // Generic Session-hook command builder. CodeBuddy CLI is a Claude-Code fork
@@ -96,6 +128,11 @@ function normalizeEntries(raw) {
   return Array.isArray(raw) ? raw.slice() : [];
 }
 
+function normalizeEventList(events) {
+  const values = Array.isArray(events) ? events : [];
+  return Array.from(new Set(values.filter((event) => typeof event === "string" && event)));
+}
+
 function normalizeCommand(cmd) {
   if (Array.isArray(cmd)) return cmd.map((v) => String(v)).join("\u0000");
   if (typeof cmd === "string") return cmd.trim();
@@ -193,9 +230,13 @@ async function writeClaudeSettings({ settingsPath, settings }) {
 }
 
 module.exports = {
+  CLAUDE_USAGE_EVENTS,
   upsertClaudeHook,
+  upsertClaudeUsageHooks,
   removeClaudeHook,
+  removeClaudeUsageHooks,
   isClaudeHookConfigured,
+  areClaudeUsageHooksConfigured,
   buildClaudeHookCommand,
   buildHookCommand,
   // Aliases for callers that want a name unbiased toward Claude (the schema

package/src/lib/diagnostics.js

@@ -4,7 +4,7 @@ const fs = require("node:fs/promises");
 
 const { readJson } = require("./fs");
 const { readCodexNotify, readEveryCodeNotify } = require("./codex-config");
-const { isClaudeHookConfigured, buildClaudeHookCommand } = require("./claude-config");
+const { areClaudeUsageHooksConfigured, buildClaudeHookCommand } = require("./claude-config");
 const {
   resolveGeminiConfigDir,
   resolveGeminiSettingsPath,
@@ -81,7 +81,7 @@ async function collectTrackerDiagnostics({
     ? everyCodeNotifyRaw.map((v) => redactValue(v, home))
     : null;
   const claudeHookCommand = buildClaudeHookCommand(path.join(binDir, "notify.cjs"));
-  const claudeHookConfigured = await isClaudeHookConfigured({
+  const claudeHookConfigured = await areClaudeUsageHooksConfigured({
     settingsPath: claudeConfigPath,
     hookCommand: claudeHookCommand,
   });

package/src/lib/local-api.js

@@ -685,6 +685,7 @@ function runSyncCommand(extraEnv = {}, opts = {}) {
     const args = [TRACKER_BIN, "sync"];
     if (opts.auto === true) args.push("--auto");
     if (opts.background === true) args.push("--background");
+    if (opts.allLocalSources === true) args.push("--all-local-sources");
     if (opts.drain === true) args.push("--drain");
     const child = spawn(process.execPath, args, {
       env: { ...process.env, ...extraEnv },
@@ -1693,6 +1694,7 @@ function createLocalApiHandler({ queuePath }) {
         const auto = body.auto === true && !drain;
         const background =
           auto && (body.background === true || body.lightweight === true);
+        const allLocalSources = background && body.allLocalSources === true;
         if (typeof body.deviceToken === "string" && body.deviceToken.trim()) {
           extraEnv.TOKENTRACKER_DEVICE_TOKEN = body.deviceToken.trim();
         }
@@ -1724,7 +1726,12 @@ function createLocalApiHandler({ queuePath }) {
             extraEnv.TOKENTRACKER_DEVICE_TOKEN = issuedToken;
           }
         }
-        const result = await runSyncCommand(extraEnv, { drain, auto, background });
+        const result = await runSyncCommand(extraEnv, {
+          drain,
+          auto,
+          background,
+          allLocalSources,
+        });
         try {
           const { resetUsageLimitsCache } = require("./usage-limits");
           resetUsageLimitsCache();