@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-SMGFN3Z4.js

@@ -0,0 +1,503 @@
+import {
+  contextConfigPath,
+  intervalElapsed,
+  loadContextConfig
+} from "./chunk-NQ7IQ5XT.js";
+import {
+  diffAgainstRegistry,
+  summarizeDiff
+} from "./chunk-2RDRMGD3.js";
+import {
+  DEFAULT_REGISTRY_URL,
+  assertSafeRegistrySource,
+  loadAgentKitManifest,
+  resolveRegistryRoot
+} from "./chunk-AW74INUW.js";
+import {
+  KIT_PACKAGE_SPEC,
+  KIT_VERSION
+} from "./chunk-7HDQEK6T.js";
+import {
+  readJson,
+  writeJson
+} from "./chunk-77V75A7O.js";
+
+// src/lifecycle/check-updates.ts
+import { execFile } from "child_process";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var SEMVER_CORE = /^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/i;
+var FACTORY_URL_MARKERS = ["agent-kit-dev"];
+var FACTORY_REFS = /* @__PURE__ */ new Set(["staging", "homologacao", "develop", "dev"]);
+var DEFAULT_UPDATE_CHECK = {
+  enabled: false,
+  intervalDays: 7,
+  lastCheckedAt: null
+};
+function gitEnv() {
+  return { ...process.env, GIT_ALLOW_PROTOCOL: "https" };
+}
+function compareSemver(a, b) {
+  const pa = parseSemverParts(a);
+  const pb = parseSemverParts(b);
+  if (!pa || !pb) {
+    throw new Error(`Invalid semver for compare: "${a}" vs "${b}"`);
+  }
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function parseSemverParts(version) {
+  const m = SEMVER_CORE.exec(version.trim());
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+function normalizeSemver(version) {
+  const parts = parseSemverParts(version);
+  if (!parts) return null;
+  return `${parts[0]}.${parts[1]}.${parts[2]}`;
+}
+function isFactoryOrDevRegistry(url, ref) {
+  if (url) {
+    const lower = url.toLowerCase();
+    if (FACTORY_URL_MARKERS.some((m) => lower.includes(m))) return true;
+  }
+  if (ref && FACTORY_REFS.has(ref.toLowerCase())) return true;
+  return false;
+}
+function pickLatestSemverTag(lsRemoteStdout) {
+  let best = null;
+  for (const line of lsRemoteStdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const ref = trimmed.split(/\s+/)[1];
+    if (!ref?.startsWith("refs/tags/")) continue;
+    if (ref.endsWith("^{}")) continue;
+    const tag = ref.slice("refs/tags/".length);
+    const norm = normalizeSemver(tag);
+    if (!norm) continue;
+    if (!best || compareSemver(norm, best) > 0) best = norm;
+  }
+  return best;
+}
+async function fetchLatestPublicVersion(registryUrl = DEFAULT_REGISTRY_URL) {
+  assertSafeRegistrySource(registryUrl, "main");
+  const { stdout } = await execFileAsync("git", ["ls-remote", "--tags", "--", registryUrl], {
+    env: gitEnv(),
+    timeout: 2e4
+  });
+  return pickLatestSemverTag(stdout);
+}
+var NPM_CLI_LATEST_URL = "https://registry.npmjs.org/@dadado%2Fagent-kit-cli/latest";
+async function fetchLatestNpmDistTag() {
+  try {
+    const res = await fetch(NPM_CLI_LATEST_URL, {
+      method: "GET",
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (!body || typeof body !== "object" || Array.isArray(body)) return null;
+    const version = body.version;
+    return typeof version === "string" ? normalizeSemver(version) : null;
+  } catch {
+    return null;
+  }
+}
+function readUpdateCheckPrefs(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return { ...DEFAULT_UPDATE_CHECK };
+  }
+  const raw = config.updateCheck;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ...DEFAULT_UPDATE_CHECK };
+  }
+  const uc = raw;
+  const intervalDays = typeof uc.intervalDays === "number" && Number.isInteger(uc.intervalDays) && uc.intervalDays >= 1 ? uc.intervalDays : DEFAULT_UPDATE_CHECK.intervalDays;
+  return {
+    enabled: uc.enabled === true,
+    intervalDays,
+    lastCheckedAt: typeof uc.lastCheckedAt === "string" ? uc.lastCheckedAt : null
+  };
+}
+async function stampLastCheckedAt(cwd) {
+  const existing = await loadContextConfig(cwd) ?? {};
+  const prev = existing.updateCheck && typeof existing.updateCheck === "object" ? { ...existing.updateCheck } : {};
+  existing.updateCheck = {
+    ...DEFAULT_UPDATE_CHECK,
+    ...prev,
+    lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeJson(contextConfigPath(cwd), existing);
+}
+async function readLocalKitVersion(registryRoot) {
+  for (const rel of ["packages/cli/package.json", "package.json"]) {
+    const data = await readJson(path.join(registryRoot, rel));
+    if (data && typeof data.version === "string" && data.version.length > 0) {
+      return data.version;
+    }
+  }
+  return null;
+}
+async function checkAgainstLocalRegistry(cwd, manifest, options) {
+  const registryPath = options.registryPath;
+  if (!registryPath) {
+    throw new Error("checkAgainstLocalRegistry requires registryPath");
+  }
+  let resolved;
+  try {
+    resolved = await resolveRegistryRoot({ cwd, registryPath });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      status: "error",
+      installedVersion: manifest.version,
+      latestVersion: null,
+      registryUrl: path.resolve(registryPath),
+      registryRef: "local",
+      applyRecommended: false,
+      message: `Failed to resolve --registry: ${msg}`
+    };
+  }
+  const registryUrl = resolved.root;
+  const registryRef = "local";
+  try {
+    let latest;
+    if (options.latestVersion !== void 0) {
+      latest = options.latestVersion;
+    } else {
+      const raw = await readLocalKitVersion(resolved.root);
+      latest = raw ? normalizeSemver(raw) : null;
+    }
+    const summary = summarizeDiff(await diffAgainstRegistry(resolved.root, cwd, manifest));
+    const hasFileDrift = summary.drift > 0 || summary["missing-local"] > 0;
+    const installed = normalizeSemver(manifest.version);
+    if (!installed) {
+      return {
+        status: "error",
+        installedVersion: manifest.version,
+        latestVersion: latest,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: `Installed version "${manifest.version}" is not valid semver.`
+      };
+    }
+    if (!latest) {
+      return {
+        status: "error",
+        installedVersion: installed,
+        latestVersion: null,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: "No semver found in the local --registry checkout (packages/cli/package.json or package.json)."
+      };
+    }
+    const cmp = compareSemver(installed, latest);
+    if (hasFileDrift) {
+      return {
+        status: "update-available",
+        installedVersion: installed,
+        latestVersion: latest,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: `Local registry has drift vs this install (drift=${summary.drift}, missing-local=${summary["missing-local"]}; source v${latest}). Run /update --registry <path> (Ask confirm) to apply; never silent.`
+      };
+    }
+    if (cmp === 0) {
+      return {
+        status: "up-to-date",
+        installedVersion: installed,
+        latestVersion: latest,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: `Installed v${installed} matches local registry v${latest}.`
+      };
+    }
+    if (cmp < 0) {
+      return {
+        status: "update-available",
+        installedVersion: installed,
+        latestVersion: latest,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: `Update available from local registry: v${installed} \u2192 v${latest}. Run /update --registry <path> (Ask confirm) to apply; never silent.`
+      };
+    }
+    return {
+      status: "ahead-of-public",
+      installedVersion: installed,
+      latestVersion: latest,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Installed v${installed} is ahead of local registry v${latest}.`
+    };
+  } finally {
+    await resolved.unlock?.();
+  }
+}
+async function checkForUpdates(cwd, options = {}) {
+  const manifest = await loadAgentKitManifest(cwd);
+  if (!manifest) {
+    return {
+      status: "skipped-no-manifest",
+      installedVersion: null,
+      latestVersion: null,
+      registryUrl: null,
+      registryRef: null,
+      applyRecommended: false,
+      message: "No .cursor/agent-kit.json \u2014 run agent-kit install first."
+    };
+  }
+  if (options.registryPath) {
+    return checkAgainstLocalRegistry(cwd, manifest, options);
+  }
+  const registryUrl = options.publicRegistryUrl ?? manifest.registry?.url ?? null;
+  const registryRef = manifest.registry?.ref ?? null;
+  if (isFactoryOrDevRegistry(registryUrl, registryRef)) {
+    return {
+      status: "skipped-factory",
+      installedVersion: manifest.version,
+      latestVersion: null,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: "Factory/dev registry detected \u2014 skipping public update check. Use /update only with explicit consumer intent."
+    };
+  }
+  if (options.respectPrefs) {
+    const config = await loadContextConfig(cwd);
+    const prefs = readUpdateCheckPrefs(config);
+    if (!prefs.enabled) {
+      return {
+        status: "skipped-disabled",
+        installedVersion: manifest.version,
+        latestVersion: null,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: "updateCheck.enabled is false (opt-in). Set true in .cursor/context/config.json to nudge."
+      };
+    }
+    if (!intervalElapsed(prefs.lastCheckedAt, prefs.intervalDays)) {
+      return {
+        status: "skipped-interval",
+        installedVersion: manifest.version,
+        latestVersion: null,
+        registryUrl,
+        registryRef,
+        applyRecommended: false,
+        message: `Within updateCheck.intervalDays (${prefs.intervalDays}); last check ${prefs.lastCheckedAt}.`
+      };
+    }
+  }
+  let latest;
+  try {
+    latest = options.latestVersion !== void 0 ? options.latestVersion : await fetchLatestPublicVersion(options.publicRegistryUrl ?? DEFAULT_REGISTRY_URL);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      status: "error",
+      installedVersion: manifest.version,
+      latestVersion: null,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Failed to fetch public tags: ${msg}`
+    };
+  }
+  if (options.stamp) {
+    try {
+      await stampLastCheckedAt(cwd);
+    } catch {
+    }
+  }
+  const installed = normalizeSemver(manifest.version);
+  if (!installed) {
+    return {
+      status: "error",
+      installedVersion: manifest.version,
+      latestVersion: latest,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Installed version "${manifest.version}" is not valid semver.`
+    };
+  }
+  if (!latest) {
+    return {
+      status: "error",
+      installedVersion: installed,
+      latestVersion: null,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: "No semver tags found on the public registry."
+    };
+  }
+  const cmp = compareSemver(installed, latest);
+  if (cmp === 0) {
+    return {
+      status: "up-to-date",
+      installedVersion: installed,
+      latestVersion: latest,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Installed v${installed} matches latest public v${latest}.`
+    };
+  }
+  if (cmp < 0) {
+    const cliBehind = compareSemver(KIT_VERSION, latest) < 0;
+    const remedy = cliBehind ? `This CLI is v${KIT_VERSION}, older than v${latest} \u2014 upgrade the binary first (\`npm i -g ${KIT_PACKAGE_SPEC}@${latest}\`), then run /update (Ask confirm); /update alone would re-apply v${KIT_VERSION}.` : "Run /update (Ask confirm) to apply; never silent.";
+    return {
+      status: "update-available",
+      installedVersion: installed,
+      latestVersion: latest,
+      registryUrl,
+      registryRef,
+      applyRecommended: false,
+      message: `Update available: v${installed} \u2192 v${latest}. ${remedy}`
+    };
+  }
+  return {
+    status: "ahead-of-public",
+    installedVersion: installed,
+    latestVersion: latest,
+    registryUrl,
+    registryRef,
+    applyRecommended: false,
+    message: `Installed v${installed} is ahead of latest public v${latest} (dev/local build).`
+  };
+}
+function runningCliBehindMessage(running, latest) {
+  return `Running CLI v${running} is behind npm latest v${latest}. Re-run with npx ${KIT_PACKAGE_SPEC}@latest or npm i -g ${KIT_PACKAGE_SPEC}@${latest}.`;
+}
+async function checkRunningCliVsNpmLatest(cwd, options = {}) {
+  const running = normalizeSemver(KIT_VERSION) ?? KIT_VERSION;
+  if (options.respectPrefs) {
+    const config = await loadContextConfig(cwd);
+    const prefs = readUpdateCheckPrefs(config);
+    if (!prefs.enabled) {
+      return {
+        status: "skipped-disabled",
+        runningVersion: running,
+        latestVersion: null,
+        message: "updateCheck.enabled is false (opt-in). Set true in .cursor/context/config.json to nudge."
+      };
+    }
+    if (!intervalElapsed(prefs.lastCheckedAt, prefs.intervalDays)) {
+      return {
+        status: "skipped-interval",
+        runningVersion: running,
+        latestVersion: null,
+        message: `Within updateCheck.intervalDays (${prefs.intervalDays}); last check ${prefs.lastCheckedAt}.`
+      };
+    }
+  }
+  let latest;
+  try {
+    if (options.latestVersion !== void 0) {
+      latest = options.latestVersion;
+    } else if (options.fetchLatest) {
+      latest = await options.fetchLatest();
+    } else {
+      latest = await fetchLatestNpmDistTag();
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      status: "error",
+      runningVersion: running,
+      latestVersion: null,
+      message: `Failed to fetch npm latest: ${msg}`
+    };
+  }
+  if (options.stamp) {
+    try {
+      await stampLastCheckedAt(cwd);
+    } catch {
+    }
+  }
+  if (!latest) {
+    return {
+      status: "error",
+      runningVersion: running,
+      latestVersion: null,
+      message: "No semver on npm dist-tags.latest for @dadado/agent-kit-cli."
+    };
+  }
+  let cmp;
+  try {
+    cmp = compareSemver(running, latest);
+  } catch {
+    return {
+      status: "error",
+      runningVersion: running,
+      latestVersion: latest,
+      message: `Invalid semver for compare: "${running}" vs "${latest}"`
+    };
+  }
+  if (cmp === 0) {
+    return {
+      status: "up-to-date",
+      runningVersion: running,
+      latestVersion: latest,
+      message: `Running CLI v${running} matches npm latest v${latest}.`
+    };
+  }
+  if (cmp < 0) {
+    return {
+      status: "behind",
+      runningVersion: running,
+      latestVersion: latest,
+      message: runningCliBehindMessage(running, latest)
+    };
+  }
+  return {
+    status: "ahead",
+    runningVersion: running,
+    latestVersion: latest,
+    message: `Running CLI v${running} is ahead of npm latest v${latest} (dev/local build).`
+  };
+}
+async function warnIfRunningCliBehindNpm(cwd, options = {}) {
+  try {
+    const result = await checkRunningCliVsNpmLatest(cwd, {
+      respectPrefs: options.respectPrefs ?? true,
+      stamp: options.stamp ?? true,
+      latestVersion: options.latestVersion,
+      fetchLatest: options.fetchLatest
+    });
+    if (result.status === "behind") {
+      (options.warn ?? ((message) => console.warn(message)))(result.message);
+    }
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      status: "error",
+      runningVersion: normalizeSemver(KIT_VERSION) ?? KIT_VERSION,
+      latestVersion: null,
+      message: msg
+    };
+  }
+}
+
+export {
+  compareSemver,
+  normalizeSemver,
+  stampLastCheckedAt,
+  readLocalKitVersion,
+  checkForUpdates,
+  warnIfRunningCliBehindNpm
+};