tokentracker-cli 0.79.8 → 0.79.9

package/src/commands/init.js

@@ -21,9 +21,11 @@ const {
 } = require("../lib/codex-config");
 const {
   upsertClaudeHook,
+  upsertClaudeUsageHooks,
   buildClaudeHookCommand,
   buildHookCommand,
   isClaudeHookConfigured,
+  areClaudeUsageHooksConfigured,
 } = require("../lib/claude-config");
 const {
   resolveGeminiConfigDir,
@@ -418,6 +420,78 @@ async function repairCodexNotifyIntegration({ home = os.homedir(), trackerDir, b
   return { ...result, skippedReason: null, notifyPath };
 }
 
+async function repairRuntimeIntegrations({
+  home = os.homedir(),
+  trackerDir,
+  binDir,
+  safeMode = true,
+} = {}) {
+  const paths = trackerDir && binDir ? { trackerDir, binDir } : await resolveTrackerPaths({ home });
+  const resolvedTrackerDir = trackerDir || paths.trackerDir;
+  const resolvedBinDir = binDir || paths.binDir;
+  const notifyPath = await writeNotifyHandler({
+    trackerDir: resolvedTrackerDir,
+    binDir: resolvedBinDir,
+  });
+  const context = buildIntegrationTargets({
+    home,
+    trackerDir: resolvedTrackerDir,
+    notifyPath,
+  });
+  const integrations = {};
+  const warnings = [];
+
+  const attempt = async (key, work) => {
+    try {
+      integrations[key] = await work();
+    } catch (error) {
+      integrations[key] = { changed: false, skippedReason: "repair-failed" };
+      warnings.push({ integration: key, error: error?.message || String(error) });
+    }
+  };
+
+  await attempt("codex", () => repairCodexNotifyIntegration({
+    home,
+    trackerDir: resolvedTrackerDir,
+    binDir: resolvedBinDir,
+    safeMode,
+  }));
+
+  const hookRepairs = [
+    ["claude", context.claudeDir, () => upsertClaudeUsageHooks({
+      settingsPath: context.claudeSettingsPath,
+      hookCommand: context.claudeHookCommand,
+    })],
+    ["gemini", context.geminiConfigDir, () => upsertGeminiHook({
+      settingsPath: context.geminiSettingsPath,
+      hookCommand: context.geminiHookCommand,
+    })],
+    ["codebuddy", context.codebuddyDir, () => upsertClaudeHook({
+      settingsPath: context.codebuddySettingsPath,
+      hookCommand: context.codebuddyHookCommand,
+    })],
+    ["workbuddy", context.workbuddyDir, () => upsertClaudeHook({
+      settingsPath: context.workbuddySettingsPath,
+      hookCommand: context.workbuddyHookCommand,
+    })],
+  ];
+  for (const [key, configDir, repair] of hookRepairs) {
+    if (await isDir(configDir)) await attempt(key, repair);
+    else integrations[key] = { changed: false, skippedReason: "config-missing" };
+  }
+
+  if (await isDir(context.opencodeConfigDir)) {
+    await attempt("opencode", () => upsertOpencodePlugin({
+      configDir: context.opencodeConfigDir,
+      notifyPath,
+    }));
+  } else {
+    integrations.opencode = { changed: false, skippedReason: "config-missing" };
+  }
+
+  return { notifyPath, integrations, warnings };
+}
+
 function buildIntegrationTargets({ home, trackerDir, notifyPath }) {
   const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
   const codexConfigPath = path.join(codexHome, "config.toml");
@@ -495,7 +569,7 @@ async function applyIntegrationSetup({ home, trackerDir, notifyPath, notifyOrigi
 
   const claudeDirExists = await isDir(context.claudeDir);
   if (claudeDirExists) {
-    await upsertClaudeHook({
+    await upsertClaudeUsageHooks({
       settingsPath: context.claudeSettingsPath,
       hookCommand: context.claudeHookCommand,
     });
@@ -787,7 +861,7 @@ async function previewIntegrations({ context }) {
 
   const claudeDirExists = await isDir(context.claudeDir);
   if (claudeDirExists) {
-    const configured = await isClaudeHookConfigured({
+    const configured = await areClaudeUsageHooksConfigured({
       settingsPath: context.claudeSettingsPath,
       hookCommand: context.claudeHookCommand,
     });
@@ -1071,7 +1145,6 @@ const codexOriginalPath = ${JSON.stringify(originalPath)};
 const codeOriginalPath = ${JSON.stringify(path.join(trackerDir, "code_notify_original.json"))};
 const trackerBinPath = ${JSON.stringify(trackerBinPath)};
   const depsMarkerPath = path.join(trackerDir, 'app', 'bin', 'tracker.js');
-  const configPath = path.join(trackerDir, 'config.json');
 const fallbackPkg = ${JSON.stringify(fallbackPkg)};
 const selfPath = path.resolve(__filename);
 const home = os.homedir();
@@ -1109,18 +1182,10 @@ if (debugEnabled) {
 // Throttle spawn: at most once per 20 seconds.
 try {
     const throttlePath = path.join(trackerDir, 'sync.throttle');
-    let deviceToken = process.env.TOKENTRACKER_DEVICE_TOKEN || null;
-    if (!deviceToken) {
-      try {
-        const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        if (cfg && typeof cfg.deviceToken === 'string') deviceToken = cfg.deviceToken;
-      } catch (_) {}
-    }
-    const canSync = Boolean(deviceToken && deviceToken.length > 0);
     const now = Date.now();
     let last = 0;
     try { last = Number(fs.readFileSync(throttlePath, 'utf8')) || 0; } catch (_) {}
-    if (canSync && now - last > 20_000) {
+    if (now - last > 20_000) {
     try { fs.writeFileSync(throttlePath, String(now), 'utf8'); } catch (_) {}
     const hasLocalRuntime = fs.existsSync(trackerBinPath);
     const hasLocalDeps = fs.existsSync(depsMarkerPath);
@@ -1241,6 +1306,7 @@ module.exports = {
   buildNotifyHandler,
   installLocalTrackerApp,
   repairCodexNotifyIntegration,
+  repairRuntimeIntegrations,
 };
 
 async function probeFile(p) {

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();