cachelint 0.1.0

package/dist/chunk-DYQPXD3G.js

@@ -0,0 +1,92 @@
+// src/lockfile/diff.ts
+function isRegression(d) {
+  return d.policyChanges.length > 0 || d.addedBundles.length > 0 || d.removedBundles.length > 0 || d.changedBundles.length > 0;
+}
+function diffLockfiles(committed, current) {
+  const policyChanges = [];
+  if (committed.normalizationPolicyVersion !== current.normalizationPolicyVersion) {
+    policyChanges.push({
+      field: "normalizationPolicyVersion",
+      committed: committed.normalizationPolicyVersion,
+      current: current.normalizationPolicyVersion
+    });
+  }
+  if (committed.ruleTableVersion !== current.ruleTableVersion) {
+    policyChanges.push({
+      field: "ruleTableVersion",
+      committed: committed.ruleTableVersion,
+      current: current.ruleTableVersion
+    });
+  }
+  const byName = (lf) => new Map(lf.bundles.map((b) => [b.name, b]));
+  const committedByName = byName(committed);
+  const currentByName = byName(current);
+  const addedBundles = [...currentByName.keys()].filter((n) => !committedByName.has(n)).sort(cmp);
+  const removedBundles = [...committedByName.keys()].filter((n) => !currentByName.has(n)).sort(cmp);
+  const changedBundles = [];
+  for (const name of [...committedByName.keys()].filter((n) => currentByName.has(n)).sort(cmp)) {
+    const c = committedByName.get(name);
+    const n = currentByName.get(name);
+    if (c.stablePrefixHash === n.stablePrefixHash && sameFiles(c.files, n.files)) continue;
+    changedBundles.push({
+      name,
+      committedHash: c.stablePrefixHash,
+      currentHash: n.stablePrefixHash,
+      fileChanges: fileChanges(c.files, n.files)
+    });
+  }
+  return { policyChanges, addedBundles, removedBundles, changedBundles };
+}
+function sameFiles(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].path !== b[i].path || a[i].sha256 !== b[i].sha256) return false;
+  }
+  return true;
+}
+function fileChanges(a, b) {
+  const am = new Map(a.map((f) => [f.path, f.sha256]));
+  const bm = new Map(b.map((f) => [f.path, f.sha256]));
+  const paths = [.../* @__PURE__ */ new Set([...am.keys(), ...bm.keys()])].sort(cmp);
+  const out = [];
+  for (const p of paths) {
+    const committed = am.get(p) ?? null;
+    const current = bm.get(p) ?? null;
+    if (committed !== current) out.push({ path: p, committed, current });
+  }
+  return out;
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function renderDiffHuman(d) {
+  const lines = [];
+  for (const pc of d.policyChanges) {
+    lines.push(
+      `policy changed: ${pc.field} ${pc.committed} \u2192 ${pc.current} \u2014 this is a deliberate cachelint upgrade; re-run \`cachelint hash\` and commit cachelint.lock.`
+    );
+  }
+  for (const name of d.addedBundles) lines.push(`+ bundle "${name}" is new (not in cachelint.lock)`);
+  for (const name of d.removedBundles) lines.push(`- bundle "${name}" is in cachelint.lock but no longer produced`);
+  for (const cb of d.changedBundles) {
+    lines.push(`~ bundle "${cb.name}" stablePrefixHash moved:`);
+    lines.push(`    was: ${cb.committedHash}`);
+    lines.push(`    now: ${cb.currentHash}`);
+    for (const fc of cb.fileChanges) {
+      const was = fc.committed ? fc.committed.slice(0, 12) : "(absent)";
+      const now = fc.current ? fc.current.slice(0, 12) : "(absent)";
+      lines.push(`    ${fc.path}: ${was} \u2192 ${now}`);
+    }
+  }
+  if (lines.length > 0) {
+    lines.push("");
+    lines.push("If this change is intentional: run `cachelint hash \u2026` and commit the updated cachelint.lock.");
+  }
+  return lines.join("\n");
+}
+
+export {
+  isRegression,
+  diffLockfiles,
+  renderDiffHuman
+};

package/dist/chunk-GXASKZ4Z.js

@@ -0,0 +1,182 @@
+import {
+  readStoredLicense
+} from "./chunk-4LB5LF2P.js";
+import {
+  LicenseError
+} from "./chunk-XKRPGMZT.js";
+
+// src/license/verify.ts
+import { verify as cryptoVerify } from "crypto";
+
+// src/license/publicKey.ts
+import { createPublicKey } from "crypto";
+var TRUSTED_KEYS = [
+  {
+    kid: 1,
+    spkiPem: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAudzwHFefdjkvu9doI3XtzSjsdHUteeUUWCWECsQ8SIM=\n-----END PUBLIC KEY-----\n"
+  }
+];
+var REVOKED_NONCES = /* @__PURE__ */ new Set([
+  // (none yet)
+]);
+function testKeyOverrideAllowed() {
+  return process.env["VITEST"] !== void 0 || process.env["NODE_ENV"] === "test";
+}
+function trustedKeys() {
+  const out = /* @__PURE__ */ new Map();
+  if (testKeyOverrideAllowed()) {
+    const override = process.env["CACHELINT_PUBLIC_KEY"];
+    if (override !== void 0 && override.trim() !== "") {
+      out.set(1, parsePublicKey(override.trim()));
+      return out;
+    }
+  }
+  for (const { kid, spkiPem } of TRUSTED_KEYS) out.set(kid, parsePublicKey(spkiPem));
+  return out;
+}
+function parsePublicKey(material) {
+  try {
+    if (material.includes("BEGIN ")) {
+      return createPublicKey({ key: material, format: "pem" });
+    }
+    return createPublicKey({ key: Buffer.from(material, "base64url"), format: "der", type: "spki" });
+  } catch {
+    throw new LicenseError({
+      code: "PRO_BAD_PUBLIC_KEY",
+      message: "could not parse a trusted public key (check CACHELINT_PUBLIC_KEY if you set it)"
+    });
+  }
+}
+
+// src/license/verify.ts
+var GRACE_PERIOD_DAYS = 14;
+var GRACE_MS = GRACE_PERIOD_DAYS * 24 * 60 * 60 * 1e3;
+var KNOWN_FEATURES = /* @__PURE__ */ new Set(["sarif", "exact", "pack"]);
+function verifyLicenseToken(token, now = Date.now()) {
+  const bad = (msg, code = "PRO_INVALID_LICENSE") => {
+    throw new LicenseError({ code, message: msg, hint: "Re-copy the key from your purchase email, or contact support." });
+  };
+  if (typeof token !== "string" || token.length < 16 || !token.includes(".")) bad("license key is malformed");
+  const dot = token.indexOf(".");
+  if (token.indexOf(".", dot + 1) !== -1) bad("license key is malformed (more than one '.')");
+  const signedPart = token.slice(0, dot);
+  const sigPart = token.slice(dot + 1);
+  if (signedPart === "" || sigPart === "") bad("license key is malformed (empty segment)");
+  let payloadBytes;
+  let sigBytes;
+  try {
+    payloadBytes = Buffer.from(signedPart, "base64url");
+    sigBytes = Buffer.from(sigPart, "base64url");
+  } catch {
+    return bad("license key is not valid base64url");
+  }
+  if (sigBytes.length !== 64) bad("license signature has the wrong length");
+  let raw;
+  try {
+    raw = JSON.parse(payloadBytes.toString("utf8"));
+  } catch {
+    return bad("license payload is not valid JSON");
+  }
+  if (typeof raw !== "object" || raw === null) return bad("license payload is not an object");
+  const p = raw;
+  if (p["v"] !== 1) bad(`unsupported license payload version (${String(p["v"])})`);
+  if (typeof p["kid"] !== "number") bad("license payload missing 'kid'");
+  if (typeof p["sub"] !== "string" || p["sub"].length === 0) bad("license payload missing 'sub'");
+  if (p["plan"] !== "pro") bad(`license plan '${String(p["plan"])}' is not recognized`);
+  if (typeof p["iat"] !== "number" || typeof p["exp"] !== "number") bad("license payload missing iat/exp");
+  if (typeof p["nonce"] !== "string" || p["nonce"].length === 0) bad("license payload missing 'nonce'");
+  const features = Array.isArray(p["features"]) ? p["features"] : [];
+  const cleanFeatures = features.filter((f) => typeof f === "string" && KNOWN_FEATURES.has(f));
+  const kid = p["kid"];
+  const keys = trustedKeys();
+  const key = keys.get(kid);
+  if (key === void 0) bad(`license was signed with an unknown key id (kid=${kid})`, "PRO_UNKNOWN_KID");
+  let ok = false;
+  try {
+    ok = cryptoVerify(null, Buffer.from(signedPart, "utf8"), key, sigBytes);
+  } catch {
+    ok = false;
+  }
+  if (!ok) bad("license signature does not verify");
+  const nonce = p["nonce"];
+  if (REVOKED_NONCES.has(nonce)) bad("this license key has been revoked", "PRO_REVOKED");
+  const expMs = p["exp"] * 1e3;
+  let inGracePeriod = false;
+  let warning = null;
+  if (now > expMs) {
+    if (now <= expMs + GRACE_MS) {
+      inGracePeriod = true;
+      const daysLeft = Math.max(0, Math.ceil((expMs + GRACE_MS - now) / (24 * 60 * 60 * 1e3)));
+      warning = `license expired on ${new Date(expMs).toISOString().slice(0, 10)} \u2014 still honored for ${daysLeft} more day(s); renew to keep Pro features.`;
+    } else {
+      bad(`license expired on ${new Date(expMs).toISOString().slice(0, 10)} (past the ${GRACE_PERIOD_DAYS}-day grace window)`, "PRO_EXPIRED");
+    }
+  }
+  const payload = {
+    v: 1,
+    sub: p["sub"],
+    plan: "pro",
+    features: cleanFeatures,
+    iat: p["iat"],
+    exp: p["exp"],
+    nonce,
+    kid
+  };
+  return { payload, inGracePeriod, warning };
+}
+
+// src/license/gate.ts
+var PRO_UPGRADE_HINT = "Pro feature \u2014 see https://github.com/davioe/cachelint#pro, then run `cachelint activate <license-key>` (or set CACHELINT_LICENSE_KEY).";
+var cached;
+function loadActive() {
+  if (cached !== void 0) return cached.info;
+  let info = null;
+  try {
+    const stored = readStoredLicense();
+    if (stored !== null) {
+      const v = verifyLicenseToken(stored.token);
+      info = {
+        plan: "pro",
+        sub: v.payload.sub,
+        exp: v.payload.exp,
+        kid: v.payload.kid,
+        features: v.payload.features,
+        inGracePeriod: v.inGracePeriod,
+        source: stored.source
+      };
+    }
+  } catch {
+    info = null;
+  }
+  cached = { info };
+  return info;
+}
+function activeLicenseInfo() {
+  return loadActive();
+}
+function isPro(feature) {
+  const info = loadActive();
+  if (info === null) return false;
+  return feature === void 0 || info.features.includes(feature);
+}
+function requirePro(feature, whatHuman) {
+  if (isPro(feature)) return;
+  throw new LicenseError({
+    code: "PRO_REQUIRED",
+    message: `${whatHuman} requires a cachelint Pro license`,
+    hint: PRO_UPGRADE_HINT
+  });
+}
+function _resetLicenseCache() {
+  cached = void 0;
+}
+
+export {
+  GRACE_PERIOD_DAYS,
+  verifyLicenseToken,
+  PRO_UPGRADE_HINT,
+  activeLicenseInfo,
+  isPro,
+  requirePro,
+  _resetLicenseCache
+};

package/dist/chunk-JZU4PCTS.js

@@ -0,0 +1,80 @@
+import {
+  _resetLicenseCache,
+  activeLicenseInfo,
+  verifyLicenseToken
+} from "./chunk-GXASKZ4Z.js";
+import {
+  clearStoredLicense,
+  hasEnvLicense,
+  licenseFilePath,
+  writeStoredLicense
+} from "./chunk-4LB5LF2P.js";
+import {
+  LicenseError
+} from "./chunk-XKRPGMZT.js";
+
+// src/commands/license.ts
+function activate(token) {
+  const v = verifyLicenseToken(token);
+  const storedAt = writeStoredLicense(token.trim());
+  _resetLicenseCache();
+  const info = activeLicenseInfo();
+  if (info === null) {
+    throw new LicenseError({ code: "PRO_ACTIVATE_FAILED", message: "license verified but could not be re-read after storing" });
+  }
+  return { info, storedAt, warning: v.warning };
+}
+function licenseStatus() {
+  const info = activeLicenseInfo();
+  return { active: info !== null, info, filePath: licenseFilePath() };
+}
+function deactivate() {
+  const removed = clearStoredLicense();
+  _resetLicenseCache();
+  return { removed, envStillActive: hasEnvLicense(), filePath: licenseFilePath() };
+}
+function renderActivateHuman(r) {
+  const lines = [
+    `cachelint: Pro license activated \u2014 thanks!`,
+    `  buyer:    ${r.info.sub}`,
+    `  expires:  ${new Date(r.info.exp * 1e3).toISOString().slice(0, 10)}`,
+    `  features: ${r.info.features.length > 0 ? r.info.features.join(", ") : "(none listed)"}`,
+    `  stored:   ${r.storedAt}`
+  ];
+  if (r.warning) lines.push(`  note:     ${r.warning}`);
+  return lines.join("\n");
+}
+function renderLicenseStatusHuman(s) {
+  if (!s.active || s.info === null) {
+    return [
+      "cachelint: no Pro license active (running the free core).",
+      `  a license would be read from: ${s.filePath}  (or the CACHELINT_LICENSE_KEY env var)`,
+      "  buy + activate: https://github.com/davioe/cachelint#pro"
+    ].join("\n");
+  }
+  const i = s.info;
+  const lines = [
+    `cachelint: Pro license active.`,
+    `  buyer:    ${i.sub}`,
+    `  expires:  ${new Date(i.exp * 1e3).toISOString().slice(0, 10)}${i.inGracePeriod ? "  (in grace period \u2014 renew soon)" : ""}`,
+    `  features: ${i.features.length > 0 ? i.features.join(", ") : "(none listed)"}`,
+    `  kid:      ${i.kid}`,
+    `  source:   ${i.source}`
+  ];
+  return lines.join("\n");
+}
+function renderDeactivateHuman(r) {
+  const lines = [];
+  lines.push(r.removed ? `cachelint: removed the stored license (${r.filePath}).` : `cachelint: no stored license file to remove (${r.filePath}).`);
+  if (r.envStillActive) lines.push("  note: CACHELINT_LICENSE_KEY is still set in the environment \u2014 Pro stays active until you unset it.");
+  return lines.join("\n");
+}
+
+export {
+  activate,
+  licenseStatus,
+  deactivate,
+  renderActivateHuman,
+  renderLicenseStatusHuman,
+  renderDeactivateHuman
+};