@event4u/agent-config 9.10.0 → 9.12.0

package/dist/cli-delegate/cmd_update.js

@@ -0,0 +1,425 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  DEFAULT_STATE_PATH,
+  _is_newer,
+  fetch_latest_from_npm
+} from "./chunk-7HQ52DHU.js";
+import {
+  lockfile_path,
+  lockfile_write_path,
+  read_lockfile,
+  write_lockfile
+} from "./chunk-GRRPEPRN.js";
+import {
+  DEFAULT_PROJECT_FILE,
+  LOCAL_PROJECT_FILE,
+  LOCAL_PROJECT_SUBDIR,
+  find_project_root,
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_update.ts
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var PACKAGE_NAME = "@event4u/agent-config";
+var PIN_KEY = "agent_config_version";
+var REGISTRY_VERSION_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/{version}`;
+var PIN_LINE_RE = /^(\s*agent_config_version\s*:\s*)(.*)$/m;
+var _HERE = fileURLToPath(import.meta.url);
+var _HERE_DIR = path.dirname(_HERE);
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`ArgparseExit(${code})`);
+    this.name = "ArgparseExit";
+    this.code = code;
+  }
+};
+var _stdout = { write: (t) => process.stdout.write(t) };
+var _stderr = { write: (t) => process.stderr.write(t) };
+function _print(out, line = "") {
+  out.write(line + "\n");
+}
+function _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _splitlinesKeepends(text) {
+  const out = [];
+  let buf = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    buf += ch;
+    if (ch === "\n") {
+      out.push(buf);
+      buf = "";
+    }
+  }
+  if (buf) {
+    out.push(buf);
+  }
+  return out;
+}
+function _canonical_settings_path(project_root) {
+  return path.join(project_root, ...LOCAL_PROJECT_SUBDIR, DEFAULT_PROJECT_FILE);
+}
+function _local_settings_path(project_root) {
+  return path.join(project_root, ...LOCAL_PROJECT_SUBDIR, LOCAL_PROJECT_FILE);
+}
+function _resolve(p) {
+  return path.resolve(p);
+}
+function _resolve_cascade_paths(cwd, project_path) {
+  if (cwd === null) {
+    const legacy = project_path ? project_path : DEFAULT_PROJECT_FILE;
+    const parent = path.dirname(legacy);
+    return [legacy, _canonical_settings_path(parent), _local_settings_path(parent)];
+  }
+  const root = find_project_root(cwd);
+  if (root === null) {
+    const legacy = project_path ? project_path : DEFAULT_PROJECT_FILE;
+    const parent = path.dirname(legacy);
+    return [legacy, _canonical_settings_path(parent), _local_settings_path(parent)];
+  }
+  const cwd_resolved = _resolve(cwd);
+  const chain = [];
+  let cursor = cwd_resolved;
+  for (; ; ) {
+    chain.push(cursor);
+    if (cursor === root) {
+      break;
+    }
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      break;
+    }
+    cursor = parent;
+  }
+  chain.reverse();
+  const out = [];
+  for (const dir of chain) {
+    out.push(path.join(dir, DEFAULT_PROJECT_FILE));
+    out.push(_canonical_settings_path(dir));
+    out.push(_local_settings_path(dir));
+  }
+  return out;
+}
+function _read_state(state_path) {
+  try {
+    const raw = fs.readFileSync(state_path, "utf-8");
+    const data = JSON.parse(raw);
+    if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+      return data;
+    }
+  } catch {
+  }
+  return {};
+}
+function _write_state(state_path, payload) {
+  const parent = path.dirname(state_path);
+  fs.mkdirSync(parent, { recursive: true });
+  const tmp = path.join(parent, `.update-check-${randomBytes(8).toString("hex")}`);
+  try {
+    const sorted = {};
+    for (const key of Object.keys(payload).sort()) {
+      sorted[key] = payload[key];
+    }
+    fs.writeFileSync(tmp, JSON.stringify(sorted, null, 2), { encoding: "utf-8", mode: 384 });
+    fs.chmodSync(tmp, 384);
+    fs.renameSync(tmp, state_path);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function _normalize(version) {
+  return version.trim().replace(/^v+/, "");
+}
+async function _registry_has_version(version, timeout = 1) {
+  const url = REGISTRY_VERSION_URL.replace("{version}", _normalize(version));
+  try {
+    const resp = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(timeout * 1e3)
+    });
+    return resp.status === 200;
+  } catch {
+    return false;
+  }
+}
+function _find_pin_file(cwd) {
+  const cascade = _resolve_cascade_paths(cwd, null);
+  for (const p of [...cascade].reverse()) {
+    if (_isFile(p) && _read_pin_line(p) !== null) {
+      return p;
+    }
+  }
+  if (cascade.length) {
+    return cascade[0];
+  }
+  return path.join(cwd, DEFAULT_PROJECT_FILE);
+}
+function _read_pin_line(p) {
+  let text;
+  try {
+    text = fs.readFileSync(p, { encoding: "utf-8" });
+  } catch {
+    return null;
+  }
+  const lines = _splitlinesKeepends(text);
+  for (let idx = 0; idx < lines.length; idx++) {
+    if (PIN_LINE_RE.test(lines[idx])) {
+      return idx;
+    }
+  }
+  return null;
+}
+function _write_pin(p, new_version) {
+  const target = `agent_config_version: "${_normalize(new_version)}"
+`;
+  let lines;
+  try {
+    lines = _splitlinesKeepends(fs.readFileSync(p, { encoding: "utf-8" }));
+  } catch (err) {
+    const e = err;
+    if (e && e.code === "ENOENT") {
+      fs.mkdirSync(path.dirname(p), { recursive: true });
+      fs.writeFileSync(p, target, { encoding: "utf-8" });
+      return true;
+    }
+    throw err;
+  }
+  for (let idx = 0; idx < lines.length; idx++) {
+    if (PIN_LINE_RE.test(lines[idx])) {
+      if (lines[idx] === target) {
+        return false;
+      }
+      lines[idx] = target;
+      fs.writeFileSync(p, lines.join(""), { encoding: "utf-8" });
+      return true;
+    }
+  }
+  if (lines.length && !lines[lines.length - 1].endsWith("\n")) {
+    lines.push("\n");
+  }
+  lines.push(target);
+  fs.writeFileSync(p, lines.join(""), { encoding: "utf-8" });
+  return true;
+}
+function _warm_npx_cache(version, runner) {
+  const run = runner ?? ((argv) => {
+    spawnSync(argv[0], argv.slice(1), {
+      stdio: "ignore",
+      timeout: 120 * 1e3
+    });
+  });
+  try {
+    run(["npx", "--yes", `${PACKAGE_NAME}@${_normalize(version)}`, "--version"]);
+  } catch {
+  }
+}
+function _refresh_state(installed, latest, state_path) {
+  const state = _read_state(state_path);
+  const payload = {
+    last_check_utc: _isoNowZ(),
+    last_seen_version: latest,
+    installed_version: installed
+  };
+  Object.assign(state, payload);
+  try {
+    _write_state(state_path, state);
+  } catch {
+  }
+}
+function _isoNowZ() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${p(d.getUTCFullYear(), 4)}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}T${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}Z`;
+}
+function _parse(argv) {
+  const prog = "agent-config update";
+  const usage = "usage: agent-config update [-h] [--check] [--to VERSION] [--offline]\n";
+  const emitError = (msg) => {
+    _stderr.write(usage);
+    _stderr.write(`${prog}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  const args = { check: false, to: null, offline: false };
+  let i = 0;
+  while (i < argv.length) {
+    const tok = argv[i];
+    const flag = tok.includes("=") ? tok.slice(0, tok.indexOf("=")) : tok;
+    if (flag === "-h" || flag === "--help") {
+      _stdout.write(usage);
+      throw new ArgparseExit(0);
+    } else if (flag === "--check") {
+      args.check = true;
+      i += 1;
+    } else if (flag === "--offline") {
+      args.offline = true;
+      i += 1;
+    } else if (flag === "--to") {
+      const eq = tok.indexOf("=");
+      if (eq >= 0) {
+        args.to = tok.slice(eq + 1);
+        i += 1;
+      } else {
+        const val = argv[i + 1];
+        if (val === void 0) {
+          emitError("argument --to: expected one argument");
+        }
+        args.to = val;
+        i += 2;
+      }
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  return args;
+}
+async function main(argv = null, options = {}) {
+  const out = options.out ?? _stdout;
+  const err = options.err ?? _stderr;
+  const fetcher = options.fetcher ?? (() => fetch_latest_from_npm());
+  const version_checker = options.version_checker ?? _registry_has_version;
+  const cache_warmer = options.cache_warmer ?? ((v) => _warm_npx_cache(v));
+  const args = _parse(argv ?? process.argv.slice(2));
+  const [cwd] = resolve_project_root(null, { cwd: options.cwd ?? null });
+  const installed_version = options.installed_version || _detect_installed_version();
+  const state_path = options.state_path || DEFAULT_STATE_PATH;
+  const offline = args.offline || process.env["AGENT_CONFIG_OFFLINE"] === "1";
+  if (offline && !args.to) {
+    _print(
+      err,
+      "\u274C  agent-config: --offline requires --to <version> (no registry, no 'latest' to fetch)."
+    );
+    return 1;
+  }
+  let latest;
+  if (args.to) {
+    const target = _normalize(args.to);
+    if (offline) {
+      latest = target;
+    } else if (!await version_checker(target)) {
+      _print(err, `\u274C  agent-config: version ${target} not found on the npm registry.`);
+      return 1;
+    } else {
+      latest = target;
+    }
+  } else {
+    const fetched = await fetcher();
+    if (!fetched) {
+      _print(
+        err,
+        "\u274C  agent-config: failed to fetch latest version from the npm registry."
+      );
+      return 1;
+    }
+    latest = _normalize(fetched);
+  }
+  if (args.check) {
+    if (_is_newer(latest, installed_version)) {
+      _print(out, `agent-config ${latest} available (you have ${installed_version}).`);
+      _print(out, `Update: npx ${PACKAGE_NAME} update`);
+    } else {
+      _print(out, `agent-config is up to date (${installed_version}).`);
+    }
+    return 0;
+  }
+  const pin_file = _find_pin_file(cwd);
+  const changed = _write_pin(pin_file, latest);
+  const rel = _relativeToOr(pin_file, cwd);
+  if (changed) {
+    _print(out, `\u2705  Pinned ${PACKAGE_NAME} to ${latest} in ${rel}.`);
+  } else {
+    _print(out, `\u2139\uFE0F  ${rel} already pins to ${latest}.`);
+  }
+  if (!offline) {
+    cache_warmer(latest);
+  }
+  _refresh_state(latest, latest, state_path);
+  _refresh_global_lockfile(latest, out);
+  return 0;
+}
+function _relativeToOr(target, base) {
+  const rel = path.relative(base, target);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    return target;
+  }
+  return rel;
+}
+function _refresh_global_lockfile(version, out) {
+  const read_path = lockfile_path();
+  const write_path = lockfile_write_path();
+  const existing = read_lockfile(read_path);
+  if (existing === null) {
+    return;
+  }
+  const recorded = existing["agent_config_version"];
+  const tools = [...existing.tools ?? []];
+  if (recorded === version && read_path === write_path) {
+    _print(out, `\u2139\uFE0F  ${write_path} already records ${version}.`);
+    return;
+  }
+  write_lockfile(version, tools, { path: write_path });
+  _print(out, `\u2705  Refreshed global lockfile at ${write_path}.`);
+}
+function _detect_installed_version() {
+  const pkg_json = path.join(resolvePackageRoot(import.meta.url), "package.json");
+  try {
+    const data = JSON.parse(fs.readFileSync(pkg_json, { encoding: "utf-8" }));
+    const version = data["version"];
+    if (typeof version === "string" && version.trim()) {
+      return version.trim();
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+  }).catch((exc) => {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  });
+}
+export {
+  PIN_KEY,
+  main
+};