@event4u/agent-config 16.4.0 → 17.0.0

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

@@ -0,0 +1,698 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  manifest_path
+} from "./chunk-4E2W63DA.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  write_target
+} from "./chunk-T6BP34WI.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_lib/global_deploy_inventory.ts
+var global_deploy_inventory_exports = {};
+__export(global_deploy_inventory_exports, {
+  INVENTORY_BASENAME: () => INVENTORY_BASENAME,
+  INVENTORY_ENV: () => INVENTORY_ENV,
+  SCHEMA_VERSION: () => SCHEMA_VERSION,
+  expected_deploy_files: () => expected_deploy_files,
+  file_sha256: () => file_sha256,
+  inventory_path: () => inventory_path,
+  is_ancestor: () => is_ancestor,
+  load_inventory: () => load_inventory,
+  reap_stale: () => reap_stale,
+  reap_tagged_orphans: () => reap_tagged_orphans,
+  record_deploy: () => record_deploy,
+  recorded_absolute_digests: () => recorded_absolute_digests,
+  recorded_absolute_files: () => recorded_absolute_files,
+  recorded_digests: () => recorded_digests,
+  recorded_rel_files: () => recorded_rel_files,
+  save_inventory: () => save_inventory
+});
+import { createHash, randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var SCHEMA_VERSION = 2;
+var INVENTORY_BASENAME = "deployed-files.json";
+var INVENTORY_ENV = "AGENT_CONFIG_DEPLOY_INVENTORY";
+function expanduser(p) {
+  if (p === "~") {
+    return os.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function expanduser_at(p, home) {
+  if (home === void 0 || home === null || home === "") return expanduser(p);
+  if (p === "~") return home;
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path.join(home, p.slice(2));
+  }
+  return p;
+}
+function resolve_path(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    const abs = path.resolve(p);
+    const parts = abs.split(path.sep);
+    for (let i = parts.length; i > 0; i -= 1) {
+      const prefix = parts.slice(0, i).join(path.sep) || path.sep;
+      try {
+        const real = fs.realpathSync(prefix);
+        const rest = parts.slice(i);
+        return rest.length > 0 ? path.join(real, ...rest) : real;
+      } catch {
+        continue;
+      }
+    }
+    return abs;
+  }
+}
+function path_exists(p) {
+  try {
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function inventory_path(env) {
+  const env_map = env ?? process.env;
+  const override = env_map[INVENTORY_ENV];
+  if (override) {
+    return expanduser(override);
+  }
+  return write_target(INVENTORY_BASENAME, { env: env ?? null });
+}
+function load_inventory(p) {
+  const target = p ?? inventory_path();
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(target, { encoding: "utf-8" }));
+  } catch {
+    return { schema_version: SCHEMA_VERSION, tools: {} };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data) || typeof data["tools"] !== "object" || data["tools"] === null || Array.isArray(data["tools"])) {
+    return { schema_version: SCHEMA_VERSION, tools: {} };
+  }
+  return data;
+}
+function save_inventory(data, p) {
+  const target = p ?? inventory_path();
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const payload = json_dumps_sorted(data, 2) + "\n";
+  const parent = path.dirname(target);
+  let fd = null;
+  let tmp_name = "";
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    tmp_name = path.join(parent, `${path.basename(target)}.${randomBytes(6).toString("hex")}`);
+    try {
+      fd = fs.openSync(tmp_name, "wx", 384);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        continue;
+      }
+      throw err;
+    }
+  }
+  if (fd === null) {
+    throw new Error("save_inventory: could not create a unique temp file");
+  }
+  try {
+    fs.writeFileSync(fd, payload, { encoding: "utf-8" });
+    fs.closeSync(fd);
+    fs.renameSync(tmp_name, target);
+  } catch (err) {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(tmp_name);
+    } catch {
+    }
+    throw err;
+  }
+  return target;
+}
+function json_dumps_sorted(value, indent) {
+  return render_json(value, indent, 0);
+}
+function render_json(value, indent, depth) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    return json_string_ascii(value);
+  }
+  const pad = " ".repeat(indent * (depth + 1));
+  const close_pad = " ".repeat(indent * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((v) => pad + render_json(v, indent, depth + 1));
+    return "[\n" + items.join(",\n") + "\n" + close_pad + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    const items = keys.map(
+      (k) => pad + json_string_ascii(k) + ": " + render_json(obj[k], indent, depth + 1)
+    );
+    return "{\n" + items.join(",\n") + "\n" + close_pad + "}";
+  }
+  return "null";
+}
+function json_string_ascii(s) {
+  const base = JSON.stringify(s);
+  let out = "";
+  for (let i = 0; i < base.length; i += 1) {
+    const code = base.charCodeAt(i);
+    if (code > 126) {
+      out += "\\u" + code.toString(16).padStart(4, "0");
+    } else {
+      out += base[i];
+    }
+  }
+  return out;
+}
+function expected_deploy_files(src, dest_rel, file_filter = null) {
+  const out = /* @__PURE__ */ new Set();
+  let src_stat;
+  try {
+    src_stat = fs.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 = fs.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    for (const name of entries) {
+      const entry = path.join(node, name);
+      const rel = join_rel(prefix, name);
+      const lst = fs.lstatSync(entry);
+      if (lst.isDirectory() && !lst.isSymbolicLink()) {
+        _walk(entry, rel);
+        continue;
+      }
+      let resolved_is_dir = false;
+      try {
+        resolved_is_dir = fs.statSync(entry).isDirectory();
+      } catch {
+        resolved_is_dir = false;
+      }
+      if (resolved_is_dir) {
+        _walk(fs.realpathSync(entry), rel);
+        continue;
+      }
+      if (file_filter !== null && !file_filter(entry)) {
+        continue;
+      }
+      out.add(as_posix(rel));
+    }
+  };
+  _walk(src, dest_rel);
+  return out;
+}
+function join_rel(prefix, name) {
+  return prefix ? path.join(prefix, name) : name;
+}
+function as_posix(p) {
+  if (p === "") {
+    return ".";
+  }
+  return p.split(path.sep).join("/");
+}
+function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false, retained = null) {
+  const tools = inventory["tools"] ?? {};
+  const entry = tools[tool_id];
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return [];
+  }
+  const e = entry;
+  const recorded_anchor = e["anchor"];
+  const prev_files = e["files"];
+  if (typeof recorded_anchor !== "string" || !Array.isArray(prev_files)) {
+    return [];
+  }
+  const anchor_resolved = resolve_path(expanduser(anchor));
+  if (resolve_path(expanduser(recorded_anchor)) !== anchor_resolved) {
+    return [];
+  }
+  const deleted = [];
+  const prune_candidates = /* @__PURE__ */ new Set();
+  const digests = digests_of_entry(e);
+  const recorded = [...digests].filter(([, d]) => !(dry_run && d.kind === "sidecar")).map(([rel]) => rel);
+  const orphans = difference([...prev_files, ...recorded], current_files);
+  for (const rel of sorted_strings(orphans)) {
+    if (typeof rel !== "string" || !rel || rel.startsWith("/") || rel.startsWith("..")) {
+      continue;
+    }
+    const target = path.join(anchor_resolved, rel);
+    try {
+      relative_to(resolve_path(path.dirname(target)), anchor_resolved);
+    } catch {
+      continue;
+    }
+    let lst = null;
+    try {
+      lst = fs.lstatSync(target);
+    } catch {
+      lst = null;
+    }
+    if (lst && lst.isDirectory() && !lst.isSymbolicLink()) {
+      continue;
+    }
+    if (lst !== null && edited_since_install(target, digests.get(rel))) {
+      retained?.push(target);
+      continue;
+    }
+    if (dry_run) {
+      if (path_exists(target) || lst !== null && lst.isSymbolicLink()) {
+        deleted.push(target);
+      }
+      continue;
+    }
+    try {
+      fs.unlinkSync(target);
+    } catch {
+      continue;
+    }
+    deleted.push(target);
+    prune_candidates.add(path.dirname(target));
+  }
+  prune_empty_dirs(prune_candidates, anchor_resolved);
+  return deleted;
+}
+function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_run = false, digests = /* @__PURE__ */ new Map(), retained = null) {
+  const anchor_resolved = resolve_path(expanduser(anchor));
+  const deleted = [];
+  const prune_candidates = /* @__PURE__ */ new Set();
+  const needle = `package: ${package_tag}`;
+  for (const dest_sub of dest_subs) {
+    const root = dest_sub ? path.join(anchor_resolved, dest_sub) : anchor_resolved;
+    let root_stat;
+    try {
+      root_stat = fs.statSync(root);
+    } catch {
+      continue;
+    }
+    if (!root_stat.isDirectory()) {
+      continue;
+    }
+    for (const md of rglob_md(root)) {
+      let md_lst;
+      try {
+        md_lst = fs.lstatSync(md);
+      } catch {
+        continue;
+      }
+      if (md_lst.isDirectory()) {
+        continue;
+      }
+      const rel = relative_to_posix(md, anchor_resolved);
+      if (current_files.has(rel)) {
+        continue;
+      }
+      try {
+        relative_to(resolve_path(path.dirname(md)), anchor_resolved);
+      } catch {
+        continue;
+      }
+      let head;
+      try {
+        head = fs.readFileSync(md, { encoding: "utf-8" });
+      } catch {
+        continue;
+      }
+      if (!head.startsWith("---")) {
+        continue;
+      }
+      const end = head.indexOf("\n---", 3);
+      const block = head.slice(0, end !== -1 ? end : head.length);
+      const hit = splitlines(block).some((line) => line.trim() === needle);
+      if (!hit) {
+        continue;
+      }
+      if (edited_since_install(md, digests.get(rel))) {
+        retained?.push(md);
+        continue;
+      }
+      if (dry_run) {
+        deleted.push(md);
+        continue;
+      }
+      try {
+        fs.unlinkSync(md);
+      } catch {
+        continue;
+      }
+      deleted.push(md);
+      prune_candidates.add(path.dirname(md));
+    }
+  }
+  prune_empty_dirs(prune_candidates, anchor_resolved);
+  return deleted;
+}
+function record_deploy(tool_id, anchor, current_files, inventory, digests = null) {
+  if (typeof inventory["tools"] !== "object" || inventory["tools"] === null || Array.isArray(inventory["tools"])) {
+    inventory["tools"] = {};
+  }
+  const tools = inventory["tools"];
+  const record = {
+    anchor: String(anchor),
+    files: sorted_strings([...current_files])
+  };
+  if (digests !== null && digests.size > 0) {
+    record["digests"] = Object.fromEntries(
+      sorted_strings([...digests.keys()]).map((rel) => [rel, { ...digests.get(rel) }])
+    );
+  }
+  tools[tool_id] = record;
+  inventory["schema_version"] = SCHEMA_VERSION;
+  return inventory;
+}
+function file_sha256(p) {
+  try {
+    return createHash("sha256").update(fs.readFileSync(p)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function edited_since_install(target, rec) {
+  if (rec === void 0) return false;
+  const on_disk = file_sha256(target);
+  if (on_disk !== null) return on_disk !== rec.installed_sha256;
+  try {
+    return !fs.lstatSync(target).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function digests_of_entry(e) {
+  const out = /* @__PURE__ */ new Map();
+  const raw = e["digests"];
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return out;
+  for (const [rel, rec] of Object.entries(raw)) {
+    if (typeof rec !== "object" || rec === null || Array.isArray(rec)) continue;
+    const r = rec;
+    const installed = r["installed_sha256"];
+    const packaged = r["packaged_sha256"];
+    if (typeof installed !== "string" || installed === "") continue;
+    out.set(rel, {
+      installed_sha256: installed,
+      packaged_sha256: typeof packaged === "string" && packaged !== "" ? packaged : null,
+      ...r["kind"] === "sidecar" ? { kind: "sidecar" } : {}
+    });
+  }
+  return out;
+}
+function recorded_digests(tool_id, anchor, inventory) {
+  const inv = inventory ?? load_inventory();
+  const tools = inv["tools"] ?? {};
+  const entry = tools[tool_id];
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return /* @__PURE__ */ new Map();
+  const e = entry;
+  const recorded_anchor = e["anchor"];
+  if (typeof recorded_anchor !== "string") return /* @__PURE__ */ new Map();
+  if (resolve_path(expanduser(recorded_anchor)) !== resolve_path(expanduser(anchor))) {
+    return /* @__PURE__ */ new Map();
+  }
+  return digests_of_entry(e);
+}
+function recorded_absolute_digests(inventory, home) {
+  const inv = inventory ?? load_inventory();
+  const tools = inv["tools"] ?? {};
+  const out = /* @__PURE__ */ new Map();
+  if (typeof tools !== "object" || tools === null || Array.isArray(tools)) return out;
+  for (const entry of Object.values(tools)) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
+    const e = entry;
+    const anchor = e["anchor"];
+    if (typeof anchor !== "string") continue;
+    const expanded = expanduser_at(anchor, home);
+    for (const [rel, rec] of digests_of_entry(e)) {
+      const lexical = path.resolve(expanded, rel);
+      out.set(lexical, rec.installed_sha256);
+      out.set(resolve_path(lexical), rec.installed_sha256);
+    }
+  }
+  return out;
+}
+function prune_empty_dirs(prune_candidates, anchor_resolved) {
+  const ordered = [...prune_candidates].sort(
+    (a, b) => b.split(path.sep).length - a.split(path.sep).length
+  );
+  for (const start of ordered) {
+    let node = start;
+    while (node !== anchor_resolved && is_ancestor(anchor_resolved, node)) {
+      try {
+        fs.rmdirSync(node);
+      } catch {
+        break;
+      }
+      node = path.dirname(node);
+    }
+  }
+}
+function is_ancestor(anchor, node) {
+  const rel = path.relative(anchor, node);
+  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function relative_to(child, parent) {
+  if (child === parent) {
+    return "";
+  }
+  const rel = path.relative(parent, child);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error(`'${child}' is not in the subpath of '${parent}'`);
+  }
+  return rel;
+}
+function relative_to_posix(child, parent) {
+  return path.relative(parent, child).split(path.sep).join("/");
+}
+function rglob_md(root) {
+  const out = [];
+  const walk = (dir) => {
+    let names;
+    try {
+      names = fs.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const full = path.join(dir, name);
+      let lst;
+      try {
+        lst = fs.lstatSync(full);
+      } catch {
+        continue;
+      }
+      if (lst.isDirectory() && !lst.isSymbolicLink()) {
+        walk(full);
+      } else if (name.endsWith(".md")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root);
+  return out;
+}
+function difference(prev, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of prev) {
+    if (typeof item === "string" && current.has(item)) {
+      continue;
+    }
+    if (seen.has(item)) {
+      continue;
+    }
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+function recorded_rel_files(tool_id, anchor, inventory) {
+  const inv = inventory ?? load_inventory();
+  const tools = inv["tools"] ?? {};
+  const entry = tools[tool_id];
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return /* @__PURE__ */ new Set();
+  }
+  const e = entry;
+  const recorded_anchor = e["anchor"];
+  const files = e["files"];
+  if (typeof recorded_anchor !== "string" || !Array.isArray(files)) {
+    return /* @__PURE__ */ new Set();
+  }
+  if (resolve_path(expanduser(recorded_anchor)) !== resolve_path(expanduser(anchor))) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(files.filter((f) => typeof f === "string"));
+}
+function recorded_absolute_files(inventory, home) {
+  const inv = inventory ?? load_inventory();
+  const tools = inv["tools"] ?? {};
+  const out = /* @__PURE__ */ new Set();
+  if (typeof tools !== "object" || tools === null || Array.isArray(tools)) return out;
+  for (const entry of Object.values(tools)) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
+    const e = entry;
+    const anchor = e["anchor"];
+    const files = e["files"];
+    if (typeof anchor !== "string" || !Array.isArray(files)) continue;
+    const expanded = expanduser_at(anchor, home);
+    for (const rel of files) {
+      if (typeof rel !== "string") continue;
+      const lexical = path.resolve(expanded, rel);
+      out.add(lexical);
+      out.add(resolve_path(lexical));
+    }
+  }
+  return out;
+}
+function sorted_strings(items) {
+  return items.filter((i) => typeof i === "string").sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function splitlines(text) {
+  const parts = text.split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+
+// 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 as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
+var NO_RECORDED_HASHES = /* @__PURE__ */ new Map();
+function classifyFileState(installedSha256, packagedSha256, onDiskSha256) {
+  if (installedSha256 === void 0 || installedSha256 === null) return "unknown";
+  if (onDiskSha256 === null) return "unknown";
+  const untouched = onDiskSha256 === installedSha256;
+  if (packagedSha256 === null) return untouched ? "retired-unmodified" : "retired-modified";
+  if (packagedSha256 !== void 0 && onDiskSha256 === packagedSha256) return "clean";
+  const shipsWhatWeWrote = packagedSha256 === void 0 || packagedSha256 === installedSha256;
+  if (untouched) return shipsWhatWeWrote ? "clean" : "outdated";
+  return shipsWhatWeWrote ? "customized" : "customized-and-outdated";
+}
+function ownershipOfState(state) {
+  switch (state) {
+    case "clean":
+    case "outdated":
+    case "retired-unmodified":
+      return "recorded-unchanged";
+    case "customized":
+    case "customized-and-outdated":
+    case "retired-modified":
+      return "recorded-modified";
+    case "unknown":
+      return "unknown";
+  }
+}
+function classifyOwnership(recordedSha256, onDiskSha256) {
+  return ownershipOfState(classifyFileState(recordedSha256, void 0, onDiskSha256));
+}
+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 = isAbsolute2(expanded) ? resolve2(expanded) : resolve2(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);
+}
+function ledgerListedPaths(env) {
+  return recorded_absolute_files(
+    load_inventory(inventory_path(env)),
+    env?.["HOME"]
+  );
+}
+function recordedHashesWithLedger(root, env) {
+  const out = new Map(recordedHashesForRoot(root, env));
+  const ledger = load_inventory(inventory_path(env));
+  for (const [target, sha] of recorded_absolute_digests(ledger, env?.["HOME"])) {
+    out.set(target, sha);
+  }
+  return out;
+}
+
+export {
+  INVENTORY_BASENAME,
+  inventory_path,
+  load_inventory,
+  save_inventory,
+  expected_deploy_files,
+  reap_stale,
+  reap_tagged_orphans,
+  record_deploy,
+  file_sha256,
+  recorded_digests,
+  is_ancestor,
+  recorded_rel_files,
+  recorded_absolute_files,
+  global_deploy_inventory_exports,
+  NO_RECORDED_HASHES,
+  classifyFileState,
+  ownershipOfState,
+  classifyOwnership,
+  readRecordedHashes,
+  ledgerListedPaths,
+  recordedHashesWithLedger
+};