@event4u/agent-config 16.5.0 → 17.1.0

package/dist/cli-delegate/chunk-2Y5AMLMY.js

@@ -0,0 +1,136 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  CONSUMER_IMPACT_VALUES
+} from "./chunk-UUYEKXKR.js";
+import {
+  classify_install_origin,
+  compare_versions,
+  node_engine_satisfied,
+  parse_version
+} from "./chunk-5VO3RTMV.js";
+
+// src/scripts/_cli/doctor_install_mode.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isSourceCheckoutPackage(packageRoot) {
+  return fs.existsSync(path.join(packageRoot, ".git"));
+}
+var INSTALL_MODE_MARKER_RELATIVE = "agents/.agent-state/install-mode.txt";
+function _is_global_only_consumer(project_root) {
+  return isFile(path.join(project_root, INSTALL_MODE_MARKER_RELATIVE)) || isDir(path.join(project_root, "agents", "overrides"));
+}
+function originForPackageRoot(root) {
+  if (isSourceCheckoutPackage(root)) return "source-checkout";
+  return classify_install_origin({ package_root: root, project_pin: null, latest: null, is_global_consumer: false });
+}
+
+// src/scripts/_lib/classify_update.ts
+function read_impact_range(map, installed, candidate) {
+  if (map === null || map === void 0) return null;
+  if (typeof map !== "object" || Array.isArray(map)) {
+    return { forged: "impact map is not an object", worst: null, security: false };
+  }
+  const rank = (i) => CONSUMER_IMPACT_VALUES.indexOf(i);
+  let worst = null;
+  let security = false;
+  for (const [version, entry] of Object.entries(map)) {
+    if (parse_version(version) === null) return { forged: `impact map key '${version}' is not a version`, worst, security };
+    if (entry === null || typeof entry !== "object") {
+      return { forged: `impact map entry ${version} is not an object`, worst, security };
+    }
+    const impact = entry["impact"];
+    if (!CONSUMER_IMPACT_VALUES.includes(impact)) {
+      return { forged: `impact map entry ${version} has impact '${String(impact)}'`, worst, security };
+    }
+    if (compare_versions(version, installed) !== 1 || compare_versions(version, candidate) === 1) continue;
+    if (worst === null || rank(impact) > rank(worst)) worst = impact;
+    security = security || entry["security"] === true;
+  }
+  return { forged: null, worst, security };
+}
+function machine_override(engines, nodeVersion) {
+  const range = engines !== null && typeof engines === "object" ? engines["node"] : void 0;
+  if (range === void 0) return { impact: null, reason: "candidate declares no engines.node" };
+  if ((parse_version(nodeVersion)?.pre.length ?? 0) > 0) return { impact: null, reason: `running Node ${nodeVersion} is a prerelease` };
+  const ok = node_engine_satisfied(range, nodeVersion);
+  if (ok === true) return { impact: null, reason: null };
+  const why = ok === false ? "is not satisfied by" : "cannot be checked against";
+  return { impact: "action", reason: `engines.node '${String(range)}' ${why} ${nodeVersion}` };
+}
+function suppression(input) {
+  if (input.env.ci) return "suppressed: CI";
+  if (!input.env.interactive) return "suppressed: non-interactive";
+  if (input.origin === "source-checkout") return "suppressed: source checkout";
+  if (input.origin === "ephemeral") return "suppressed: ephemeral npx run has nothing to update";
+  if (input.env.noUpdateCheck) return "suppressed: AGENT_CONFIG_NO_UPDATE_CHECK=1";
+  if (input.settings.mode === "off") return "suppressed: mode off";
+  return null;
+}
+function classifyUpdate(input) {
+  const suppressed = suppression(input);
+  if (suppressed !== null) return { action: "none", reasons: [suppressed] };
+  const order = compare_versions(input.candidate, input.installed);
+  if (order === null) return { action: "none", reasons: ["unparseable version: no action"] };
+  if (order !== 1) return { action: "none", reasons: [`candidate ${input.candidate} is not newer than ${input.installed}`] };
+  const ask = [];
+  const uncertain = [];
+  const local = machine_override(input.engines, input.env.nodeVersion);
+  if (local.impact === "action") return { action: "action", reasons: [local.reason] };
+  if (local.reason !== null) uncertain.push(local.reason);
+  const range = read_impact_range(input.impactMap, input.installed, input.candidate);
+  const security = range?.security === true;
+  const waits = [];
+  if (input.deprecated === true || typeof input.deprecated === "string" && input.deprecated !== "") {
+    waits.push("wait: candidate is deprecated");
+  }
+  const gateHours = input.settings.minReleaseAgeHours ?? 0;
+  if (!Number.isFinite(gateHours)) uncertain.push("release-age gate is not a number");
+  else if (gateHours > 0) {
+    const published = input.publishedAt === null ? NaN : Date.parse(input.publishedAt);
+    const now = Date.parse(input.env.now);
+    if (Number.isNaN(published) || Number.isNaN(now)) uncertain.push("publish time unknown under a release-age gate");
+    else if (now - published < gateHours * 36e5) waits.push(`wait: published less than ${gateHours} h ago`);
+  }
+  if (waits.length > 0) {
+    return security ? { action: "notify", reasons: [...waits, "security fix in range"] } : { action: "none", reasons: waits };
+  }
+  if (range === null) uncertain.push("impact map unavailable");
+  else if (range.forged !== null) ask.push(`untrusted impact map: ${range.forged}`);
+  else if (range.worst === "action") ask.push("a release in range needs consumer action");
+  if (ask.length > 0) return { action: "ask", reasons: ask };
+  const notify = [];
+  if (range?.worst === "notice") notify.push("a release in range carries a notice");
+  if (security) notify.push("security fix in range");
+  if (input.provenance !== true) uncertain.push("provenance attestation missing");
+  if (input.settings.projectPin) uncertain.push(`project pins ${input.settings.projectPin}`);
+  else if (input.origin === "project-pin") uncertain.push("install is pinned by the project");
+  if (input.origin === "unknown") uncertain.push("install origin unknown");
+  if (parse_version(input.candidate).pre.length > 0) uncertain.push("candidate is a prerelease");
+  if (input.settings.mode === void 0) uncertain.push("update mode not set");
+  const blocking = [...uncertain, ...range?.worst === "notice" ? notify : []];
+  if (blocking.length > 0) return { action: "notify", reasons: [...uncertain, ...notify] };
+  if (input.settings.mode !== "auto") return { action: "notify", reasons: [`mode ${input.settings.mode} does not install`, ...notify] };
+  return { action: "auto", reasons: ["every input known and no release in range needs a hand", ...notify] };
+}
+
+export {
+  isSourceCheckoutPackage,
+  INSTALL_MODE_MARKER_RELATIVE,
+  _is_global_only_consumer,
+  originForPackageRoot,
+  classifyUpdate
+};

