ccusage-tracker 0.1.0 → 0.1.2

package/dist/index.js

@@ -36,11 +36,18 @@ function writeConfig(config) {
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, copyFileSync, mkdirSync as mkdirSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
+var HOOK_TIMEOUT_SEC = 25;
 function getClaudeSettingsPath() {
   return join2(homedir2(), ".claude", "settings.json");
 }
+function sessionEndScriptPath() {
+  return join2(homedir2(), ".config", "ccusage-tracker", "session-end.mjs");
+}
 function getHookCommand() {
-  return "node " + join2(homedir2(), ".config", "ccusage-tracker", "session-end.mjs");
+  return "node " + sessionEndScriptPath() + " --mode=session-end";
+}
+function getStopHookCommand() {
+  return "node " + sessionEndScriptPath() + " --mode=stop";
 }
 function getStartHookCommand() {
   return "node " + join2(homedir2(), ".config", "ccusage-tracker", "session-start.mjs");
@@ -48,32 +55,62 @@ function getStartHookCommand() {
 function isCcusageTrackerHook(command) {
   return !!command && command.includes("ccusage-tracker");
 }
-function appendHookIfMissing(existing, command) {
-  const present = existing.some((m) => m.hooks?.some((h) => isCcusageTrackerHook(h.command)));
-  if (present) {
-    return { matchers: existing, installed: false };
+function matcherEquivalent(a, b) {
+  const norm = (s) => s === "" ? "*" : s;
+  return norm(a) === norm(b);
+}
+function upsertHook(existing, command, opts = {}) {
+  const newEntry = { type: "command", command };
+  if (opts.timeout !== undefined)
+    newEntry.timeout = opts.timeout;
+  const newMatcher = { matcher: opts.matcher ?? "*", hooks: [newEntry] };
+  const filtered = existing.map((m) => ({
+    matcher: m.matcher,
+    hooks: (m.hooks ?? []).filter((h) => !isCcusageTrackerHook(h.command))
+  })).filter((m) => m.hooks.length > 0);
+  const next = [...filtered, newMatcher];
+  const changed = !sameMatchers(existing, next);
+  return { matchers: changed ? next : existing, changed };
+}
+function sameMatchers(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    if (!matcherEquivalent(a[i].matcher, b[i].matcher))
+      return false;
+    const ha = a[i].hooks ?? [];
+    const hb = b[i].hooks ?? [];
+    if (ha.length !== hb.length)
+      return false;
+    for (let j = 0;j < ha.length; j++) {
+      if (ha[j].command !== hb[j].command)
+        return false;
+      if (ha[j].timeout !== hb[j].timeout)
+        return false;
+    }
   }
-  const newMatcher = {
-    matcher: "",
-    hooks: [{ type: "command", command }]
-  };
-  return { matchers: [...existing, newMatcher], installed: true };
+  return true;
 }
 function applyTrackerHooks(settings) {
-  const start = appendHookIfMissing(settings.hooks?.SessionStart ?? [], getStartHookCommand());
-  const end = appendHookIfMissing(settings.hooks?.SessionEnd ?? [], getHookCommand());
-  const updated = start.installed || end.installed ? {
+  const start = upsertHook(settings.hooks?.SessionStart ?? [], getStartHookCommand());
+  const end = upsertHook(settings.hooks?.SessionEnd ?? [], getHookCommand(), { timeout: HOOK_TIMEOUT_SEC });
+  const stop = upsertHook(settings.hooks?.Stop ?? [], getStopHookCommand(), { timeout: HOOK_TIMEOUT_SEC });
+  const anyChanged = start.changed || end.changed || stop.changed;
+  const updated = anyChanged ? {
     ...settings,
     hooks: {
       ...settings.hooks,
       SessionStart: start.matchers,
-      SessionEnd: end.matchers
+      SessionEnd: end.matchers,
+      Stop: stop.matchers
     }
   } : settings;
   return {
     updated,
-    sessionStartInstalled: start.installed,
-    sessionEndInstalled: end.installed
+    sessionStartChanged: start.changed,
+    sessionEndChanged: end.changed,
+    stopChanged: stop.changed,
+    anyChanged
   };
 }
 function installHook(scripts) {
@@ -83,20 +120,21 @@ function installHook(scripts) {
   if (existsSync2(settingsPath)) {
     const raw = readFileSync2(settingsPath, "utf-8");
     settings = JSON.parse(raw);
-    const backupPath = settingsPath + ".backup";
-    copyFileSync(settingsPath, backupPath);
-    backedUp = true;
   }
   const destDir = join2(homedir2(), ".config", "ccusage-tracker");
   mkdirSync2(destDir, { recursive: true });
   writeFileSync2(join2(destDir, "session-end.mjs"), scripts.sessionEnd);
   writeFileSync2(join2(destDir, "session-start.mjs"), scripts.sessionStart);
-  const { updated, sessionStartInstalled, sessionEndInstalled } = applyTrackerHooks(settings);
-  if (sessionStartInstalled || sessionEndInstalled) {
+  const { updated, sessionStartChanged, sessionEndChanged, stopChanged, anyChanged } = applyTrackerHooks(settings);
+  if (anyChanged) {
+    if (existsSync2(settingsPath)) {
+      copyFileSync(settingsPath, settingsPath + ".backup");
+      backedUp = true;
+    }
     writeFileSync2(settingsPath, JSON.stringify(updated, null, 2) + `
 `);
   }
-  return { sessionEndInstalled, sessionStartInstalled, backedUp };
+  return { sessionEndChanged, sessionStartChanged, stopChanged, backedUp };
 }
 function isHookInstalled() {
   const settingsPath = getClaudeSettingsPath();
@@ -104,21 +142,31 @@ function isHookInstalled() {
     return false;
   try {
     const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
-    return settings.hooks?.SessionEnd?.some((m) => m.hooks?.some((h) => isCcusageTrackerHook(h.command))) ?? false;
+    const hasIn = (arr) => arr?.some((m) => m.hooks?.some((h) => isCcusageTrackerHook(h.command))) ?? false;
+    return hasIn(settings.hooks?.Stop) || hasIn(settings.hooks?.SessionEnd);
   } catch {
     return false;
   }
 }
 
 // src/commands/setup.ts
-function defaultPrompt(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
+var sharedRl = null;
+var lineIterator = null;
+async function defaultPrompt(question) {
+  if (!sharedRl || !lineIterator) {
+    sharedRl = createInterface({ input: process.stdin, output: process.stdout });
+    lineIterator = sharedRl[Symbol.asyncIterator]();
+  }
+  process.stdout.write(question);
+  const { value, done } = await lineIterator.next();
+  return done ? "" : value.trim();
+}
+function closeSharedPrompt() {
+  if (sharedRl) {
+    sharedRl.close();
+    sharedRl = null;
+    lineIterator = null;
+  }
 }
 async function defaultCheckServer(serverUrl) {
   try {
@@ -160,6 +208,13 @@ var defaultDeps = {
 };
 async function setupCommand(overrides) {
   const deps = { ...defaultDeps, ...overrides };
+  try {
+    await runSetup(deps);
+  } finally {
+    closeSharedPrompt();
+  }
+}
+async function runSetup(deps) {
   deps.log(`ccusage-tracker setup
 `);
   const name = await deps.prompt("Your name: ");
@@ -194,14 +249,15 @@ Config saved.`);
   ]);
   if (sessionEnd && sessionStart) {
     try {
-      const { sessionEndInstalled, sessionStartInstalled, backedUp } = deps.installHook({
+      const { sessionEndChanged, sessionStartChanged, stopChanged, backedUp } = deps.installHook({
         sessionEnd,
         sessionStart
       });
-      if (sessionEndInstalled || sessionStartInstalled) {
-        deps.log("SessionStart + SessionEnd hooks installed." + (backedUp ? " (settings.json backed up)" : ""));
+      const anyChanged = sessionEndChanged || sessionStartChanged || stopChanged;
+      if (anyChanged) {
+        deps.log("SessionStart + SessionEnd + Stop hooks installed/updated." + (backedUp ? " (settings.json backed up)" : ""));
       } else {
-        deps.log("SessionStart + SessionEnd hooks already installed.");
+        deps.log("SessionStart + SessionEnd + Stop hooks already up to date.");
       }
     } catch (err) {
       deps.warn("Warning: Could not install hooks automatically. " + err.message);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccusage-tracker",
-  "version": "0.1.0",
-  "description": "CLI for ccusage-tracker — install Claude Code SessionStart/SessionEnd hooks to report token usage to a self-hosted team tracker.",
+  "version": "0.1.2",
+  "description": "CLI for ccusage-tracker — install Claude Code SessionStart/SessionEnd/Stop hooks to report token usage to a self-hosted team tracker.",
   "type": "module",
   "bin": {
     "ccusage-tracker": "dist/index.js",