@event4u/agent-config 9.9.0 → 9.11.0

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

@@ -0,0 +1,259 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  detectToolPresence
+} from "./chunk-OMIVVCG2.js";
+
+// src/install/preflight.ts
+import { accessSync, constants, existsSync as existsSync2, statSync as statSync2 } from "node:fs";
+import * as fs from "node:fs";
+import { dirname } from "node:path";
+
+// src/install/plan.ts
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+function sha256File(path) {
+  try {
+    const data = readFileSync(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 = readdirSync(dir).sort();
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = join(dir, name);
+    let isDir;
+    try {
+      isDir = statSync(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 = relative(source.srcDir, srcFile);
+      const destPath = resolve(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
+  };
+}
+
+// src/install/conflict.ts
+import { existsSync } from "node:fs";
+function isJsonTarget(entry) {
+  return entry.kind === "deployed" && entry.path.endsWith(".json");
+}
+function computeConflicts(plan) {
+  if (plan.policy.force) return [];
+  const out = [];
+  for (const entries of Object.values(plan.filesByTool)) {
+    for (const entry of entries) {
+      if (entry.kind === "bridge") continue;
+      if (entry.sha256 === null) continue;
+      if (!existsSync(entry.path)) continue;
+      if (plan.policy.knownPaths.has(entry.path)) continue;
+      const onDisk = sha256File(entry.path);
+      if (onDisk === entry.sha256) continue;
+      out.push({
+        path: entry.path,
+        kind: entry.kind,
+        plannedSha256: entry.sha256,
+        existingSha256: onDisk,
+        mergeable: isJsonTarget(entry)
+      });
+    }
+  }
+  return out;
+}
+
+// src/install/preflight.ts
+var DEFAULT_DISK_FLOOR_BYTES = 50 * 1024 * 1024;
+function nearestExistingAncestor(p) {
+  let cur = p;
+  while (!existsSync2(cur)) {
+    const parent = dirname(cur);
+    if (parent === cur) return cur;
+    cur = parent;
+  }
+  return cur;
+}
+function checkPermissions(inputs) {
+  const out = [];
+  const roots = /* @__PURE__ */ new Set([inputs.root, ...inputs.sources.map((s) => s.destDir)]);
+  for (const root of roots) {
+    const probe = nearestExistingAncestor(root);
+    try {
+      accessSync(probe, constants.W_OK);
+    } catch {
+      out.push({
+        id: "permissions",
+        severity: "blocking",
+        path: root,
+        message: `target root is not writable (nearest existing ancestor: ${probe})`,
+        remedy: `fix permissions on ${probe} or choose a different target`
+      });
+    }
+    if (existsSync2(root)) {
+      try {
+        if (!statSync2(root).isDirectory()) {
+          out.push({
+            id: "permissions",
+            severity: "blocking",
+            path: root,
+            message: "target root exists but is not a directory",
+            remedy: `move or remove the file at ${root}`
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+function checkDiskSpace(inputs, opts = {}) {
+  const floor = opts.diskFloorBytes ?? DEFAULT_DISK_FLOOR_BYTES;
+  const probe = nearestExistingAncestor(inputs.root);
+  const statfsSync2 = fs.statfsSync;
+  if (typeof statfsSync2 !== "function") {
+    return [
+      {
+        id: "disk-space",
+        severity: "info",
+        path: probe,
+        message: "free-disk check unavailable on this Node runtime",
+        remedy: ""
+      }
+    ];
+  }
+  try {
+    const st = statfsSync2(probe);
+    const free = st.bavail * st.bsize;
+    if (free < floor) {
+      return [
+        {
+          id: "disk-space",
+          severity: "blocking",
+          path: probe,
+          message: `free disk ${free} B is below the ${floor} B floor`,
+          remedy: "free disk space on the target volume, then re-run"
+        }
+      ];
+    }
+  } catch {
+    return [
+      {
+        id: "disk-space",
+        severity: "info",
+        path: probe,
+        message: "free-disk probe failed (statfs error) \u2014 check skipped",
+        remedy: ""
+      }
+    ];
+  }
+  return [];
+}
+function checkConflicts(inputs) {
+  const plan = buildInstallPlan(inputs);
+  const conflicts = computeConflicts(plan);
+  return conflicts.map((c) => ({
+    id: "conflicts",
+    severity: "warning",
+    path: c.path,
+    message: `existing file conflicts with planned ${c.kind} content`,
+    remedy: "resolve interactively, or pass --force to overwrite"
+  }));
+}
+function checkHostDetection(inputs) {
+  const presence = detectToolPresence(inputs.root);
+  const detected = Object.entries(presence).filter(([, v]) => v === true).map(([k]) => k);
+  if (detected.length === 0) {
+    return [
+      {
+        id: "host-detection",
+        severity: "info",
+        path: inputs.root,
+        message: "no AI-tool directories detected at the target root",
+        remedy: "expected for a first global install; verify the target path is right"
+      }
+    ];
+  }
+  return [
+    {
+      id: "host-detection",
+      severity: "info",
+      path: inputs.root,
+      message: `detected AI-tool surfaces: ${detected.join(", ")}`,
+      remedy: ""
+    }
+  ];
+}
+function runPreflight(inputs, opts = {}) {
+  return [
+    ...checkPermissions(inputs),
+    ...checkDiskSpace(inputs, opts),
+    ...checkConflicts(inputs),
+    ...checkHostDetection(inputs)
+  ];
+}
+function hasBlockingFinding(findings) {
+  return findings.some((f) => f.severity === "blocking");
+}
+
+export {
+  runPreflight,
+  hasBlockingFinding
+};