@event4u/agent-config 9.11.0 → 9.13.0

package/dist/cli-delegate/{chunk-IR7P7JWA.js → chunk-A3HJ6NTI.js}

@@ -3,7 +3,11 @@ import {
   write_target
 } from "./chunk-NDJLNC6Q.js";
 import {
-  __export
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  __export,
+  __toESM
 } from "./chunk-J55WI3RR.js";
 
 // src/scripts/_lib/fs_atomic.ts
@@ -140,18 +144,18 @@ function manifest_path(project_root, env) {
 var _TOP_KEY_RE = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
 var _LIST_DASH_RE = /^\s*-\s*(.+?)\s*$/;
 var _INDENT_KEY_RE = /^\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
-function read_manifest(path3) {
+function read_manifest(path4) {
   let text;
   try {
-    text = require_read_text(path3);
+    text = require_read_text(path4);
   } catch {
     return null;
   }
   const data = _parse_manual(text);
   return _normalise_v2_shape(data);
 }
-function require_read_text(path3) {
-  return fs2.readFileSync(path3, { encoding: "utf-8" });
+function require_read_text(path4) {
+  return fs2.readFileSync(path4, { encoding: "utf-8" });
 }
 function _normalise_v2_shape(data) {
   if (data["tools"] === void 0 || data["tools"] === null) {
@@ -332,9 +336,9 @@ function stable_sort(items, key) {
     return a.index - b.index;
   }).map((entry) => entry.item);
 }
-function write_manifest(path3, version, tools, options = {}) {
+function write_manifest(path4, version, tools, options = {}) {
   const rendered = _render(version, tools, { deploy_roots: options.deploy_roots ?? null });
-  return write_atomic(path3, rendered);
+  return write_atomic(path4, rendered);
 }
 var ScopeMismatchError = class extends Error {
   name_;
@@ -422,6 +426,201 @@ function _today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 
+// src/install/atomic.ts
+import {
+  closeSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { dirname, join as join2 } from "node:path";
+function atomicWriteFile(target, data, options = {}) {
+  const mode = options.mode ?? 420;
+  const parent = dirname(target);
+  mkdirSync(parent, { recursive: true });
+  const tmp = join2(parent, `.tmp.${process.pid}.${randSuffix()}`);
+  let fd = null;
+  try {
+    fd = openSync(tmp, "w", mode);
+    const buf = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+    writeSync(fd, buf, 0, buf.length, 0);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = null;
+    renameSync(tmp, target);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function atomicAppendLine(target, line) {
+  let existing = "";
+  try {
+    existing = readFileSync2(target, "utf8");
+  } catch {
+    existing = "";
+  }
+  const sep2 = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  atomicWriteFile(target, `${existing}${sep2}${line}
+`);
+}
+function randSuffix() {
+  return Math.floor(Math.random() * 281474976710655).toString(16).padStart(12, "0");
+}
+
+// src/scripts/_lib/claude_settings_hooks.ts
+var YAML = __toESM(require_dist(), 1);
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+function _yaml_parse(text) {
+  return YAML.parse(text);
+}
+var MANAGED_SIGNATURE = "dispatch:hook --platform claude";
+var CorruptSettingsError = class extends Error {
+  constructor(file, cause) {
+    super(
+      `${file} exists but is not valid JSON (${cause}). Refusing to overwrite a user-owned settings file \u2014 fix or remove it, then re-run.`
+    );
+    this.name = "CorruptSettingsError";
+  }
+};
+var SettingsLockError = class extends Error {
+  constructor(lockPath) {
+    super(
+      `settings lock ${lockPath} is held by another process. Re-run when the concurrent install finishes (stale lock: delete the file).`
+    );
+    this.name = "SettingsLockError";
+  }
+};
+function build_claude_hook_matrix(manifest_path2) {
+  const raw = fs3.readFileSync(manifest_path2, "utf8");
+  const manifest = _yaml_parse(raw) ?? {};
+  const hook_spec = manifest["schema_version"] ?? 1;
+  const platforms = manifest["platforms"] ?? {};
+  const claude_events = (platforms["claude"] ?? {}) || {};
+  const aliasesAll = manifest["native_event_aliases"] ?? {};
+  const aliases = (aliasesAll["claude"] ?? {}) || {};
+  const ac_to_native = {};
+  for (const [native, ac] of Object.entries(aliases)) {
+    ac_to_native[String(ac)] = native;
+  }
+  const matrix = {};
+  for (const [ac_event, concerns] of Object.entries(claude_events)) {
+    if (!concerns || Array.isArray(concerns) && concerns.length === 0) continue;
+    const native = ac_to_native[ac_event];
+    if (native === void 0) continue;
+    matrix[native] = `BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config; command -v "$BIN" >/dev/null 2>&1 || exit 0; "$BIN" dispatch:hook --platform claude --event ${ac_event} --native-event ${native} --project-dir "$CLAUDE_PROJECT_DIR" --min-version ${String(hook_spec)}`;
+  }
+  return matrix;
+}
+function _is_managed_group(group) {
+  if (typeof group !== "object" || group === null || Array.isArray(group)) return false;
+  const hooks = group.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some(
+    (h) => typeof h === "object" && h !== null && typeof h.command === "string" && h.command.includes(MANAGED_SIGNATURE)
+  );
+}
+function _read_settings(settings_path) {
+  if (!fs3.existsSync(settings_path)) return {};
+  const raw = fs3.readFileSync(settings_path, "utf8");
+  if (raw.trim() === "") return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new CorruptSettingsError(settings_path, e.message);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new CorruptSettingsError(settings_path, "top level is not an object");
+  }
+  return parsed;
+}
+function _with_lock(settings_path, fn) {
+  const lockPath = settings_path + ".agent-config.lock";
+  fs3.mkdirSync(path2.dirname(lockPath), { recursive: true });
+  let fd;
+  try {
+    fd = fs3.openSync(lockPath, "wx");
+  } catch {
+    throw new SettingsLockError(lockPath);
+  }
+  try {
+    return fn();
+  } finally {
+    fs3.closeSync(fd);
+    fs3.rmSync(lockPath, { force: true });
+  }
+}
+function ensure_managed_hooks(settings_path, matrix) {
+  return _with_lock(settings_path, () => {
+    const settings = _read_settings(settings_path);
+    const before = JSON.stringify(settings);
+    const hooks = (settings["hooks"] ?? {}) || {};
+    const touched = [];
+    for (const [native, command] of Object.entries(matrix)) {
+      const existing = Array.isArray(hooks[native]) ? hooks[native] : [];
+      const user_groups = existing.filter((g) => !_is_managed_group(g));
+      const managed_group = {
+        hooks: [{ type: "command", command }]
+      };
+      const next = [...user_groups, managed_group];
+      if (JSON.stringify(next) !== JSON.stringify(existing)) touched.push(native);
+      hooks[native] = next;
+    }
+    settings["hooks"] = hooks;
+    const after = JSON.stringify(settings);
+    if (after === before) {
+      return { changed: false, events: [] };
+    }
+    atomicWriteFile(settings_path, JSON.stringify(settings, null, 2) + "\n");
+    return { changed: true, events: touched };
+  });
+}
+function remove_managed_hooks(settings_path) {
+  if (!fs3.existsSync(settings_path)) return { changed: false, events: [] };
+  return _with_lock(settings_path, () => {
+    const settings = _read_settings(settings_path);
+    const hooks = settings["hooks"];
+    if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) {
+      return { changed: false, events: [] };
+    }
+    const hooksRec = hooks;
+    const touched = [];
+    for (const [native, groups] of Object.entries(hooksRec)) {
+      if (!Array.isArray(groups)) continue;
+      const kept = groups.filter((g) => !_is_managed_group(g));
+      if (kept.length !== groups.length) {
+        touched.push(native);
+        if (kept.length === 0) {
+          delete hooksRec[native];
+        } else {
+          hooksRec[native] = kept;
+        }
+      }
+    }
+    if (touched.length === 0) return { changed: false, events: [] };
+    if (Object.keys(hooksRec).length === 0) {
+      delete settings["hooks"];
+    }
+    atomicWriteFile(settings_path, JSON.stringify(settings, null, 2) + "\n");
+    return { changed: true, events: touched };
+  });
+}
+
 // src/scripts/_lib/global_deploy_inventory.ts
 var global_deploy_inventory_exports = {};
 __export(global_deploy_inventory_exports, {
@@ -430,6 +629,7 @@ __export(global_deploy_inventory_exports, {
   SCHEMA_VERSION: () => SCHEMA_VERSION2,
   expected_deploy_files: () => expected_deploy_files,
   inventory_path: () => inventory_path,
+  is_ancestor: () => is_ancestor,
   load_inventory: () => load_inventory,
   reap_stale: () => reap_stale,
   reap_tagged_orphans: () => reap_tagged_orphans,
@@ -437,9 +637,9 @@ __export(global_deploy_inventory_exports, {
   save_inventory: () => save_inventory
 });
 import { randomBytes as randomBytes2 } from "node:crypto";
-import * as fs3 from "node:fs";
+import * as fs4 from "node:fs";
 import * as os2 from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 var SCHEMA_VERSION2 = 1;
 var INVENTORY_BASENAME = "deployed-files.json";
 var INVENTORY_ENV = "AGENT_CONFIG_DEPLOY_INVENTORY";
@@ -448,22 +648,22 @@ function expanduser2(p) {
     return os2.homedir();
   }
   if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return path2.join(os2.homedir(), p.slice(2));
+    return path3.join(os2.homedir(), p.slice(2));
   }
   return p;
 }
 function resolve_path(p) {
   try {
-    return fs3.realpathSync(p);
+    return fs4.realpathSync(p);
   } catch {
-    const abs = path2.resolve(p);
-    const parts = abs.split(path2.sep);
+    const abs = path3.resolve(p);
+    const parts = abs.split(path3.sep);
     for (let i = parts.length; i > 0; i -= 1) {
-      const prefix = parts.slice(0, i).join(path2.sep) || path2.sep;
+      const prefix = parts.slice(0, i).join(path3.sep) || path3.sep;
       try {
-        const real = fs3.realpathSync(prefix);
+        const real = fs4.realpathSync(prefix);
         const rest = parts.slice(i);
-        return rest.length > 0 ? path2.join(real, ...rest) : real;
+        return rest.length > 0 ? path3.join(real, ...rest) : real;
       } catch {
         continue;
       }
@@ -473,7 +673,7 @@ function resolve_path(p) {
 }
 function path_exists(p) {
   try {
-    fs3.statSync(p);
+    fs4.statSync(p);
     return true;
   } catch {
     return false;
@@ -491,7 +691,7 @@ function load_inventory(p) {
   const target = p ?? inventory_path();
   let data;
   try {
-    data = JSON.parse(fs3.readFileSync(target, { encoding: "utf-8" }));
+    data = JSON.parse(fs4.readFileSync(target, { encoding: "utf-8" }));
   } catch {
     return { schema_version: SCHEMA_VERSION2, tools: {} };
   }
@@ -502,15 +702,15 @@ function load_inventory(p) {
 }
 function save_inventory(data, p) {
   const target = p ?? inventory_path();
-  fs3.mkdirSync(path2.dirname(target), { recursive: true });
+  fs4.mkdirSync(path3.dirname(target), { recursive: true });
   const payload = json_dumps_sorted(data, 2) + "\n";
-  const parent = path2.dirname(target);
+  const parent = path3.dirname(target);
   let fd = null;
   let tmp_name = "";
   for (let attempt = 0; attempt < 32; attempt += 1) {
-    tmp_name = path2.join(parent, `${path2.basename(target)}.${randomBytes2(6).toString("hex")}`);
+    tmp_name = path3.join(parent, `${path3.basename(target)}.${randomBytes2(6).toString("hex")}`);
     try {
-      fd = fs3.openSync(tmp_name, "wx", 384);
+      fd = fs4.openSync(tmp_name, "wx", 384);
       break;
     } catch (err) {
       if (err.code === "EEXIST") {
@@ -523,16 +723,16 @@ function save_inventory(data, p) {
     throw new Error("save_inventory: could not create a unique temp file");
   }
   try {
-    fs3.writeFileSync(fd, payload, { encoding: "utf-8" });
-    fs3.closeSync(fd);
-    fs3.renameSync(tmp_name, target);
+    fs4.writeFileSync(fd, payload, { encoding: "utf-8" });
+    fs4.closeSync(fd);
+    fs4.renameSync(tmp_name, target);
   } catch (err) {
     try {
-      fs3.closeSync(fd);
+      fs4.closeSync(fd);
     } catch {
     }
     try {
-      fs3.unlinkSync(tmp_name);
+      fs4.unlinkSync(tmp_name);
     } catch {
     }
     throw err;
@@ -587,36 +787,42 @@ function json_string_ascii(s) {
   }
   return out;
 }
-function expected_deploy_files(src, dest_rel) {
+function expected_deploy_files(src, dest_rel, file_filter = null) {
   const out = /* @__PURE__ */ new Set();
   let src_stat;
   try {
-    src_stat = fs3.statSync(src);
+    src_stat = fs4.statSync(src);
   } catch {
     return out;
   }
   if (!src_stat.isDirectory()) {
+    if (file_filter !== null && !file_filter(src)) {
+      return out;
+    }
     out.add(as_posix(dest_rel));
     return out;
   }
   const _walk = (node, prefix) => {
-    const entries = fs3.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const entries = fs4.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     for (const name of entries) {
-      const entry = path2.join(node, name);
+      const entry = path3.join(node, name);
       const rel = join_rel(prefix, name);
-      const lst = fs3.lstatSync(entry);
+      const lst = fs4.lstatSync(entry);
       if (lst.isDirectory() && !lst.isSymbolicLink()) {
         _walk(entry, rel);
         continue;
       }
       let resolved_is_dir = false;
       try {
-        resolved_is_dir = fs3.statSync(entry).isDirectory();
+        resolved_is_dir = fs4.statSync(entry).isDirectory();
       } catch {
         resolved_is_dir = false;
       }
       if (resolved_is_dir) {
-        _walk(fs3.realpathSync(entry), rel);
+        _walk(fs4.realpathSync(entry), rel);
+        continue;
+      }
+      if (file_filter !== null && !file_filter(entry)) {
         continue;
       }
       out.add(as_posix(rel));
@@ -626,13 +832,13 @@ function expected_deploy_files(src, dest_rel) {
   return out;
 }
 function join_rel(prefix, name) {
-  return prefix ? path2.join(prefix, name) : name;
+  return prefix ? path3.join(prefix, name) : name;
 }
 function as_posix(p) {
   if (p === "") {
     return ".";
   }
-  return p.split(path2.sep).join("/");
+  return p.split(path3.sep).join("/");
 }
 function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false) {
   const tools = inventory["tools"] ?? {};
@@ -657,15 +863,15 @@ function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false)
     if (typeof rel !== "string" || !rel || rel.startsWith("/") || rel.startsWith("..")) {
       continue;
     }
-    const target = path2.join(anchor_resolved, rel);
+    const target = path3.join(anchor_resolved, rel);
     try {
-      relative_to(resolve_path(path2.dirname(target)), anchor_resolved);
+      relative_to(resolve_path(path3.dirname(target)), anchor_resolved);
     } catch {
       continue;
     }
     let lst = null;
     try {
-      lst = fs3.lstatSync(target);
+      lst = fs4.lstatSync(target);
     } catch {
       lst = null;
     }
@@ -679,12 +885,12 @@ function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false)
       continue;
     }
     try {
-      fs3.unlinkSync(target);
+      fs4.unlinkSync(target);
     } catch {
       continue;
     }
     deleted.push(target);
-    prune_candidates.add(path2.dirname(target));
+    prune_candidates.add(path3.dirname(target));
   }
   prune_empty_dirs(prune_candidates, anchor_resolved);
   return deleted;
@@ -695,10 +901,10 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
   const prune_candidates = /* @__PURE__ */ new Set();
   const needle = `package: ${package_tag}`;
   for (const dest_sub of dest_subs) {
-    const root = dest_sub ? path2.join(anchor_resolved, dest_sub) : anchor_resolved;
+    const root = dest_sub ? path3.join(anchor_resolved, dest_sub) : anchor_resolved;
     let root_stat;
     try {
-      root_stat = fs3.statSync(root);
+      root_stat = fs4.statSync(root);
     } catch {
       continue;
     }
@@ -708,7 +914,7 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
     for (const md of rglob_md(root)) {
       let md_lst;
       try {
-        md_lst = fs3.lstatSync(md);
+        md_lst = fs4.lstatSync(md);
       } catch {
         continue;
       }
@@ -720,13 +926,13 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
         continue;
       }
       try {
-        relative_to(resolve_path(path2.dirname(md)), anchor_resolved);
+        relative_to(resolve_path(path3.dirname(md)), anchor_resolved);
       } catch {
         continue;
       }
       let head;
       try {
-        head = fs3.readFileSync(md, { encoding: "utf-8" });
+        head = fs4.readFileSync(md, { encoding: "utf-8" });
       } catch {
         continue;
       }
@@ -744,12 +950,12 @@ function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_
         continue;
       }
       try {
-        fs3.unlinkSync(md);
+        fs4.unlinkSync(md);
       } catch {
         continue;
       }
       deleted.push(md);
-      prune_candidates.add(path2.dirname(md));
+      prune_candidates.add(path3.dirname(md));
     }
   }
   prune_empty_dirs(prune_candidates, anchor_resolved);
@@ -769,51 +975,51 @@ function record_deploy(tool_id, anchor, current_files, inventory) {
 }
 function prune_empty_dirs(prune_candidates, anchor_resolved) {
   const ordered = [...prune_candidates].sort(
-    (a, b) => b.split(path2.sep).length - a.split(path2.sep).length
+    (a, b) => b.split(path3.sep).length - a.split(path3.sep).length
   );
   for (const start of ordered) {
     let node = start;
     while (node !== anchor_resolved && is_ancestor(anchor_resolved, node)) {
       try {
-        fs3.rmdirSync(node);
+        fs4.rmdirSync(node);
       } catch {
         break;
       }
-      node = path2.dirname(node);
+      node = path3.dirname(node);
     }
   }
 }
 function is_ancestor(anchor, node) {
-  const rel = path2.relative(anchor, node);
-  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+  const rel = path3.relative(anchor, node);
+  return rel !== "" && !rel.startsWith("..") && !path3.isAbsolute(rel);
 }
 function relative_to(child, parent) {
   if (child === parent) {
     return "";
   }
-  const rel = path2.relative(parent, child);
-  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+  const rel = path3.relative(parent, child);
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
     throw new Error(`'${child}' is not in the subpath of '${parent}'`);
   }
   return rel;
 }
 function relative_to_posix(child, parent) {
-  return path2.relative(parent, child).split(path2.sep).join("/");
+  return path3.relative(parent, child).split(path3.sep).join("/");
 }
 function rglob_md(root) {
   const out = [];
   const walk = (dir) => {
     let names;
     try {
-      names = fs3.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      names = fs4.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
     } catch {
       return;
     }
     for (const name of names) {
-      const full = path2.join(dir, name);
+      const full = path3.join(dir, name);
       let lst;
       try {
-        lst = fs3.lstatSync(full);
+        lst = fs4.lstatSync(full);
       } catch {
         continue;
       }
@@ -862,11 +1068,17 @@ export {
   write_manifest,
   ScopeMismatchError,
   upsert_tool,
+  atomicAppendLine,
+  MANAGED_SIGNATURE,
+  build_claude_hook_matrix,
+  ensure_managed_hooks,
+  remove_managed_hooks,
   load_inventory,
   save_inventory,
   expected_deploy_files,
   reap_stale,
   reap_tagged_orphans,
   record_deploy,
+  is_ancestor,
   global_deploy_inventory_exports
 };