tokentracker-cli 0.79.8 → 0.80.0

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 },
@@ -1053,15 +1054,17 @@ function createLocalApiHandler({ queuePath }) {
   // sync is on. Cloud sync is a dashboard (WebView) preference persisted in
   // localStorage; the dashboard mirrors it here via POST
   // /functions/tokentracker-cloud-sync-pref so the auth-unaware popover can key
-  // off the same flag. Defaults OFF, exactly like the dashboard toggle.
+  // off the same flag. Defaults ON, exactly like the dashboard toggle — every
+  // consumer additionally requires a relayed refresh token, so the default only
+  // takes effect for signed-in users; an explicit {enabled:false} still wins.
   const cloudSyncPrefPath = path.join(trackerDataDir, "cloud-sync-pref.json");
   let cloudSyncPrefCache;
   function getCloudSyncPref() {
     if (cloudSyncPrefCache === undefined) {
       try {
-        cloudSyncPrefCache = JSON.parse(fs.readFileSync(cloudSyncPrefPath, "utf8"))?.enabled === true;
+        cloudSyncPrefCache = JSON.parse(fs.readFileSync(cloudSyncPrefPath, "utf8"))?.enabled !== false;
       } catch {
-        cloudSyncPrefCache = false;
+        cloudSyncPrefCache = true;
       }
     }
     return cloudSyncPrefCache;
@@ -1693,6 +1696,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 +1728,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();
@@ -2572,14 +2581,18 @@ function createLocalApiHandler({ queuePath }) {
     if (p === "/functions/tokentracker-usage-limits") {
       const { getUsageLimits, resetUsageLimitsCache } = require("./usage-limits");
       try {
-        const forceRefresh = url.searchParams.get("refresh");
-        if (forceRefresh === "1" || forceRefresh === "true") {
+        const refreshParam = url.searchParams.get("refresh");
+        const forceRefresh = refreshParam === "1" || refreshParam === "true";
+        if (forceRefresh) {
           resetUsageLimitsCache();
         }
         const data = await getUsageLimits({
           home: os.homedir(),
           env: process.env,
           platform: process.platform,
+          // Punches through the Claude disk fresh-cache (but not the 429
+          // cooldown) — an explicit user refresh should hit upstream.
+          forceRefresh,
         });
         json(res, data);
       } catch (e) {

package/src/lib/openclaw-session-plugin.js

@@ -312,6 +312,19 @@ async function removeOpenclawSessionPluginConfig({
 }
 
 function runOpenclawCli(args, env = process.env) {
+  // Test-only escape hatch: skip spawning the real `openclaw` CLI. Behaves like
+  // the CLI being absent (which is the CI environment anyway), so callers take
+  // their graceful skip path. Avoids a ~2s `plugins install --link` per cmdInit
+  // on dev machines that happen to have openclaw installed.
+  if ((env && env.TOKENTRACKER_SKIP_OPENCLAW_CLI) === "1") {
+    return {
+      code: 1,
+      skippedReason: "openclaw-cli-missing",
+      error: "skipped via TOKENTRACKER_SKIP_OPENCLAW_CLI",
+      stdout: "",
+      stderr: "",
+    };
+  }
   let res;
   try {
     res = cp.spawnSync("openclaw", args, {