@event4u/agent-config 14.6.0 → 14.8.0

package/dist/cli-delegate/chunk-E4XIZDIB.js

@@ -0,0 +1,402 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/hooks/state_io.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+var LOCK_BASENAME = ".dispatcher.lock";
+var REPLAY_ENV_VAR = "AGENT_CONFIG_REPLAY";
+function is_replay_mode() {
+  return (process.env[REPLAY_ENV_VAR] ?? "").trim() === "1";
+}
+function _lock_path(state_dir) {
+  return path.join(state_dir, LOCK_BASENAME);
+}
+function _target_lock_path(target_path) {
+  return `${target_path}.lock`;
+}
+function _py_json_dumps(value, indent) {
+  const pad = " ".repeat(indent);
+  const escapeString = (s) => {
+    let out = '"';
+    for (const ch of s) {
+      const code = ch.codePointAt(0);
+      switch (ch) {
+        case '"':
+          out += '\\"';
+          break;
+        case "\\":
+          out += "\\\\";
+          break;
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "	":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          if (code < 32 || code > 126) {
+            if (code > 65535) {
+              const c = code - 65536;
+              const hi = 55296 + (c >> 10);
+              const lo = 56320 + (c & 1023);
+              out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
+            } else {
+              out += "\\u" + code.toString(16).padStart(4, "0");
+            }
+          } else {
+            out += ch;
+          }
+      }
+    }
+    return out + '"';
+  };
+  const render = (v, depth) => {
+    if (v === null || v === void 0) {
+      return "null";
+    }
+    if (typeof v === "boolean") {
+      return v ? "true" : "false";
+    }
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) {
+        if (Number.isNaN(v)) return "NaN";
+        return v > 0 ? "Infinity" : "-Infinity";
+      }
+      return String(v);
+    }
+    if (typeof v === "string") {
+      return escapeString(v);
+    }
+    const curPad = pad.repeat(depth + 1);
+    const closePad = pad.repeat(depth);
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        return "[]";
+      }
+      const items = v.map((item) => curPad + render(item, depth + 1));
+      return "[\n" + items.join(",\n") + "\n" + closePad + "]";
+    }
+    if (typeof v === "object") {
+      const obj = v;
+      const keys = Object.keys(obj);
+      if (keys.length === 0) {
+        return "{}";
+      }
+      const items = keys.map(
+        (k) => curPad + escapeString(k) + ": " + render(obj[k], depth + 1)
+      );
+      return "{\n" + items.join(",\n") + "\n" + closePad + "}";
+    }
+    throw new TypeError(`Object of type ${typeof v} is not JSON serializable`);
+  };
+  return render(value, 0);
+}
+function atomic_write_json(target, payload, options = {}) {
+  if (is_replay_mode()) {
+    return;
+  }
+  const indent = options.indent ?? 2;
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  fs.mkdirSync(state_dir, { recursive: true });
+  const body = _py_json_dumps(payload, indent) + "\n";
+  _atomic_write_text(targetPath, body);
+}
+function atomic_write_text(target, text) {
+  if (is_replay_mode()) {
+    return;
+  }
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  fs.mkdirSync(state_dir, { recursive: true });
+  _atomic_write_text(targetPath, text);
+}
+var LOCK_STALE_MS = 3e4;
+var LOCK_ACQUIRE_DEADLINE_MS = 5e3;
+var LOCK_SPIN_SLEEP_MS = 2;
+function _sleep(ms) {
+  const sab = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(sab, 0, 0, ms);
+}
+function _acquire_lock(lock_path, options = {}) {
+  const blocking = options.blocking ?? true;
+  const fd = fs.openSync(lock_path, "a", 420);
+  const held = lock_path + ".held";
+  const give_up = () => {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+    return null;
+  };
+  const start = Date.now();
+  for (; ; ) {
+    try {
+      const heldFd = fs.openSync(held, "wx", 420);
+      fs.closeSync(heldFd);
+      return fd;
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        return fd;
+      }
+      let age_ms;
+      try {
+        age_ms = Date.now() - fs.statSync(held).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (age_ms >= LOCK_STALE_MS) {
+        try {
+          fs.rmSync(held, { force: true });
+        } catch {
+        }
+        continue;
+      }
+      if (!blocking) {
+        return give_up();
+      }
+      if (Date.now() - start > LOCK_ACQUIRE_DEADLINE_MS) {
+        return give_up();
+      }
+      _sleep(LOCK_SPIN_SLEEP_MS);
+    }
+  }
+}
+function _release_lock(fd, lock_path) {
+  try {
+    fs.closeSync(fd);
+  } catch {
+  }
+  try {
+    fs.rmSync(lock_path + ".held", { force: true });
+  } catch {
+  }
+}
+function _publish_text_locked(target, text) {
+  const tmp = target + `.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, text, { encoding: "utf-8" });
+  fs.renameSync(tmp, target);
+}
+function _atomic_write_text(target, text) {
+  const lock_path = _lock_path(path.dirname(target));
+  const fd = _acquire_lock(lock_path);
+  if (fd === null) {
+    _publish_text_locked(target, text);
+    return;
+  }
+  try {
+    _publish_text_locked(target, text);
+  } finally {
+    _release_lock(fd, lock_path);
+  }
+}
+function has_stable_session_id(session_id) {
+  return typeof session_id === "string" && session_id.trim() !== "";
+}
+function session_state_file(dir, session_id) {
+  const digest = createHash("sha256").update(session_id, "utf8").digest("hex").slice(0, 32);
+  return path.join(dir, `${digest}.json`);
+}
+function restore_claimed_state(tomb, live, link = fs.linkSync) {
+  try {
+    link(tomb, live);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EEXIST" && code !== "ENOENT") {
+      if (!NO_HARD_LINK_CODES.has(code ?? "")) throw err;
+      if (!fs.existsSync(live)) {
+        fs.renameSync(tomb, live);
+        return;
+      }
+    }
+  }
+  fs.rmSync(tomb, { force: true });
+}
+var NO_HARD_LINK_CODES = /* @__PURE__ */ new Set(["EPERM", "ENOSYS", "EXDEV", "EOPNOTSUPP", "EMLINK"]);
+function prune_stale_session_states(dir, now_ms, retention_days, mtime_of = (target) => fs.statSync(target).mtimeMs) {
+  if (is_replay_mode()) return 0;
+  const cutoff = now_ms - retention_days * 24 * 60 * 60 * 1e3;
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return 0;
+  }
+  let removed = 0;
+  let claim = 0;
+  for (const name of entries) {
+    const orphan = /^(.+\.json)\.\d+\.\d+\.tomb$/.exec(name);
+    const live_name = orphan?.[1];
+    if (live_name === void 0) continue;
+    const tomb = path.join(dir, name);
+    const live = path.join(dir, live_name);
+    try {
+      if (mtime_of(tomb) >= cutoff) {
+        restore_claimed_state(tomb, live);
+        continue;
+      }
+      fs.rmSync(tomb, { force: true });
+      removed += 1;
+    } catch {
+    }
+  }
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    const full = path.join(dir, name);
+    try {
+      if (mtime_of(full) >= cutoff) continue;
+      claim += 1;
+      const tomb = `${full}.${process.pid}.${claim}.tomb`;
+      fs.renameSync(full, tomb);
+      if (mtime_of(tomb) >= cutoff) {
+        restore_claimed_state(tomb, full);
+        continue;
+      }
+      fs.rmSync(tomb, { force: true });
+      for (const suffix of [".lock", ".lock.held"]) {
+        try {
+          fs.rmSync(`${full}${suffix}`, { force: true });
+        } catch {
+        }
+      }
+      removed += 1;
+    } catch {
+    }
+  }
+  return removed;
+}
+function prune_legacy_state_file(target) {
+  if (is_replay_mode()) return;
+  try {
+    if (fs.statSync(target).isFile()) {
+      fs.rmSync(target, { force: true });
+    }
+  } catch {
+  }
+}
+function owns_session_state(state, session_id) {
+  if (typeof state !== "object" || state === null || Array.isArray(state)) return false;
+  return state["session_id"] === session_id;
+}
+function update_json_under_lock(target, mutate, options = {}) {
+  if (is_replay_mode()) return "failed";
+  const targetPath = path.resolve(target);
+  const state_dir = path.dirname(targetPath);
+  try {
+    fs.mkdirSync(state_dir, { recursive: true });
+  } catch {
+    return "failed";
+  }
+  const lock_path = _target_lock_path(targetPath);
+  let fd;
+  try {
+    fd = _acquire_lock(lock_path, { blocking: options.blocking ?? true });
+  } catch {
+    return "failed";
+  }
+  if (fd === null) return "failed";
+  try {
+    let loaded = {};
+    try {
+      const raw = fs.readFileSync(targetPath, "utf-8");
+      const decoded = JSON.parse(raw);
+      if (typeof decoded === "object" && decoded !== null && !Array.isArray(decoded)) {
+        loaded = decoded;
+      }
+    } catch {
+    }
+    const next = mutate(loaded);
+    if (next === null) return "skipped";
+    _publish_text_locked(targetPath, _py_json_dumps(next, options.indent ?? 2) + "\n");
+    return "written";
+  } catch {
+    return "failed";
+  } finally {
+    _release_lock(fd, lock_path);
+  }
+}
+
+// src/scripts/_lib/git_common_dir.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function realpath_or_self(p) {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function git_dir(project_root) {
+  const dot_git = path2.join(project_root, ".git");
+  try {
+    const st = fs2.statSync(dot_git);
+    if (st.isDirectory()) {
+      return realpath_or_self(dot_git);
+    }
+    const m = fs2.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
+    if (m === null) {
+      return null;
+    }
+    return realpath_or_self(path2.resolve(project_root, m[1].trim()));
+  } catch {
+    return null;
+  }
+}
+function current_branch(project_root) {
+  const gd = git_dir(project_root);
+  if (gd === null) return null;
+  try {
+    const head = fs2.readFileSync(path2.join(gd, "HEAD"), "utf-8").trim();
+    const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+    return m === null ? null : m[1].trim();
+  } catch {
+    return null;
+  }
+}
+function git_common_dir(project_root) {
+  const dot_git = path2.join(project_root, ".git");
+  try {
+    const st = fs2.statSync(dot_git);
+    if (st.isDirectory()) {
+      return realpath_or_self(dot_git);
+    }
+    const m = fs2.readFileSync(dot_git, "utf-8").match(/^gitdir:\s*(.+)\s*$/m);
+    if (m === null) {
+      return null;
+    }
+    const gitdir = path2.resolve(project_root, m[1].trim());
+    const commondir_file = path2.join(gitdir, "commondir");
+    if (fs2.existsSync(commondir_file)) {
+      const common = path2.resolve(gitdir, fs2.readFileSync(commondir_file, "utf-8").trim());
+      return realpath_or_self(common);
+    }
+    return realpath_or_self(gitdir);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  is_replay_mode,
+  atomic_write_json,
+  atomic_write_text,
+  has_stable_session_id,
+  session_state_file,
+  prune_stale_session_states,
+  prune_legacy_state_file,
+  owns_session_state,
+  update_json_under_lock,
+  git_dir,
+  current_branch,
+  git_common_dir
+};

package/dist/cli-delegate/{chunk-3UCJWMMP.js → chunk-EEJUMCDZ.js}

@@ -10,6 +10,11 @@ import {
   claude_plugin_snapshot_version,
   codex_plugin_identity
 } from "./chunk-FTAISGDQ.js";
+import {
+  DEFAULT_GITATTRIBUTES,
+  SECTION_HEADER,
+  _is_source_repo
+} from "./chunk-M2DPGFZ4.js";
 import {
   DEFAULT_PROJECTS_ROOT,
   aggregateByBucket,
@@ -21,15 +26,10 @@ import {
   projectStoreSlug,
   scanTranscripts,
   weightedInputUnits
-} from "./chunk-FBKL6JWT.js";
+} from "./chunk-MMSGVZKV.js";
 import {
   git_common_dir
-} from "./chunk-PZWRPRWP.js";
-import {
-  DEFAULT_GITATTRIBUTES,
-  SECTION_HEADER,
-  _is_source_repo
-} from "./chunk-M2DPGFZ4.js";
+} from "./chunk-E4XIZDIB.js";
 import {
   DEFAULT_DEPLOY_ROOTS,
   MANAGED_SIGNATURE,
@@ -38,15 +38,21 @@ import {
   global_deploy_inventory_exports,
   manifest_path,
   read_manifest
-} from "./chunk-63WSP6YZ.js";
+} from "./chunk-PMEKGDED.js";
 import {
   read_lockfile
-} from "./chunk-GRRPEPRN.js";
+} from "./chunk-T7L2QK3K.js";
 import {
   LEGACY_ALL,
   excludedRuleBasenames,
   ruleScopeFromSettings
-} from "./chunk-NXFWFAYV.js";
+} from "./chunk-G23AT6GD.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
 import {
   PROJECT_ROOT_ENV,
   ProjectRootError,
@@ -59,12 +65,6 @@ import {
   event4u_root,
   resolve_with_fallback
 } from "./chunk-NDJLNC6Q.js";
-import {
-  require_dist
-} from "./chunk-OY53J6II.js";
-import {
-  resolvePackageRoot
-} from "./chunk-MCJYCQPF.js";
 import {
   __export,
   __toESM

package/dist/cli-delegate/{chunk-NXFWFAYV.js → chunk-G23AT6GD.js}

@@ -332,6 +332,7 @@ export {
   load_packs_registry,
   compute_active_pack_ids,
   is_pruned_under_scoped,
+  parseFrontmatter,
   LEGACY_ALL,
   ruleScopeFromSettings,
   ruleFileArrives,