@leejpsd/nextjs-cache-handler 0.3.4 → 0.4.1

package/dist/cli/index.js

@@ -0,0 +1,928 @@
+import path4 from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import fs from 'fs';
+import { promisify } from 'util';
+import { gzip, gunzip, brotliCompress, brotliDecompress, constants } from 'zlib';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var getFilename, getDirname, __dirname$1;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path4.dirname(getFilename());
+    __dirname$1 = /* @__PURE__ */ getDirname();
+  }
+});
+function nodeRequire(id) {
+  try {
+    return packageRequire(id);
+  } catch {
+    return cwdRequire(id);
+  }
+}
+var packageRequire, cwdRequire;
+var init_node_require = __esm({
+  "src/shared/node-require.ts"() {
+    init_esm_shims();
+    packageRequire = createRequire(import.meta.url);
+    cwdRequire = createRequire(
+      path4.join(process.cwd(), "__resolve-anchor__.js")
+    );
+  }
+});
+
+// src/shared/client/adapter-redis.ts
+var adapter_redis_exports = {};
+__export(adapter_redis_exports, {
+  adaptRedisV5: () => adaptRedisV5,
+  createRedisV5Client: () => createRedisV5Client
+});
+function adaptRedisV5(client) {
+  const like = client;
+  like.dispose = () => {
+    try {
+      client.destroy();
+    } catch {
+    }
+  };
+  like.subscribe = async (channel, onMessage, onDown) => {
+    const sub = client.duplicate();
+    const teardown = () => {
+      try {
+        sub.destroy();
+      } catch {
+      }
+    };
+    let down = false;
+    const markDown = () => {
+      if (down) return;
+      down = true;
+      teardown();
+      onDown?.();
+    };
+    sub.on("error", markDown);
+    sub.on("end", markDown);
+    try {
+      await sub.connect();
+      await sub.subscribe(channel, (message) => onMessage(message));
+    } catch (err) {
+      teardown();
+      throw err;
+    }
+    return async () => teardown();
+  };
+  return like;
+}
+function createRedisV5Client(config) {
+  const { createClient } = nodeRequire("redis");
+  const useTls = config.tls ?? config.url.startsWith("rediss://");
+  const opts = {
+    url: config.url,
+    socket: {
+      connectTimeout: config.connectTimeout ?? 1500,
+      reconnectStrategy: false,
+      ...useTls ? { tls: true } : {}
+    }
+  };
+  if (config.password !== void 0) opts.password = config.password;
+  return createClient(opts);
+}
+var init_adapter_redis = __esm({
+  "src/shared/client/adapter-redis.ts"() {
+    init_esm_shims();
+    init_node_require();
+  }
+});
+
+// src/shared/client/adapter-ioredis.ts
+var adapter_ioredis_exports = {};
+__export(adapter_ioredis_exports, {
+  adaptCluster: () => adaptCluster,
+  adaptIoredis: () => adaptIoredis,
+  createIoredisClient: () => createIoredisClient,
+  createIoredisCluster: () => createIoredisCluster,
+  createIoredisSentinel: () => createIoredisSentinel
+});
+function adapt(client, isClusterClient = false) {
+  return {
+    get isOpen() {
+      return client.status === "ready";
+    },
+    connect: async () => {
+      if (client.status !== "ready" && client.status !== "connecting") {
+        await client.connect();
+      }
+    },
+    get: (k) => client.get(k),
+    set: (k, v, opts) => {
+      const args = [];
+      if (opts?.EX !== void 0) args.push("EX", opts.EX);
+      if (opts?.NX) args.push("NX");
+      return client.set(k, v, ...args);
+    },
+    del: async (keys) => {
+      const arr = Array.isArray(keys) ? keys : [keys];
+      if (arr.length === 0) return 0;
+      return client.del(...arr);
+    },
+    sAdd: async (k, m) => {
+      const arr = Array.isArray(m) ? m : [m];
+      if (arr.length === 0) return 0;
+      return client.sadd(k, ...arr);
+    },
+    sMembers: (k) => client.smembers(k),
+    expire: async (k, s) => {
+      const r = await client.expire(k, s);
+      return r;
+    },
+    mGet: async (keys) => {
+      if (keys.length === 0) return [];
+      return client.mget(...keys);
+    },
+    eval: (script, opts) => client.eval(
+      script,
+      opts.keys.length,
+      ...opts.keys,
+      ...opts.arguments
+    ),
+    evalSha: (sha, opts) => client.evalsha(
+      sha,
+      opts.keys.length,
+      ...opts.keys,
+      ...opts.arguments
+    ),
+    scriptLoad: async (script) => await client.script("LOAD", script),
+    scanIterator: async function* ({ MATCH, COUNT }) {
+      if (isClusterClient) {
+        const cluster = client;
+        for (const node of cluster.nodes("master")) {
+          let cursor = "0";
+          do {
+            const [next, batch] = await node.scan(
+              cursor,
+              "MATCH",
+              MATCH,
+              "COUNT",
+              COUNT ?? 100
+            );
+            cursor = next;
+            if (batch.length > 0) yield batch;
+          } while (cursor !== "0");
+        }
+      } else {
+        const redis = client;
+        let cursor = "0";
+        do {
+          const [next, batch] = await redis.scan(
+            cursor,
+            "MATCH",
+            MATCH,
+            "COUNT",
+            COUNT ?? 100
+          );
+          cursor = next;
+          if (batch.length > 0) yield batch;
+        } while (cursor !== "0");
+      }
+    },
+    ping: () => client.ping(),
+    on: (event, listener) => {
+      client.on(event, listener);
+      return client;
+    },
+    publish: (channel, message) => client.publish(channel, message),
+    ...isClusterClient ? {} : {
+      subscribe: async (channel, onMessage, onDown) => {
+        const sub = client.duplicate();
+        let down = false;
+        const markDown = () => {
+          if (down) return;
+          down = true;
+          try {
+            sub.disconnect();
+          } catch {
+          }
+          onDown?.();
+        };
+        sub.on("error", markDown);
+        sub.on("end", markDown);
+        try {
+          if (sub.status !== "ready" && sub.status !== "connecting") {
+            await sub.connect();
+          }
+          await sub.subscribe(channel);
+        } catch (err) {
+          markDown();
+          throw err;
+        }
+        sub.on("message", (ch, message) => {
+          if (ch === channel) onMessage(message);
+        });
+        return async () => {
+          down = true;
+          sub.disconnect();
+        };
+      }
+    },
+    dispose: () => {
+      client.disconnect();
+    }
+  };
+}
+function adaptIoredis(client) {
+  return adapt(client, false);
+}
+function adaptCluster(cluster) {
+  return adapt(cluster, true);
+}
+function createIoredisClient(config) {
+  const IORedis = nodeRequire("ioredis");
+  const Ctor = IORedis.default ?? IORedis;
+  return new Ctor(config.url, {
+    password: config.password,
+    connectTimeout: config.connectTimeout ?? 1500,
+    tls: config.tls ? {} : void 0,
+    lazyConnect: true,
+    maxRetriesPerRequest: 1,
+    // Batch same-tick commands into one RTT (matches redis@5's default
+    // behavior) — makes Promise.all fan-outs a single pipeline.
+    enableAutoPipelining: true
+  });
+}
+function createIoredisSentinel(config) {
+  const IORedis = nodeRequire("ioredis");
+  const Ctor = IORedis.default ?? IORedis;
+  return new Ctor({
+    sentinels: config.sentinels,
+    name: config.name,
+    password: config.password,
+    sentinelPassword: config.sentinelPassword,
+    connectTimeout: config.connectTimeout ?? 1500,
+    tls: config.tls ? {} : void 0,
+    lazyConnect: true,
+    maxRetriesPerRequest: 1,
+    enableAutoPipelining: true
+  });
+}
+function createIoredisCluster(config) {
+  const IORedis = nodeRequire("ioredis");
+  const ClusterCtor = IORedis.Cluster ?? IORedis.default.Cluster;
+  return new ClusterCtor(config.nodes, {
+    redisOptions: {
+      password: config.password,
+      tls: config.tls ? {} : void 0
+    },
+    enableReadyCheck: true,
+    lazyConnect: true,
+    // Same-slot commands issued in the same tick share one pipeline.
+    enableAutoPipelining: true
+  });
+}
+var init_adapter_ioredis = __esm({
+  "src/shared/client/adapter-ioredis.ts"() {
+    init_esm_shims();
+    init_node_require();
+  }
+});
+
+// src/cli/index.ts
+init_esm_shims();
+
+// src/shared/client/index.ts
+init_esm_shims();
+async function buildClient(source) {
+  if (typeof source === "function") {
+    return await source();
+  }
+  switch (source.type) {
+    case "redis": {
+      const { adaptRedisV5: adaptRedisV52, createRedisV5Client: createRedisV5Client2 } = await Promise.resolve().then(() => (init_adapter_redis(), adapter_redis_exports));
+      return adaptRedisV52(createRedisV5Client2(source));
+    }
+    case "ioredis": {
+      const { adaptIoredis: adaptIoredis2, createIoredisClient: createIoredisClient2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptIoredis2(createIoredisClient2(source));
+    }
+    case "cluster": {
+      const { adaptCluster: adaptCluster2, createIoredisCluster: createIoredisCluster2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptCluster2(createIoredisCluster2(source));
+    }
+    case "sentinel": {
+      const { adaptIoredis: adaptIoredis2, createIoredisSentinel: createIoredisSentinel2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptIoredis2(createIoredisSentinel2(source));
+    }
+    default: {
+      const exhaustive = source;
+      throw new Error(
+        `[next-cache] unknown client config: ${JSON.stringify(exhaustive)}`
+      );
+    }
+  }
+}
+
+// src/seed/index.ts
+init_esm_shims();
+
+// src/shared/compress.ts
+init_esm_shims();
+var gzipAsync = promisify(gzip);
+promisify(gunzip);
+var brotliCompressAsync = promisify(brotliCompress);
+promisify(brotliDecompress);
+var GZIP_MARKER = "__ncgz__:";
+var BROTLI_MARKER = "__ncbr__:";
+var MIN_COMPRESS_BYTES = 1024;
+var BROTLI_OPTS = {
+  params: { [constants.BROTLI_PARAM_QUALITY]: 5 }
+};
+async function compressValue(value, algo) {
+  if (!algo || Buffer.byteLength(value) < MIN_COMPRESS_BYTES) return value;
+  const input = Buffer.from(value);
+  if (algo === "gzip") {
+    return GZIP_MARKER + (await gzipAsync(input)).toString("base64");
+  }
+  return BROTLI_MARKER + (await brotliCompressAsync(input, BROTLI_OPTS)).toString("base64");
+}
+
+// src/shared/namespace.ts
+init_esm_shims();
+var FALLBACK = "unversioned";
+function resolveBuildNamespace(override) {
+  if (override !== void 0) {
+    return typeof override === "function" ? override() : override;
+  }
+  return process.env.DEPLOYMENT_VERSION ?? process.env.GIT_HASH ?? process.env.NEXT_DEPLOYMENT_ID ?? FALLBACK;
+}
+function buildKey(prefix, namespace, rest, hashTag = false) {
+  const ns = hashTag ? `{${namespace}}` : namespace;
+  return `${prefix}${ns}:${rest}`;
+}
+
+// src/incremental/serialize.ts
+init_esm_shims();
+function replacer(key, value) {
+  const raw = this[key];
+  if (Buffer.isBuffer(raw)) {
+    const env = {
+      __type: "Buffer",
+      data: raw.toString("base64")
+    };
+    return env;
+  }
+  if (value instanceof Map) {
+    const env = {
+      __type: "Map",
+      entries: Array.from(value.entries())
+    };
+    return env;
+  }
+  return value;
+}
+function serializeCacheRecord(record) {
+  return JSON.stringify(record, replacer);
+}
+
+// src/seed/index.ts
+var ONE_YEAR_SEC = 60 * 60 * 24 * 365;
+var MIN_TTL_SEC = 60;
+var DEFAULT_KEY_PREFIX = "next-incremental:";
+function clampTtl(revalidate) {
+  if (revalidate === false || revalidate === void 0) return ONE_YEAR_SEC;
+  if (typeof revalidate === "number" && revalidate > 0) {
+    return Math.min(Math.max(Math.ceil(revalidate), MIN_TTL_SEC), ONE_YEAR_SEC);
+  }
+  return MIN_TTL_SEC;
+}
+function routeToFileBase(route) {
+  return route === "/" ? "/index" : route;
+}
+function readMeta(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeRecord(client, key, value, revalidateSec, opts) {
+  const record = {
+    lastModified: Date.now(),
+    value,
+    revalidateSec: clampTtl(revalidateSec)
+  };
+  const redisKey = buildKey(`${opts.keyPrefix}entry:`, opts.ns, key, opts.hashTag);
+  const payload = await compressValue(
+    serializeCacheRecord(record),
+    opts.compression
+  );
+  const result = await client.set(redisKey, payload, {
+    EX: clampTtl(revalidateSec),
+    NX: true
+  });
+  return result === null ? "skipped" : "written";
+}
+async function seedBuildOutput(options) {
+  const dir = path4.resolve(options.dir ?? ".next");
+  const keyPrefix = options.keyPrefix ?? DEFAULT_KEY_PREFIX;
+  const hashTag = options.hashTag ?? false;
+  const ns = resolveBuildNamespace(options.buildNamespace);
+  const warn = options.logger?.warn ?? (() => {
+  });
+  const summary = {
+    routes: 0,
+    pages: 0,
+    fetch: 0,
+    skippedExisting: 0,
+    skippedIncomplete: 0,
+    skippedRouteHandlers: 0,
+    errors: []
+  };
+  const manifestPath = path4.join(dir, "prerender-manifest.json");
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(
+      `[next-cache] no prerender-manifest.json in ${dir} \u2014 run \`next build\` first`
+    );
+  }
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const client = await buildClient(options.client);
+  if (!client.isOpen) await client.connect();
+  const writeOpts = { keyPrefix, hashTag, ns, ...options.compression ? { compression: options.compression } : {} };
+  try {
+    for (const [route, info] of Object.entries(manifest.routes ?? {})) {
+      try {
+        const isPages = typeof info.dataRoute === "string" && info.dataRoute.endsWith(".json");
+        const base = routeToFileBase(route);
+        if (isPages) {
+          const html = path4.join(dir, "server", "pages", `${base.slice(1)}.html`);
+          const data = path4.join(dir, "server", "pages", `${base.slice(1)}.json`);
+          if (!fs.existsSync(html)) {
+            summary.skippedIncomplete += 1;
+            continue;
+          }
+          const value2 = {
+            kind: "PAGES",
+            html: fs.readFileSync(html, "utf8"),
+            pageData: fs.existsSync(data) ? JSON.parse(fs.readFileSync(data, "utf8")) : {},
+            headers: void 0,
+            status: void 0
+          };
+          const r2 = await writeRecord(client, route, value2, info.initialRevalidateSeconds, writeOpts);
+          if (r2 === "written") summary.pages += 1;
+          else summary.skippedExisting += 1;
+          continue;
+        }
+        const htmlPath = path4.join(dir, "server", "app", `${base.slice(1)}.html`);
+        const rscPath = path4.join(dir, "server", "app", `${base.slice(1)}.rsc`);
+        const metaPath = path4.join(dir, "server", "app", `${base.slice(1)}.meta`);
+        if (!fs.existsSync(htmlPath) || !fs.existsSync(metaPath)) {
+          if (fs.existsSync(path4.join(dir, "server", "app", `${base.slice(1)}.body`))) {
+            summary.skippedRouteHandlers += 1;
+          } else {
+            summary.skippedIncomplete += 1;
+          }
+          continue;
+        }
+        const meta = readMeta(metaPath) ?? {};
+        if (meta.postponed) {
+          summary.skippedIncomplete += 1;
+          continue;
+        }
+        let segmentData;
+        if (Array.isArray(meta.segmentPaths) && meta.segmentPaths.length > 0) {
+          const segDir = path4.join(dir, "server", "app", `${base.slice(1)}.segments`);
+          segmentData = /* @__PURE__ */ new Map();
+          for (const segPath of meta.segmentPaths) {
+            const segFile = path4.join(segDir, `${segPath.slice(1)}.segment.rsc`);
+            if (fs.existsSync(segFile)) {
+              segmentData.set(segPath, fs.readFileSync(segFile));
+            }
+          }
+          if (segmentData.size !== meta.segmentPaths.length) {
+            summary.skippedIncomplete += 1;
+            continue;
+          }
+        }
+        const value = {
+          kind: "APP_PAGE",
+          html: fs.readFileSync(htmlPath, "utf8"),
+          rscData: fs.existsSync(rscPath) ? fs.readFileSync(rscPath) : void 0,
+          headers: meta.headers,
+          status: meta.status
+        };
+        if (segmentData) value.segmentData = segmentData;
+        const r = await writeRecord(client, route, value, info.initialRevalidateSeconds, writeOpts);
+        if (r === "written") summary.routes += 1;
+        else summary.skippedExisting += 1;
+      } catch (err) {
+        summary.errors.push(`${route}: ${err.message}`);
+        warn("seed: route failed", { route, message: err.message });
+      }
+    }
+    const fetchDir = path4.join(dir, "cache", "fetch-cache");
+    if (fs.existsSync(fetchDir)) {
+      for (const file of fs.readdirSync(fetchDir)) {
+        if (file.startsWith(".")) continue;
+        try {
+          const raw = fs.readFileSync(path4.join(fetchDir, file), "utf8");
+          const value = JSON.parse(raw);
+          if (value.kind !== "FETCH") continue;
+          const r = await writeRecord(client, file, value, value.revalidate, writeOpts);
+          if (r === "written") summary.fetch += 1;
+          else summary.skippedExisting += 1;
+        } catch (err) {
+          summary.errors.push(`fetch:${file}: ${err.message}`);
+        }
+      }
+    }
+  } finally {
+    const c = client;
+    try {
+      (c.dispose ?? c.destroy ?? c.disconnect)?.call(c);
+    } catch {
+    }
+  }
+  return summary;
+}
+
+// src/cli/index.ts
+var OK = "[ok]";
+var WARN = "[warn]";
+var ACTION = "[action]";
+var ERR = "[error]";
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function detectNextMajor(pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const raw = deps["next"] ?? null;
+  if (!raw) return { raw: null, major: null, supportsCacheComponents: false };
+  const m = raw.match(/(\d+)\.(\d+)/);
+  if (!m) return { raw, major: null, supportsCacheComponents: false };
+  const major = Number(m[1]);
+  const minor = Number(m[2]);
+  const supportsCacheComponents = major > 16 ? false : major === 16 && minor >= 1;
+  return { raw, major, supportsCacheComponents };
+}
+function detectClient(pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  if (deps["redis"]) return "redis";
+  if (deps["ioredis"]) return "ioredis";
+  return null;
+}
+function findNextConfig(cwd) {
+  for (const name of ["next.config.ts", "next.config.js", "next.config.mjs", "next.config.cjs"]) {
+    const p = path4.join(cwd, name);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+var RULES_BEGIN = "<!-- nextjs-cache-handler:rules:begin -->";
+var RULES_END = "<!-- nextjs-cache-handler:rules:end -->";
+function packagedFile(rel) {
+  const root = path4.resolve(__dirname$1, "..", "..");
+  const p = path4.join(root, rel);
+  return fs.existsSync(p) ? p : null;
+}
+function shimSource(kind, clientType) {
+  const factory = kind === "incremental" ? "createIncrementalCacheHandler" : "createCacheComponentsHandler";
+  const subpath = kind === "incremental" ? "incremental" : "cache-components";
+  return `// Generated by \`npx nextjs-cache-handler init\`
+const { ${factory} } = require("@leejpsd/nextjs-cache-handler/${subpath}");
+
+module.exports = ${factory}({
+  client: { type: "${clientType}", url: process.env.REDIS_URL },
+  // Per-deploy namespace isolation \u2014 set DEPLOYMENT_VERSION in every runtime
+  // environment (Docker: the runner stage), e.g. the git SHA.
+  buildNamespace: () => process.env.DEPLOYMENT_VERSION,
+});
+`;
+}
+async function init(ctx) {
+  const { cwd, flags, log } = ctx;
+  const apply = flags.has("--yes") && !flags.has("--dry-run");
+  const pkg = readJson(path4.join(cwd, "package.json"));
+  if (!pkg) {
+    log(`${ERR} no package.json in ${cwd} \u2014 run inside your Next.js project`);
+    return 1;
+  }
+  const next = detectNextMajor(pkg);
+  if (!next.raw) {
+    log(`${ERR} "next" is not a dependency here \u2014 not a Next.js project`);
+    return 1;
+  }
+  if (next.major !== null && next.major < 15) {
+    log(`${ERR} next@${next.raw} unsupported \u2014 this package needs next >=15.0.0 <17`);
+    return 1;
+  }
+  log(`${OK} next: ${next.raw} \u2192 ${next.supportsCacheComponents ? "BOTH handlers (ISR + 'use cache')" : "ISR handler only"}`);
+  const deps = pkg.dependencies;
+  if (!deps?.["@leejpsd/nextjs-cache-handler"]) {
+    log(`${ACTION} install the package first: npm i @leejpsd/nextjs-cache-handler`);
+  } else {
+    log(`${OK} @leejpsd/nextjs-cache-handler ${deps["@leejpsd/nextjs-cache-handler"]}`);
+  }
+  const client = detectClient(pkg);
+  if (!client) {
+    log(`${ACTION} no Redis client installed \u2014 run: npm i redis   (or ioredis for Cluster/Sentinel)`);
+  } else {
+    log(`${OK} redis client: ${client}`);
+  }
+  const clientType = client ?? "redis";
+  const wanted = [
+    ["incremental", "cache-incremental.cjs"]
+  ];
+  if (next.supportsCacheComponents) wanted.push(["cache-components", "cache-components.cjs"]);
+  for (const [kind, file] of wanted) {
+    const target = path4.join(cwd, file);
+    if (fs.existsSync(target)) {
+      log(`${OK} ${file} already exists \u2014 leaving it untouched`);
+      continue;
+    }
+    if (apply) {
+      fs.writeFileSync(target, shimSource(kind, clientType));
+      log(`${OK} wrote ${file}`);
+    } else {
+      log(`${ACTION} would create ${file} (re-run with --yes to write)`);
+    }
+  }
+  const cfg = findNextConfig(cwd);
+  const cfgLines = [
+    `cacheHandler: require.resolve("./cache-incremental.cjs"),`,
+    ...next.supportsCacheComponents ? [
+      `cacheHandlers: { default: require.resolve("./cache-components.cjs") },`,
+      `cacheComponents: true,`
+    ] : [],
+    `cacheMaxMemorySize: 0, // required for multi-instance correctness`
+  ];
+  if (!cfg) {
+    log(`${WARN} no next.config found \u2014 create one with:`);
+  } else {
+    const body = fs.readFileSync(cfg, "utf8");
+    if (body.includes("cacheHandler")) {
+      log(`${OK} ${path4.basename(cfg)} already references a cacheHandler \u2014 verify it points at the shims above`);
+    } else {
+      log(`${ACTION} add to ${path4.basename(cfg)}:`);
+    }
+    if (cfg.endsWith(".mjs")) {
+      log(`${WARN} ESM config: add  import { createRequire } from "module"; const require = createRequire(import.meta.url);`);
+    }
+  }
+  for (const l of cfgLines) log(`    ${l}`);
+  const envExample = path4.join(cwd, ".env.example");
+  const envBlock = `
+# @leejpsd/nextjs-cache-handler
+REDIS_URL=redis://127.0.0.1:6379
+DEPLOYMENT_VERSION=dev
+`;
+  if (fs.existsSync(envExample)) {
+    const body = fs.readFileSync(envExample, "utf8");
+    if (body.includes("REDIS_URL")) {
+      log(`${OK} .env.example already mentions REDIS_URL`);
+    } else if (apply) {
+      fs.appendFileSync(envExample, envBlock);
+      log(`${OK} appended REDIS_URL / DEPLOYMENT_VERSION to .env.example`);
+    } else {
+      log(`${ACTION} would append REDIS_URL / DEPLOYMENT_VERSION to .env.example`);
+    }
+  } else {
+    log(`${ACTION} set REDIS_URL and DEPLOYMENT_VERSION in every runtime environment`);
+  }
+  const rulesSrc = packagedFile("rules/nextjs-cache-rules.md");
+  const ruleTargets = ["CLAUDE.md", "AGENTS.md"].map((f) => path4.join(cwd, f)).filter((p) => fs.existsSync(p));
+  if (rulesSrc && ruleTargets.length > 0) {
+    const rules = `
+${RULES_BEGIN}
+${fs.readFileSync(rulesSrc, "utf8")}
+${RULES_END}
+`;
+    for (const target of ruleTargets) {
+      const body = fs.readFileSync(target, "utf8");
+      if (body.includes(RULES_BEGIN)) {
+        log(`${OK} ${path4.basename(target)} already has the cache rules block`);
+      } else if (apply) {
+        fs.appendFileSync(target, rules);
+        log(`${OK} appended cache rules to ${path4.basename(target)}`);
+      } else {
+        log(`${ACTION} would append cache rules to ${path4.basename(target)}`);
+      }
+    }
+  } else if (ruleTargets.length === 0) {
+    log(`${WARN} no CLAUDE.md/AGENTS.md found \u2014 skip rules injection (create one to guide your agent)`);
+  }
+  const mcpPath = path4.join(cwd, ".mcp.json");
+  if (fs.existsSync(mcpPath)) {
+    const body = fs.readFileSync(mcpPath, "utf8");
+    if (body.includes("nextjs-cache-handler-mcp")) {
+      log(`${OK} .mcp.json already registers the cache MCP server`);
+    } else {
+      log(`${ACTION} .mcp.json exists \u2014 add the "nextjs-cache" server manually (see @leejpsd/nextjs-cache-handler-mcp README)`);
+    }
+  } else if (apply) {
+    fs.writeFileSync(
+      mcpPath,
+      JSON.stringify(
+        {
+          mcpServers: {
+            "nextjs-cache": {
+              command: "npx",
+              args: ["-y", "@leejpsd/nextjs-cache-handler-mcp"],
+              env: {
+                REDIS_URL: "redis://127.0.0.1:6379",
+                DEPLOYMENT_VERSION: "dev"
+              }
+            }
+          }
+        },
+        null,
+        2
+      ) + "\n"
+    );
+    log(`${OK} wrote .mcp.json \u2014 your agent now has cache_health/tag_state/... tools (edit REDIS_URL for real environments)`);
+  } else {
+    log(`${ACTION} would create .mcp.json registering @leejpsd/nextjs-cache-handler-mcp`);
+  }
+  if (flags.has("--skills")) {
+    const skillSrc = packagedFile("skills/nextjs-redis-cache/SKILL.md");
+    if (skillSrc) {
+      const dest = path4.join(cwd, ".claude", "skills", "nextjs-redis-cache", "SKILL.md");
+      if (apply) {
+        fs.mkdirSync(path4.dirname(dest), { recursive: true });
+        fs.copyFileSync(skillSrc, dest);
+        log(`${OK} installed skill to .claude/skills/nextjs-redis-cache/`);
+      } else {
+        log(`${ACTION} would install skill to .claude/skills/nextjs-redis-cache/`);
+      }
+    }
+  }
+  log(`${OK} init ${apply ? "complete" : "preview complete \u2014 re-run with --yes to apply"}. Verify with: npx nextjs-cache-handler doctor`);
+  return 0;
+}
+async function doctor(ctx) {
+  const { args, log } = ctx;
+  const urlIdx = args.indexOf("--url");
+  const url = urlIdx >= 0 ? args[urlIdx + 1] : process.env.REDIS_URL;
+  if (!url) {
+    log(`${ERR} no Redis URL \u2014 pass --url <redis-url> or set REDIS_URL`);
+    return 1;
+  }
+  const deployment = process.env.DEPLOYMENT_VERSION;
+  log(deployment ? `${OK} DEPLOYMENT_VERSION=${deployment}` : `${WARN} DEPLOYMENT_VERSION not set \u2014 keys will use the "unversioned" namespace`);
+  let client;
+  try {
+    try {
+      client = await buildClient({ type: "redis", url });
+    } catch (err) {
+      if (/Cannot find module/.test(err.message)) {
+        client = await buildClient({ type: "ioredis", url });
+      } else {
+        throw err;
+      }
+    }
+    if (!client.isOpen) await client.connect();
+  } catch (err) {
+    log(`${ERR} connect failed: ${err.message}`);
+    log(`${ACTION} check the URL/network, or install a client: npm i redis  (or ioredis)`);
+    return 1;
+  }
+  try {
+    const t0 = Date.now();
+    await client.ping();
+    log(`${OK} redis PING ${Date.now() - t0}ms (${url.replace(/\/\/[^@]*@/, "//***@")})`);
+    const counts = /* @__PURE__ */ new Map();
+    for await (const chunk of client.scanIterator({ MATCH: "next-*", COUNT: 500 })) {
+      const keys = Array.isArray(chunk) ? chunk : [chunk];
+      for (const k of keys) {
+        const key = String(k);
+        const m = key.match(/^(next-cache|next-incremental):([a-z-]+):/);
+        const bucket = m ? `${m[1]}:${m[2]}` : "other";
+        counts.set(bucket, (counts.get(bucket) ?? 0) + 1);
+      }
+    }
+    if (counts.size === 0) {
+      log(`${WARN} no next-* keys found \u2014 cache not yet exercised (or a custom keyPrefix is in use)`);
+    } else {
+      for (const [bucket, n] of [...counts.entries()].sort()) {
+        log(`${OK} ${bucket}* \u2014 ${n} keys`);
+      }
+    }
+    const probeKey = `next-cache:doctor:${Date.now()}`;
+    await client.set(probeKey, "ok", { EX: 30 });
+    const back = await client.get(probeKey);
+    await client.del(probeKey);
+    log(back === "ok" ? `${OK} write/read round-trip` : `${ERR} round-trip failed`);
+    return back === "ok" ? 0 : 1;
+  } finally {
+    client.dispose?.();
+  }
+}
+async function seed(ctx) {
+  const { args, flags, log } = ctx;
+  const urlIdx = args.indexOf("--url");
+  const url = urlIdx >= 0 ? args[urlIdx + 1] : process.env.REDIS_URL;
+  if (!url) {
+    log(`${ERR} no Redis URL \u2014 pass --url <redis-url> or set REDIS_URL`);
+    return 1;
+  }
+  const flagVal = (name) => {
+    const i = args.indexOf(name);
+    return i >= 0 ? args[i + 1] : void 0;
+  };
+  const dir = flagVal("--dir") ?? ".next";
+  const keyPrefix = flagVal("--key-prefix");
+  const namespace = flagVal("--namespace");
+  const compression = flagVal("--compression");
+  const hashTag = flags.has("--hash-tag");
+  const ns = namespace ?? process.env.DEPLOYMENT_VERSION ?? process.env.GIT_HASH ?? "unversioned";
+  if (ns === "unversioned") {
+    log(`${WARN} no namespace \u2014 seeding into "unversioned" (set DEPLOYMENT_VERSION or pass --namespace)`);
+  }
+  log(`${OK} target keys: ${keyPrefix ?? "next-incremental:"}entry:${hashTag ? `{${ns}}` : ns}:*`);
+  const seedOpts = {
+    dir,
+    buildNamespace: ns,
+    ...keyPrefix ? { keyPrefix } : {},
+    ...compression ? { compression } : {},
+    ...hashTag ? { hashTag: true } : {}
+  };
+  const report = (summary) => {
+    log(`${OK} seeded: ${summary.routes} app routes, ${summary.pages} pages routes, ${summary.fetch} fetch entries`);
+    if (summary.skippedExisting > 0)
+      log(`${OK} left ${summary.skippedExisting} newer live entries untouched (NX)`);
+    if (summary.skippedRouteHandlers > 0)
+      log(`${OK} ${summary.skippedRouteHandlers} prerendered route handlers not seeded (by design)`);
+    if (summary.skippedIncomplete > 0)
+      log(`${WARN} skipped ${summary.skippedIncomplete} routes (incomplete files or PPR resume state)`);
+    for (const e of summary.errors.slice(0, 5)) log(`${WARN} ${e}`);
+    return summary.errors.length > 0 ? 1 : 0;
+  };
+  try {
+    return report(
+      await seedBuildOutput({ client: { type: "redis", url }, ...seedOpts })
+    );
+  } catch (err) {
+    const msg = err.message;
+    if (/Cannot find module 'redis'/.test(msg)) {
+      try {
+        return report(
+          await seedBuildOutput({ client: { type: "ioredis", url }, ...seedOpts })
+        );
+      } catch (err2) {
+        log(`${ERR} ${err2.message}`);
+        return 1;
+      }
+    }
+    log(`${ERR} ${msg}`);
+    return 1;
+  }
+}
+async function main(argv = process.argv.slice(2)) {
+  const [cmd, ...rest] = argv;
+  const ctx = {
+    cwd: process.cwd(),
+    args: rest,
+    flags: new Set(rest.filter((a) => a.startsWith("--"))),
+    log: (l) => console.log(l)
+  };
+  switch (cmd) {
+    case "init":
+      return init(ctx);
+    case "doctor":
+      return doctor(ctx);
+    case "seed":
+      return seed(ctx);
+    default:
+      console.log(`nextjs-cache-handler <command>
+
+Commands:
+  init    [--yes] [--dry-run] [--skills]   wire handlers into this Next.js app
+  doctor  [--url <redis-url>]              connectivity + cache diagnostics
+  seed    [--dir .next] [--url <u>] [--namespace <ns>] [--key-prefix <p>] [--hash-tag] [--compression gzip|brotli]
+          seed prerendered build output into Redis
+
+Agent setup instructions:
+  https://raw.githubusercontent.com/leejpsd/nextjs-cache-handler/main/setup-instructions/setup.md`);
+      return cmd ? 1 : 0;
+  }
+}
+
+export { doctor, init, main, seed };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map