ccc-notifier 0.3.0 → 0.5.0

package/dist/{chunk-7KVOQ4UZ.js → chunk-S3XKO7MY.js}

@@ -8,14 +8,16 @@ import {
   detectCodex
 } from "./chunk-HTYUYKFW.js";
 import {
+  configFilePath,
   paths,
   readConfig
-} from "./chunk-ECADO26T.js";
+} from "./chunk-5PH7PPD6.js";
 
 // src/setup.ts
 import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync2,
+  lstatSync,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
   rmSync,
@@ -35,123 +37,201 @@ import {
   writeFileSync
 } from "fs";
 import { dirname, join } from "path";
-function isPlainObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
+var CODEX_HOOK_EVENTS = ["Stop", "UserPromptSubmit", "SubagentStart", "SubagentStop"];
+var CODEX_HOOK_TIMEOUT_SECONDS = 20;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function codexHooksFile() {
   return join(codexHome(), "hooks.json");
 }
-function codexHookCommand(nodePath, cliPath) {
-  let node = nodePath;
-  let cli = cliPath;
-  if (process.platform === "win32") {
-    node = node.replace(/\\/g, "/");
-    cli = cli.replace(/\\/g, "/");
+function normalizeExecutablePath(value) {
+  return process.platform === "win32" ? value.replace(/\\/g, "/") : value;
+}
+function codexHookCommand(nodePath, cliPath, event = "Stop") {
+  const node = normalizeExecutablePath(nodePath);
+  const cli = normalizeExecutablePath(cliPath);
+  return `"${node}" "${cli}" __ccc-notifier-codex-hook ${event}`;
+}
+function tokenize(command) {
+  const result = [];
+  const re = /\s*(?:"([^"]*)"|'([^']*)'|(\S+))/gy;
+  let offset = 0;
+  while (offset < command.length) {
+    re.lastIndex = offset;
+    const match = re.exec(command);
+    if (!match) return null;
+    result.push(match[1] ?? match[2] ?? match[3]);
+    offset = re.lastIndex;
   }
-  return `"${node}" "${cli}" track --codex`;
+  return result;
 }
-function ourCodexStopEntry(command) {
-  return { hooks: [{ type: "command", command }] };
+function parseLegacyOwnedCommand(command) {
+  const tokens = tokenize(command);
+  if (tokens === null || tokens.length !== 4 || !isCccNotifierExecutablePair(tokens[0], tokens[1]) || tokens[2] !== "track" || tokens[3] !== "--codex") return null;
+  return {
+    nodePath: normalizeExecutablePath(tokens[0]),
+    cliPath: normalizeExecutablePath(tokens[1]),
+    event: "Stop"
+  };
 }
-function isOurStopEntry(entry) {
-  if (!isPlainObject(entry)) return false;
-  const hooks = entry.hooks;
-  if (!Array.isArray(hooks)) return false;
-  return hooks.some(
-    (h) => isPlainObject(h) && typeof h.command === "string" && matchesMarker(h.command)
-  );
+function isCccNotifierExecutablePair(nodePath, cliPath) {
+  const node = normalizeExecutablePath(nodePath);
+  const cli = normalizeExecutablePath(cliPath);
+  const nodeAbsolute = node.startsWith("/") || /^[a-z]:\//i.test(node);
+  const cliAbsolute = cli.startsWith("/") || /^[a-z]:\//i.test(cli);
+  return nodeAbsolute && cliAbsolute && /(^|\/)node(?:\.exe)?$/i.test(node) && /\/(?:ccc-notifier\/dist|ccc-notifier-dist)\/cli\.js$/i.test(cli);
+}
+function parseOwnedCodexHookCommand(command) {
+  if (typeof command !== "string") return null;
+  const tokens = tokenize(command);
+  if (tokens === null || tokens.length !== 4 || tokens[2] !== "__ccc-notifier-codex-hook") return null;
+  if (!CODEX_HOOK_EVENTS.includes(tokens[3])) return null;
+  if (!isCccNotifierExecutablePair(tokens[0], tokens[1])) return null;
+  return {
+    nodePath: normalizeExecutablePath(tokens[0]),
+    cliPath: normalizeExecutablePath(tokens[1]),
+    event: tokens[3]
+  };
 }
-function buildManualSnippet(command) {
-  return JSON.stringify(ourCodexStopEntry(command), null, 2);
+function parseConfiguredOwnedCodexHookCommand(command, event) {
+  const parsed = parseOwnedCodexHookCommand(command) ?? (typeof command === "string" ? parseLegacyOwnedCommand(command) : null);
+  return parsed !== null && (event === void 0 || parsed.event === event) ? parsed : null;
+}
+function isOwnedHandler(value, event) {
+  if (!isPlainObject(value) || value.type !== "command") return false;
+  return parseConfiguredOwnedCodexHookCommand(value.command, event) !== null;
+}
+function canonicalHandler(command) {
+  return { type: "command", command, timeout: CODEX_HOOK_TIMEOUT_SECONDS };
+}
+function manualSnippet(nodePath, cliPath) {
+  const hooks = Object.fromEntries(
+    CODEX_HOOK_EVENTS.map((event) => [
+      event,
+      [{ hooks: [canonicalHandler(codexHookCommand(nodePath, cliPath, event))] }]
+    ])
+  );
+  return JSON.stringify({ hooks }, null, 2);
 }
-function backupHooks(path) {
+function backup(path) {
   const backupPath = `${path}.bak-${Date.now()}`;
   copyFileSync(path, backupPath);
   return backupPath;
 }
-function writeHooks(path, obj) {
-  writeFileSync(path, JSON.stringify(obj, null, 2) + "\n", "utf8");
+function write(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function validateShape(root) {
+  if (root.hooks !== void 0 && !isPlainObject(root.hooks)) return null;
+  const hooks = root.hooks ?? {};
+  for (const event of CODEX_HOOK_EVENTS) {
+    if (hooks[event] !== void 0 && !Array.isArray(hooks[event])) return null;
+    const groups = hooks[event] ?? [];
+    for (const group of groups) {
+      if (!isPlainObject(group) || !Array.isArray(group.hooks)) return null;
+    }
+  }
+  return hooks;
 }
 function registerCodexHook(nodePath, cliPath) {
-  const hooksFile = codexHooksFile();
-  const command = codexHookCommand(nodePath, cliPath);
-  if (!existsSync(hooksFile)) {
-    mkdirSync(dirname(hooksFile), { recursive: true });
-    writeHooks(hooksFile, { hooks: { Stop: [ourCodexStopEntry(command)] } });
+  const path = codexHooksFile();
+  if (!existsSync(path)) {
+    mkdirSync(dirname(path), { recursive: true });
+    const hooks2 = {};
+    for (const event of CODEX_HOOK_EVENTS) {
+      hooks2[event] = [{ hooks: [canonicalHandler(codexHookCommand(nodePath, cliPath, event))] }];
+    }
+    write(path, { hooks: hooks2 });
     return { status: "written", backupPath: null };
   }
-  const raw = readFileSync(hooksFile, "utf8");
+  const raw = readFileSync(path, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return { status: "manual", backupPath: null, manualSnippet: buildManualSnippet(command) };
+    return { status: "manual", backupPath: null, manualSnippet: manualSnippet(nodePath, cliPath) };
   }
   if (!isPlainObject(parsed)) {
-    return { status: "manual", backupPath: null, manualSnippet: buildManualSnippet(command) };
+    return { status: "manual", backupPath: null, manualSnippet: manualSnippet(nodePath, cliPath) };
   }
-  const obj = parsed;
-  const hooksVal = obj.hooks;
-  if (hooksVal !== void 0 && !isPlainObject(hooksVal)) {
-    return { status: "manual", backupPath: null, manualSnippet: buildManualSnippet(command) };
+  const hooks = validateShape(parsed);
+  if (hooks === null) {
+    return { status: "manual", backupPath: null, manualSnippet: manualSnippet(nodePath, cliPath) };
   }
-  const hooks = hooksVal ?? {};
-  const stopVal = hooks.Stop;
-  if (stopVal !== void 0 && !Array.isArray(stopVal)) {
-    return { status: "manual", backupPath: null, manualSnippet: buildManualSnippet(command) };
-  }
-  const stop = stopVal ?? [];
-  const idx = stop.findIndex(isOurStopEntry);
-  if (idx >= 0) {
-    const entry = stop[idx];
-    const entryHooks = entry.hooks;
-    const needsUpdate = entryHooks.some(
-      (h) => isPlainObject(h) && typeof h.command === "string" && matchesMarker(h.command) && h.command !== command
-    );
-    if (!needsUpdate) return { status: "unchanged", backupPath: null };
-    const backupPath2 = backupHooks(hooksFile);
-    for (const h of entryHooks) {
-      if (isPlainObject(h) && typeof h.command === "string" && matchesMarker(h.command)) {
-        h.command = command;
+  let changed = false;
+  for (const event of CODEX_HOOK_EVENTS) {
+    const groups = hooks[event] ?? [];
+    const wanted = canonicalHandler(codexHookCommand(nodePath, cliPath, event));
+    let found = false;
+    const groupsToRemove = /* @__PURE__ */ new Set();
+    for (const group of groups) {
+      const handlers = group.hooks;
+      for (let i = 0; i < handlers.length; i++) {
+        if (!isOwnedHandler(handlers[i], event)) continue;
+        if (!found) {
+          found = true;
+          const current = handlers[i];
+          const needsUpdate = !isPlainObject(current) || current.type !== wanted.type || current.command !== wanted.command || current.timeout !== wanted.timeout;
+          if (needsUpdate) {
+            handlers[i] = isPlainObject(current) ? { ...current, ...wanted } : wanted;
+            changed = true;
+          }
+        } else {
+          handlers.splice(i--, 1);
+          changed = true;
+          if (handlers.length === 0) groupsToRemove.add(group);
+        }
       }
     }
-    obj.hooks = hooks;
-    hooks.Stop = stop;
-    writeHooks(hooksFile, obj);
-    return { status: "written", backupPath: backupPath2 };
+    if (!found) {
+      groups.push({ hooks: [wanted] });
+      changed = true;
+    }
+    const retainedGroups = groups.filter((group) => !groupsToRemove.has(group));
+    if (retainedGroups.length !== groups.length) changed = true;
+    hooks[event] = retainedGroups;
   }
-  const backupPath = backupHooks(hooksFile);
-  stop.push(ourCodexStopEntry(command));
-  obj.hooks = hooks;
-  hooks.Stop = stop;
-  writeHooks(hooksFile, obj);
+  if (!changed) return { status: "unchanged", backupPath: null };
+  const backupPath = backup(path);
+  parsed.hooks = hooks;
+  write(path, parsed);
   return { status: "written", backupPath };
 }
 function removeCodexHook() {
-  const hooksFile = codexHooksFile();
-  if (!existsSync(hooksFile)) return { status: "unchanged", backupPath: null };
-  const raw = readFileSync(hooksFile, "utf8");
+  const path = codexHooksFile();
+  if (!existsSync(path)) return { status: "unchanged", backupPath: null };
   let parsed;
   try {
-    parsed = JSON.parse(raw);
+    parsed = JSON.parse(readFileSync(path, "utf8"));
   } catch {
     return { status: "unchanged", backupPath: null };
   }
   if (!isPlainObject(parsed)) return { status: "unchanged", backupPath: null };
-  const obj = parsed;
-  const hooks = isPlainObject(obj.hooks) ? obj.hooks : null;
-  const stop = hooks && Array.isArray(hooks.Stop) ? hooks.Stop : null;
-  if (!hooks || !stop || !stop.some(isOurStopEntry)) {
-    return { status: "unchanged", backupPath: null };
-  }
-  const backupPath = backupHooks(hooksFile);
-  const filtered = stop.filter((e) => !isOurStopEntry(e));
-  if (filtered.length === 0) {
-    delete hooks.Stop;
-  } else {
-    hooks.Stop = filtered;
+  const hooks = validateShape(parsed);
+  if (hooks === null) return { status: "unchanged", backupPath: null };
+  let changed = false;
+  for (const event of CODEX_HOOK_EVENTS) {
+    const original = hooks[event] ?? [];
+    const groups = [];
+    for (const group of original) {
+      const handlers = group.hooks;
+      const filtered = handlers.filter((handler) => !isOwnedHandler(handler, event));
+      const removedOwned = filtered.length !== handlers.length;
+      if (removedOwned) changed = true;
+      if (!removedOwned) groups.push(group);
+      else if (filtered.length > 0) groups.push({ ...group, hooks: filtered });
+    }
+    if (groups.length === 0) {
+      if (event in hooks) delete hooks[event];
+    } else {
+      hooks[event] = groups;
+    }
   }
-  writeHooks(hooksFile, obj);
+  if (!changed) return { status: "unchanged", backupPath: null };
+  const backupPath = backup(path);
+  write(path, parsed);
   return { status: "written", backupPath };
 }
 
@@ -186,7 +266,7 @@ function buildHookCommand() {
 function matchesMarker(command) {
   return command.includes(HOOK_MARKER);
 }
-function isOurStopEntry2(entry) {
+function isOurStopEntry(entry) {
   if (!isPlainObject2(entry)) return false;
   const hooks = entry.hooks;
   if (!Array.isArray(hooks)) return false;
@@ -246,10 +326,13 @@ function parseInitFlags(argv) {
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--yes" || a === "-y") flags.yes = true;
-    else if (a === "--os-only") flags.osOnly = true;
-    else if (a === "--slack-only") flags.slackOnly = true;
-    else if (a === "--no-notify") flags.noNotify = true;
-    else if (a === "--codex") flags.codex = true;
+    else if (a === "--os-only") {
+      flags.osOnly = true;
+    } else if (a === "--slack-only") {
+      flags.slackOnly = true;
+    } else if (a === "--no-notify") {
+      flags.noNotify = true;
+    } else if (a === "--codex") flags.codex = true;
     else if (a === "--no-codex") flags.noCodex = true;
     else if (a === "--slack-webhook" || a.startsWith("--slack-webhook=")) {
       flags.slackWebhook = takeValue(argv, i, "--slack-webhook");
@@ -267,6 +350,38 @@ function parseInitFlags(argv) {
   }
   return flags;
 }
+function configPathEntryExists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch (err) {
+    if (isPlainObject2(err) && err.code === "ENOENT") return false;
+    return null;
+  }
+}
+function isExactCodexMigrationInvocation(argv, flags) {
+  return flags.yes && flags.codex && argv.every((arg) => arg === "--yes" || arg === "-y" || arg === "--codex");
+}
+function printCodexHookResult(codexResult) {
+  if (codexResult.status === "written") {
+    console.log(`Codex \u306B Stop/UserPromptSubmit/SubagentStart/SubagentStop hook \u3092\u767B\u9332\u3057\u307E\u3057\u305F: ${codexHooksFile()}`);
+    if (codexResult.backupPath) {
+      console.log(`  \u30D0\u30C3\u30AF\u30A2\u30C3\u30D7: ${codexResult.backupPath}`);
+    }
+    console.log(
+      "\u6B21\u56DE codex \u8D77\u52D5\u6642\u306B\u300EHooks need review\u300F\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u300ETrust all and continue\u300F\u3092\u9078\u3076\u3068\u6709\u52B9\u306B\u306A\u308A\u307E\u3059(\u627F\u8A8D\u307E\u3067\u306F\u52D5\u304D\u307E\u305B\u3093)"
+    );
+  } else if (codexResult.status === "unchanged") {
+    console.log("Codex \u306E Stop/UserPromptSubmit/SubagentStart/SubagentStop hook \u306F\u767B\u9332\u6E08\u307F\u3067\u3059");
+  } else {
+    console.error(`Codex \u306E hooks.json \u3092\u81EA\u52D5\u7DE8\u96C6\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F: ${codexHooksFile()}`);
+    console.error("\u5B89\u5168\u306E\u305F\u3081 hooks.json \u306E\u81EA\u52D5\u7DE8\u96C6\u3092\u4E2D\u6B62\u3057\u307E\u3057\u305F\u3002");
+    console.error("\u4EE5\u4E0B\u306E JSON \u306E4\u30A4\u30D9\u30F3\u30C8\u3092 hooks.json \u3078\u624B\u52D5\u3067\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044:");
+    console.error("");
+    console.error(codexResult.manualSnippet ?? "");
+    console.error("");
+  }
+}
 function parseUninstallFlags(argv) {
   const flags = { yes: false, purge: false };
   for (const a of argv) {
@@ -300,7 +415,7 @@ function mergeSettings(sPath, command) {
   const hooks = obj.hooks;
   if (!Array.isArray(hooks.Stop)) hooks.Stop = [];
   const stop = hooks.Stop;
-  const idx = stop.findIndex(isOurStopEntry2);
+  const idx = stop.findIndex(isOurStopEntry);
   if (idx >= 0) {
     const entry = stop[idx];
     const entryHooks = entry.hooks;
@@ -322,6 +437,33 @@ async function runInit(argv) {
     console.error("--codex \u3068 --no-codex \u306F\u540C\u6642\u306B\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093");
     return 1;
   }
+  const exactMigrationInvocation = isExactCodexMigrationInvocation(argv, flags);
+  const configEntryState = exactMigrationInvocation ? configPathEntryExists(configFilePath()) : false;
+  if (configEntryState === null) {
+    console.error(`config.json \u306E\u5B58\u5728\u3092\u5B89\u5168\u306B\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F: ${configFilePath()}`);
+    console.error("\u5B89\u5168\u306E\u305F\u3081 Codex hook \u3092\u542B\u3080\u3059\u3079\u3066\u306E\u5909\u66F4\u3092\u4E2D\u6B62\u3057\u307E\u3057\u305F\u3002");
+    return 1;
+  }
+  const codexOnlyMigration = exactMigrationInvocation && configEntryState;
+  if (codexOnlyMigration) {
+    const codexResult2 = registerCodexHook(process.execPath, resolveCliPath());
+    printCodexHookResult(codexResult2);
+    if (codexResult2.status === "manual") {
+      console.error(
+        "Codex hook \u9650\u5B9A\u79FB\u884C\u3092\u5B8C\u4E86\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002config.json\u3001Claude settings\u3001\u901A\u77E5\u8A2D\u5B9A\u306F\u5909\u66F4\u3057\u3066\u3044\u307E\u305B\u3093\u3002"
+      );
+      return 1;
+    }
+    console.log(
+      "Codex hook \u306E\u307F\u3092\u78BA\u8A8D\u30FB\u66F4\u65B0\u3057\u307E\u3057\u305F\u3002config.json\u3001Claude settings\u3001\u901A\u77E5\u8A2D\u5B9A\u306F\u5909\u66F4\u305B\u305A\u3001\u30C6\u30B9\u30C8\u901A\u77E5\u3082\u9001\u4FE1\u3057\u3066\u3044\u307E\u305B\u3093\u3002"
+    );
+    if (codexResult2.status === "written") {
+      console.log(
+        "Codex \u3092\u518D\u8D77\u52D5\u3057\u3001/hooks \u3067 Stop / UserPromptSubmit / SubagentStart / SubagentStop \u3092\u4FE1\u983C\u6E08\u307F\u306B\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+      );
+    }
+    return 0;
+  }
   let installCodex = false;
   const cfg = readConfig();
   const initialChannel = !cfg.notify.os && !cfg.notify.slack ? "none" : cfg.notify.slack ? cfg.notify.os ? "both" : "slack" : "os";
@@ -517,24 +659,7 @@ async function runInit(argv) {
     console.log("Claude Code \u3067\u4F55\u304B\u5B9F\u884C\u3059\u308B\u3068\u901A\u77E5\u304C\u5C4A\u304D\u307E\u3059\u3002\u78BA\u8A8D: npx ccc-notifier doctor");
   }
   if (codexResult) {
-    if (codexResult.status === "written") {
-      console.log(`Codex \u306B\u3082 Stop hook \u3092\u767B\u9332\u3057\u307E\u3057\u305F: ${codexHooksFile()}`);
-      if (codexResult.backupPath) {
-        console.log(`  \u30D0\u30C3\u30AF\u30A2\u30C3\u30D7: ${codexResult.backupPath}`);
-      }
-      console.log(
-        "\u6B21\u56DE codex \u8D77\u52D5\u6642\u306B\u300EHooks need review\u300F\u304C\u8868\u793A\u3055\u308C\u307E\u3059\u3002\u300ETrust all and continue\u300F\u3092\u9078\u3076\u3068\u6709\u52B9\u306B\u306A\u308A\u307E\u3059(\u627F\u8A8D\u307E\u3067\u306F\u52D5\u304D\u307E\u305B\u3093)"
-      );
-    } else if (codexResult.status === "unchanged") {
-      console.log("Codex \u306E Stop hook \u306F\u767B\u9332\u6E08\u307F\u3067\u3059");
-    } else {
-      console.error(`Codex \u306E hooks.json \u3092\u81EA\u52D5\u7DE8\u96C6\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F: ${codexHooksFile()}`);
-      console.error("\u5B89\u5168\u306E\u305F\u3081 hooks.json \u306E\u81EA\u52D5\u7DE8\u96C6\u3092\u4E2D\u6B62\u3057\u307E\u3057\u305F\u3002");
-      console.error("\u4EE5\u4E0B\u306E JSON \u3092 hooks.json \u306E hooks.Stop \u914D\u5217\u306B\u624B\u52D5\u3067\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044:");
-      console.error("");
-      console.error(codexResult.manualSnippet ?? "");
-      console.error("");
-    }
+    printCodexHookResult(codexResult);
   }
   return 0;
 }
@@ -558,12 +683,12 @@ async function runUninstall(argv) {
       const obj = parsed;
       const hooks = isPlainObject2(obj.hooks) ? obj.hooks : null;
       const stop = hooks && Array.isArray(hooks.Stop) ? hooks.Stop : null;
-      const hasMarker = stop ? stop.some(isOurStopEntry2) : false;
+      const hasMarker = stop ? stop.some(isOurStopEntry) : false;
       if (!hasMarker || !hooks || !stop) {
         console.log("\u767B\u9332\u306A\u3057: \u672C\u30C4\u30FC\u30EB\u306E Stop \u30D5\u30C3\u30AF\u306F\u767B\u9332\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002");
       } else {
         const backupPath = backupSettings(sPath);
-        const filtered = stop.filter((e) => !isOurStopEntry2(e));
+        const filtered = stop.filter((e) => !isOurStopEntry(e));
         if (filtered.length === 0) {
           delete hooks.Stop;
         } else {
@@ -577,7 +702,7 @@ async function runUninstall(argv) {
   }
   const codexRemoval = removeCodexHook();
   if (codexRemoval.status === "written") {
-    console.log("Codex \u306E Stop hook \u3092\u524A\u9664\u3057\u307E\u3057\u305F");
+    console.log("Codex \u306E Stop/UserPromptSubmit/SubagentStart/SubagentStop hook \u3092\u524A\u9664\u3057\u307E\u3057\u305F");
   }
   if (flags.purge) {
     const home = paths().home;
@@ -602,7 +727,9 @@ async function runUninstall(argv) {
 }
 
 export {
-  codexHooksFile,
+  CODEX_HOOK_EVENTS,
+  CODEX_HOOK_TIMEOUT_SECONDS,
+  parseConfiguredOwnedCodexHookCommand,
   matchesMarker,
   runInit,
   runUninstall