tokenmaxxing 0.19.0 → 0.21.0

package/src/lib/settings.ts

@@ -4,7 +4,7 @@
 // are ours outright - tokenmaxxing renders them natively, so any other
 // statusLine command is replaced.
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 import { paths } from "./paths.ts";
@@ -39,11 +39,15 @@ function readSettings(): Settings {
 }
 
 function writeSettings(s: Settings): void {
-  writeFileAtomic(paths.claudeSettings, JSON.stringify(s, null, 2) + "\n", 0o644);
+  // Preserve the user's mode: settings.json can carry an env block with
+  // credentials, and the atomic rename would otherwise widen a 0600 file to
+  // world-readable. A brand-new file starts at the conservative 0600.
+  const mode = existsSync(paths.claudeSettings) ? statSync(paths.claudeSettings).mode & 0o777 : 0o600;
+  writeFileAtomic(paths.claudeSettings, JSON.stringify(s, null, 2) + "\n", mode);
 }
 
 /** True if a hook/statusline command string is one tokenmaxxing installed. */
-export function isOurCommand(cmd: string | undefined): boolean {
+function isOurCommand(cmd: string | undefined): boolean {
   if (!cmd) return false;
   return (
     cmd.includes(SUBCMD.statusline) ||
@@ -55,36 +59,69 @@ export function isOurCommand(cmd: string | undefined): boolean {
   );
 }
 
+/** The exact command string installSettings writes for a subcommand; doctor
+ *  compares against it verbatim, so a green check proves the canonical entry. */
+function ourCommand(sub: string): string {
+  return `${JSON.stringify(installedBin())} ${sub}`;
+}
+
 function ourHookGroup(sub: string): HookGroup {
-  return { hooks: [{ type: "command", command: `${JSON.stringify(installedBin())} ${sub}` }] };
+  return { hooks: [{ type: "command", command: ourCommand(sub) }] };
 }
 
 function appendHook(s: Settings, event: string, sub: string): void {
   s.hooks ??= {};
   s.hooks[event] ??= [];
   const arr = s.hooks[event]!;
-  const present = arr.some((g) => g.hooks?.some((h) => h.command?.includes(sub)));
+  const present = arr.some((g) => g.hooks.some((h) => h.command === ourCommand(sub)));
   if (!present) arr.push(ourHookGroup(sub));
 }
 
+/** True only for a command tokenmaxxing itself wrote - the exact historical
+ *  shape `"<...>/tokenmaxxing" <sub>` at ANY install path (so stale
+ *  pre-relocation entries match too). A foreign command that merely mentions
+ *  the subcommand or the path as text is NOT ours and must survive removal. */
+/** Structural ownership: exactly `"<path>/tokenmaxxing" <sub>`. Exported for
+ *  the codex hooks.json installer, whose old includes()-based match deleted
+ *  foreign hooks sharing a group and misclassified commands merely mentioning
+ *  the subcommand (closing-review catch; the same class settings.ts's own
+ *  removeHook was fixed for in PR #31). */
+export function isOurHookCommand(cmd: string, sub: string): boolean {
+  if (!cmd.endsWith(` ${sub}`)) return false;
+  const quotedPath = cmd.slice(0, cmd.length - (sub.length + 1));
+  if (!quotedPath.startsWith('"') || !quotedPath.endsWith('"')) return false;
+  let path: unknown;
+  try {
+    path = JSON.parse(quotedPath);
+  } catch {
+    return false;
+  }
+  const parsed = z.string().safeParse(path);
+  return parsed.success && parsed.data.endsWith("/tokenmaxxing");
+}
+
 function removeHook(s: Settings, event: string, sub: string): void {
   const arr = s.hooks?.[event];
   if (!arr) return;
-  s.hooks![event] = arr.filter((g) => !g.hooks?.some((h) => h.command?.includes(sub)));
+  // Strip only VERIFIED tokenmaxxing-owned entries from WITHIN each group:
+  // foreign hooks sharing a group - or merely mentioning our strings - survive
+  // (review catches, PR #31), and a group is dropped only once it is empty.
+  for (const g of arr) g.hooks = g.hooks.filter((h) => !isOurHookCommand(h.command, sub));
+  s.hooks![event] = arr.filter((g) => g.hooks.length > 0);
   if (s.hooks![event]!.length === 0) delete s.hooks![event];
 }
 
-/** Install the entries: take both statusLine slots, append our hooks. */
+/** Install the entries: take both statusLine slots, append our hooks. Stale
+ *  same-subcommand hooks from an OLD install path are dropped first, so a
+ *  TOKENMAXXING_HOME relocation rewrites the entries instead of leaving dead
+ *  paths that read as installed (relocation residue is how the supervisor
+ *  recursion incident started). Foreign hooks are untouched. */
 export function installSettings(): void {
   const s = readSettings();
-  s.statusLine = {
-    type: "command",
-    command: `${JSON.stringify(installedBin())} ${SUBCMD.statusline}`,
-  };
-  s.subagentStatusLine = {
-    type: "command",
-    command: `${JSON.stringify(installedBin())} ${SUBCMD.subagentStatusline}`,
-  };
+  s.statusLine = { type: "command", command: ourCommand(SUBCMD.statusline) };
+  s.subagentStatusLine = { type: "command", command: ourCommand(SUBCMD.subagentStatusline) };
+  removeHook(s, "Stop", SUBCMD.stop);
+  removeHook(s, "SessionStart", SUBCMD.sessionStart);
   appendHook(s, "Stop", SUBCMD.stop);
   appendHook(s, "SessionStart", SUBCMD.sessionStart);
   writeSettings(s);
@@ -110,11 +147,15 @@ export type SettingsCheck = z.infer<typeof SettingsCheckSchema>;
 
 export function checkSettings(): SettingsCheck {
   const s = readSettings();
+  // Exact-command identity (review catch, PR #31): only the verbatim string
+  // installSettings writes counts as installed. A hook pointing at an OLD
+  // install path reads as broken, and a foreign command that merely mentions
+  // the path or subcommand as text never green-lights.
   const has = (event: string, sub: string) =>
-    !!s.hooks?.[event]?.some((g) => g.hooks?.some((h) => h.command?.includes(sub)));
+    !!s.hooks?.[event]?.some((g) => g.hooks.some((h) => h.command === ourCommand(sub)));
   return {
-    statusLineOk: isOurCommand(s.statusLine?.command),
-    subagentStatusLineOk: isOurCommand(s.subagentStatusLine?.command),
+    statusLineOk: s.statusLine?.command === ourCommand(SUBCMD.statusline),
+    subagentStatusLineOk: s.subagentStatusLine?.command === ourCommand(SUBCMD.subagentStatusline),
     stopOk: has("Stop", SUBCMD.stop),
     sessionStartOk: has("SessionStart", SUBCMD.sessionStart),
   };