package/dist/cli-delegate/chunk-3PK3VZHB.js

@@ -0,0 +1,235 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  getLogPath
+} from "./chunk-W5JXMF2T.js";
+import {
+  classifyOwnership
+} from "./chunk-J2SJZICO.js";
+
+// src/install/preserve.ts
+var SIDECAR_SUFFIX = ".agent-config.new";
+var EXIT_COMPLETED_WITH_CONFLICTS = 3;
+function isLedgerMigration(inputs) {
+  if (!inputs.exists || inputs.force || inputs.loggedWrite === true) return false;
+  if (inputs.ledgerListed !== true) return false;
+  if (inputs.onDiskSha256 === null) return false;
+  return classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256) === "unknown";
+}
+function logProofApplies(inputs) {
+  if (!inputs.exists || inputs.force || inputs.onDiskSha256 === null) return false;
+  const ownership = classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256);
+  if (ownership === "recorded-modified") return inputs.recordedIsStaged === true;
+  return ownership === "unknown" && isLedgerMigration({ ...inputs, loggedWrite: false });
+}
+function decideDeployWrite(inputs) {
+  if (!inputs.exists) return "write";
+  if (inputs.force) return "write";
+  if (inputs.loggedWrite === true && logProofApplies(inputs)) return "write";
+  const ownership = classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256);
+  if (ownership === "recorded-modified") return "preserve";
+  if (ownership === "unknown" && isLedgerMigration(inputs)) {
+    return inputs.packagedSha256 != null && inputs.packagedSha256 === inputs.onDiskSha256 ? "write" : "preserve";
+  }
+  return "write";
+}
+function sidecarPathFor(target) {
+  return `${target}${SIDECAR_SUFFIX}`;
+}
+function preservedFileMessage(target, sidecar) {
+  return `Preserved user-modified ${target}. Package content was written to ${sidecar}; the active installation is not current. Review and merge it, or rerun with --force to replace the managed file.`;
+}
+function migrationPreservedMessage(target, sidecar) {
+  return `Preserved ${target} without being able to classify it: this package deployed it before it began recording digests, so an edit and an older version look the same here. Package content was written to ${sidecar}; the active installation is not current. Review and merge it, or rerun with --force to replace the managed file. Once resolved, this file is classified normally on every later install.`;
+}
+function conflictSummaryMessage(count) {
+  const noun = count === 1 ? "file" : "files";
+  return `Completed with conflicts: ${count} user-modified ${noun} preserved. Package content is staged alongside as *${SIDECAR_SUFFIX}; the active installation is not current until you merge it, or rerun with --force to replace the managed ${noun}.`;
+}
+function foreignSidecarMessage(target, sidecar) {
+  return `Refusing to replace ${sidecar}: it already exists with different content and this install cannot show it wrote it. Package content for ${target} was NOT staged. Move or delete that file and re-run, or rerun with --force to replace the managed file instead.`;
+}
+
+// src/install/loggedWrites.ts
+import { gunzipSync } from "node:zlib";
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+var WRITE_MARKER = '"kind":"write"';
+var fileCache = /* @__PURE__ */ new Map();
+var dirRealpaths = /* @__PURE__ */ new Map();
+function canonicalPath(p) {
+  const abs = resolve(p);
+  const dir = dirname(abs);
+  let real = dirRealpaths.get(dir);
+  if (real === void 0) {
+    try {
+      real = realpathSync(dir);
+    } catch {
+      real = dir;
+    }
+    dirRealpaths.set(dir, real);
+  }
+  return join(real, basename(abs));
+}
+function logFiles(logPath) {
+  const dir = dirname(logPath);
+  if (!existsSync(dir)) return [];
+  const stem = basename(logPath).replace(/\.jsonl$/, "");
+  try {
+    return readdirSync(dir).filter((n) => n.startsWith(stem) && (n.endsWith(".jsonl") || n.endsWith(".jsonl.gz"))).map((n) => join(dir, n)).sort();
+  } catch {
+    return [];
+  }
+}
+function writesIn(file) {
+  let stamp;
+  try {
+    const st = statSync(file);
+    stamp = `${st.size}:${Math.trunc(st.mtimeMs)}`;
+  } catch {
+    return [];
+  }
+  const cached = fileCache.get(file);
+  if (cached !== void 0 && cached.stamp === stamp) return cached.entries;
+  let text = "";
+  try {
+    const raw = readFileSync(file);
+    text = (file.endsWith(".gz") ? gunzipSync(raw) : raw).toString("utf8");
+  } catch {
+    text = "";
+  }
+  const entries = [];
+  for (const line of text.split("\n")) {
+    if (!line.includes(WRITE_MARKER)) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof entry.path !== "string" || typeof entry.sha256 !== "string" || entry.sha256 === "") continue;
+    entries.push([canonicalPath(entry.path), entry.sha256]);
+  }
+  fileCache.set(file, { stamp, entries });
+  return entries;
+}
+function loggedWriteDigests(logPath = getLogPath()) {
+  const writes = /* @__PURE__ */ new Map();
+  for (const file of logFiles(logPath)) {
+    for (const [target, sha] of writesIn(file)) {
+      let set = writes.get(target);
+      if (set === void 0) writes.set(target, set = /* @__PURE__ */ new Set());
+      set.add(sha);
+    }
+  }
+  return writes;
+}
+function onlyDeployed(anchor, currentFiles, log) {
+  return (target) => {
+    const rel = relative(resolve(anchor), resolve(target)).split(sep).join("/");
+    if (currentFiles.has(rel)) log(target);
+  };
+}
+function wroteTheseBytes(target, onDiskSha256, writes) {
+  return writes.get(canonicalPath(target))?.has(onDiskSha256) === true;
+}
+
+// src/install/plan.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { join as join2, relative as relative2, resolve as resolve2 } from "node:path";
+function sha256File(path) {
+  try {
+    const data = readFileSync2(path);
+    return createHash("sha256").update(data).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function fileEntry(path, kind, options) {
+  return {
+    path,
+    kind,
+    sha256: options.hashContent ? sha256File(path) : null
+  };
+}
+function walkSourceTree(dir) {
+  const out = [];
+  walkInto(dir, out);
+  return out;
+}
+function walkInto(dir, out) {
+  let entries;
+  try {
+    entries = readdirSync2(dir).sort();
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = join2(dir, name);
+    let isDir;
+    try {
+      isDir = statSync2(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      walkInto(full, out);
+    } else {
+      out.push(full);
+    }
+  }
+}
+function buildInstallPlan(inputs) {
+  const filesByTool = {};
+  for (const source of inputs.sources) {
+    const bucket = filesByTool[source.toolId] ?? [];
+    let files = walkSourceTree(source.srcDir);
+    if (source.fileFilter !== void 0) {
+      files = files.filter(source.fileFilter);
+    }
+    for (const srcFile of files) {
+      const rel = relative2(source.srcDir, srcFile);
+      const destPath = resolve2(source.destDir, rel);
+      bucket.push(
+        fileEntry(srcFile, source.kind, {
+          hashContent: source.kind !== "bridge"
+        })
+      );
+      bucket[bucket.length - 1] = {
+        ...bucket[bucket.length - 1],
+        path: destPath
+      };
+    }
+    filesByTool[source.toolId] = bucket;
+  }
+  for (const source of inputs.sources) {
+    if (!(source.toolId in filesByTool)) {
+      filesByTool[source.toolId] = [];
+    }
+  }
+  return {
+    version: 2,
+    target: inputs.target,
+    root: inputs.root,
+    filesByTool,
+    mergedKeysByTool: {},
+    policy: inputs.policy
+  };
+}
+
+export {
+  EXIT_COMPLETED_WITH_CONFLICTS,
+  isLedgerMigration,
+  logProofApplies,
+  decideDeployWrite,
+  sidecarPathFor,
+  preservedFileMessage,
+  migrationPreservedMessage,
+  conflictSummaryMessage,
+  foreignSidecarMessage,
+  loggedWriteDigests,
+  onlyDeployed,
+  wroteTheseBytes,
+  sha256File,
+  buildInstallPlan
+};

package/dist/cli-delegate/{chunk-OKJUIAPS.js → chunk-4E2W63DA.js}

@@ -2,12 +2,6 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   write_atomic
 } from "./chunk-MWRD5YOH.js";
-import {
-  require_dist
-} from "./chunk-OY53J6II.js";
-import {
-  __toESM
-} from "./chunk-J55WI3RR.js";
 
 // src/scripts/_lib/installed_tools.ts
 import * as fs from "node:fs";
@@ -330,57 +324,6 @@ function _today() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 
-// src/install/recordedOwnership.ts
-var YAML = __toESM(require_dist(), 1);
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { isAbsolute, join as join2, resolve } from "node:path";
-var NO_RECORDED_HASHES = /* @__PURE__ */ new Map();
-function classifyOwnership(recordedSha256, onDiskSha256) {
-  if (recordedSha256 === void 0 || recordedSha256 === null) return "unknown";
-  if (onDiskSha256 === null) return "unknown";
-  return recordedSha256 === onDiskSha256 ? "recorded-unchanged" : "recorded-modified";
-}
-function readRecordedHashes(manifestPath, projectRoot) {
-  if (!existsSync(manifestPath)) return NO_RECORDED_HASHES;
-  let doc;
-  try {
-    doc = YAML.parse(readFileSync2(manifestPath, "utf8"));
-  } catch {
-    return NO_RECORDED_HASHES;
-  }
-  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) return NO_RECORDED_HASHES;
-  const tools = doc["tools"];
-  if (!Array.isArray(tools)) return NO_RECORDED_HASHES;
-  const out = /* @__PURE__ */ new Map();
-  for (const tool of tools) {
-    if (tool === null || typeof tool !== "object" || Array.isArray(tool)) continue;
-    const files = tool["files"];
-    if (!Array.isArray(files)) continue;
-    for (const entry of files) {
-      if (entry === null || typeof entry !== "object" || Array.isArray(entry)) continue;
-      const rec = entry;
-      const raw = rec["path"];
-      if (typeof raw !== "string" || raw.length === 0) continue;
-      const sha = rec["sha256"];
-      const expanded = expanduser2(raw);
-      const target = isAbsolute(expanded) ? resolve(expanded) : resolve(projectRoot, expanded);
-      out.set(target, typeof sha === "string" && sha.length > 0 ? sha : null);
-    }
-  }
-  return out;
-}
-function expanduser2(p) {
-  if (p === "~") return homedir2();
-  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return join2(homedir2(), p.slice(2));
-  }
-  return p;
-}
-function recordedHashesForRoot(root, env) {
-  return readRecordedHashes(manifest_path(root, env), root);
-}
-
 export {
   SCHEMA_VERSIONS_SUPPORTED,
   DEFAULT_DEPLOY_ROOTS,
@@ -388,9 +331,5 @@ export {
   read_manifest,
   write_manifest,
   ScopeMismatchError,
-  upsert_tool,
-  NO_RECORDED_HASHES,
-  classifyOwnership,
-  readRecordedHashes,
-  recordedHashesForRoot
+  upsert_tool
 };

package/dist/cli-delegate/chunk-5VO3RTMV.js

@@ -0,0 +1,208 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  write_target
+} from "./chunk-T6BP34WI.js";
+
+// src/scripts/_lib/version_order.ts
+var NUM = "(0|[1-9]\\d*)";
+var IDENT = "[0-9A-Za-z-]+";
+var VERSION_RE = new RegExp(
+  `^v*${NUM}\\.${NUM}\\.${NUM}(?:-(${IDENT}(?:\\.${IDENT})*))?(?:\\+${IDENT}(?:\\.${IDENT})*)?$`
+);
+function parse_version(v) {
+  if (typeof v !== "string") return null;
+  const m = VERSION_RE.exec(v.trim());
+  if (!m) return null;
+  const pre = m[4] === void 0 ? [] : m[4].split(".").map((id) => /^\d+$/.test(id) ? Number(id) : id);
+  return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]), pre };
+}
+function cmp_num(a, b) {
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+function compare_parsed(a, b) {
+  const core = cmp_num(a.major, b.major) || cmp_num(a.minor, b.minor) || cmp_num(a.patch, b.patch);
+  if (core !== 0) return core;
+  if (a.pre.length === 0 || b.pre.length === 0) return cmp_num(b.pre.length, a.pre.length);
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i += 1) {
+    const x = a.pre[i];
+    const y = b.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (typeof x === "number" && typeof y === "number") {
+      if (x !== y) return cmp_num(x, y);
+    } else if (typeof x === "number") {
+      return -1;
+    } else if (typeof y === "number") {
+      return 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function compare_versions(a, b) {
+  const pa = parse_version(a);
+  const pb = parse_version(b);
+  if (pa === null || pb === null) return null;
+  return compare_parsed(pa, pb);
+}
+var PARTIAL_RE = /^(\^|~|>=|<=|>|<|=)?v?(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?$/;
+function at(major, minor = 0, patch = 0) {
+  return { major, minor, patch, pre: [] };
+}
+function bounds_for(token) {
+  if (token === "*" || token === "x" || token === "X") return [];
+  const m = PARTIAL_RE.exec(token);
+  if (!m) return null;
+  const op = m[1] ?? "=";
+  const parts = [m[2], m[3], m[4]];
+  const known = [];
+  for (const p of parts) {
+    if (p === void 0 || /^[xX*]$/.test(p)) break;
+    known.push(Number(p));
+  }
+  if (known.length === 0) return op === "<" || op === ">" ? null : [];
+  const [M, mi = 0, pa = 0] = known;
+  const full = known.length === 3;
+  const next = known.length === 1 ? at(M + 1) : known.length === 2 ? at(M, mi + 1) : at(M, mi, pa + 1);
+  const base = at(M, mi, pa);
+  switch (op) {
+    case "^": {
+      const upper = M > 0 ? at(M + 1) : known.length === 1 ? at(1) : mi > 0 ? at(0, mi + 1) : full ? at(0, 0, pa + 1) : at(0, 1);
+      return [{ op: ">=", v: base }, { op: "<", v: upper }];
+    }
+    case "~":
+      return [{ op: ">=", v: base }, { op: "<", v: known.length === 1 ? at(M + 1) : at(M, mi + 1) }];
+    case ">=":
+      return [{ op: ">=", v: base }];
+    case "<":
+      return [{ op: "<", v: base }];
+    case ">":
+      return [full ? { op: ">", v: base } : { op: ">=", v: next }];
+    case "<=":
+      return [full ? { op: "<=", v: base } : { op: "<", v: next }];
+    default:
+      return full ? [{ op: "=", v: base }] : [{ op: ">=", v: base }, { op: "<", v: next }];
+  }
+}
+function holds(b, v) {
+  const c = compare_parsed(v, b.v);
+  if (b.op === ">=") return c >= 0;
+  if (b.op === ">") return c > 0;
+  if (b.op === "<") return c < 0;
+  if (b.op === "<=") return c <= 0;
+  return c === 0;
+}
+function node_engine_satisfied(range, runtime) {
+  const v = parse_version(runtime);
+  if (v === null || typeof range !== "string") return null;
+  const sets = [];
+  for (const alt of range.split("||")) {
+    const tokens = alt.trim().replace(/(\^|~|>=|<=|>|<|=)\s+/g, "$1").split(/\s+/).filter(Boolean);
+    if (tokens.includes("-")) return null;
+    const set = [];
+    for (const t of tokens) {
+      const b = bounds_for(t);
+      if (b === null) return null;
+      set.push(...b);
+    }
+    sets.push(set);
+  }
+  if (v.pre.length > 0) return null;
+  return sets.some((set) => set.every((b) => holds(b, v)));
+}
+
+// src/scripts/_lib/update_check.ts
+var PACKAGE_NAME = "@event4u/agent-config";
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var FETCH_TIMEOUT_S = 1;
+var CHECK_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var STATE_FILENAME = "update-check.json";
+var DEFAULT_STATE_PATH = write_target(STATE_FILENAME);
+async function fetch_latest_from_npm(options = {}) {
+  return (await fetch_latest_document(options))?.version ?? null;
+}
+async function fetch_latest_document(options = {}) {
+  const timeout = options.timeout ?? FETCH_TIMEOUT_S;
+  const url = options.url ?? NPM_REGISTRY_URL;
+  const fetch_impl = options.fetch_impl ?? fetch;
+  try {
+    const resp = await fetch_impl(url, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "agent-config-update-check"
+      },
+      signal: AbortSignal.timeout(timeout * 1e3)
+    });
+    const payload = await resp.json();
+    if (payload !== null && typeof payload === "object" && !Array.isArray(payload)) {
+      const doc = payload;
+      const version = doc["version"];
+      if (typeof version === "string" && version.trim()) {
+        const cfg = doc["agentConfig"];
+        const impact = cfg !== null && typeof cfg === "object" && !Array.isArray(cfg) ? cfg["impact"] : null;
+        return { version: version.trim(), impact: impact ?? null };
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+var GLOBAL_TREE = /[\\/](?:lib|npm)[\\/]node_modules[\\/]@event4u[\\/]agent-config[\\/]?$/;
+function classify_install_origin(signals) {
+  const pin = signals.project_pin?.trim() ?? "";
+  if (pin !== "") {
+    return signals.latest && _is_newer(signals.latest, pin) ? "project-pin" : "unknown";
+  }
+  if (signals.package_root.split(/[\\/]+/).includes("_npx")) {
+    return "ephemeral";
+  }
+  if (signals.is_global_consumer || GLOBAL_TREE.test(signals.package_root)) {
+    return "global";
+  }
+  return "unknown";
+}
+function _int_or_zero(part) {
+  const trimmed = part.trim();
+  if (/^[+-]?\d+$/.test(trimmed)) {
+    return parseInt(trimmed, 10);
+  }
+  return 0;
+}
+function _is_newer(latest, installed) {
+  const parse = (v) => {
+    const core = v.replace(/^v+/, "").split("-")[0] ?? "";
+    const parts = core.split(".");
+    const out = [];
+    for (const p of parts.slice(0, 3)) {
+      out.push(_int_or_zero(p));
+    }
+    while (out.length < 3) {
+      out.push(0);
+    }
+    return [out[0], out[1], out[2]];
+  };
+  const a = parse(latest);
+  const b = parse(installed);
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] > b[i]) {
+      return true;
+    }
+    if (a[i] < b[i]) {
+      return false;
+    }
+  }
+  return false;
+}
+
+export {
+  parse_version,
+  compare_versions,
+  node_engine_satisfied,
+  STATE_FILENAME,
+  DEFAULT_STATE_PATH,
+  fetch_latest_from_npm,
+  classify_install_origin,
+  _is_newer
+};

package/dist/cli-delegate/chunk-6E2LDY4F.js

@@ -0,0 +1,27 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/session_tag.ts
+import { createHash } from "node:crypto";
+var _WS_RE = /\s+/g;
+var SESSION_ID_LEN = 16;
+var SESSION_ID_UNKNOWN = "<unknown>";
+var SESSION_ID_LEGACY = "<legacy>";
+function _strip(s) {
+  return s.replace(/^\s+/u, "").replace(/\s+$/u, "");
+}
+function fingerprint(value) {
+  const normalized = _strip((value || "").replace(_WS_RE, " "));
+  return createHash("sha256").update(normalized, "utf-8").digest("hex");
+}
+function derive_session_tag(session_id) {
+  if (!session_id) {
+    return SESSION_ID_UNKNOWN;
+  }
+  return fingerprint(session_id).slice(0, SESSION_ID_LEN);
+}
+
+export {
+  SESSION_ID_UNKNOWN,
+  SESSION_ID_LEGACY,
+  derive_session_tag
+};