esa-pcg-cli 0.1.1 → 0.1.3

package/dist/runtime/cdn-purge.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * CDN Purge Runtime
+ *
+ * 在 revalidateTag / revalidatePath 后,fire-and-forget 触发 ESA 边缘缓存失效。
+ *
+ * 设计原则:
+ *   - tag → paths 反查走 **本地** manifest(build 时由 pcg build 把
+ *     .open-next/dynamodb-provider/dynamodb-cache.json 嵌入 FC bundle),
+ *     运行时第一次用到时 lazy 加载到内存 Map,后续 O(1) 查询,无网络往返
+ *   - /cache/refresh 走 Gateway,沿用现有 HMAC 鉴权 + ESA 分流
+ *   - 所有失败仅 warn,绝不抛错(purge 是优化,不是正确性)
+ *   - hostname / siteId 缺失则 loadCdnPurgeConfig 返回 null,调用方降级 no-op
+ *   - 跨 tag 反查结果去重,每 path 追加 /_next/data/{buildId}/{path}.json
+ *   - 调 /cache/refresh 时按 100 URL/批、batch 内并发上限 4
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCdnPurgeClient = exports.loadCdnPurgeConfig = void 0;
+const fs = require("fs");
+const path = require("path");
+const gateway_auth_1 = require("./gateway-auth");
+const REFRESH_TIMEOUT_MS = 15000;
+const URL_BATCH_SIZE = 100;
+const REFRESH_CONCURRENCY = 4;
+// 与 build.ts 中 TAG_MANIFEST_FILENAME 保持一致(对侧是写入,这侧是读取)
+const TAG_MANIFEST_FILENAME = '__pcg_tag_manifest.json';
+function stripLeadingSlash(s) {
+    return s.replace(/^\/+/, '');
+}
+function ensureLeadingSlash(s) {
+    return s.startsWith('/') ? s : `/${s}`;
+}
+/**
+ * 从环境变量加载 purge 配置。
+ *
+ * 沿用 loadGatewayAuthConfig 的 5 个 env,额外读取:
+ *   - ESA_CACHE_GW_HOSTNAME — 拼 purge URL 用
+ *   - ESA_CACHE_GW_SITE_ID  — 透传给 /cache/refresh
+ *
+ * 缺一返回 null,调用方应跳过 purge(不影响 tag 写库)。
+ */
+function loadCdnPurgeConfig() {
+    const base = (0, gateway_auth_1.loadGatewayAuthConfig)();
+    if (!base)
+        return null;
+    const hostname = process.env.ESA_CACHE_GW_HOSTNAME;
+    const siteIdRaw = process.env.ESA_CACHE_GW_SITE_ID;
+    if (!hostname || !siteIdRaw) {
+        return null;
+    }
+    const siteIdNum = Number(siteIdRaw);
+    const siteId = Number.isFinite(siteIdNum)
+        ? siteIdNum
+        : siteIdRaw;
+    return {
+        ...base,
+        hostname,
+        siteId,
+    };
+}
+exports.loadCdnPurgeConfig = loadCdnPurgeConfig;
+function createCdnPurgeClient(cfg) {
+    var _a;
+    const buildId = cfg.version;
+    const pathPrefix = `${buildId}/`;
+    const manifestPath = (_a = cfg.manifestPath) !== null && _a !== void 0 ? _a : path.join(__dirname, TAG_MANIFEST_FILENAME);
+    // lazy 加载;Promise 用于并发首次调用的合流
+    let manifestPromise = null;
+    async function loadManifest() {
+        if (manifestPromise)
+            return manifestPromise;
+        manifestPromise = (async () => {
+            var _a, _b, _c, _d;
+            const map = new Map();
+            let raw;
+            try {
+                raw = await fs.promises.readFile(manifestPath, 'utf-8');
+            }
+            catch (err) {
+                // ENOENT 是常见情况(纯静态项目无 tag,或老版 CLI 未嵌入),静默降级
+                if ((err === null || err === void 0 ? void 0 : err.code) !== 'ENOENT') {
+                    console.warn(`[cdn-purge] manifest read error ${manifestPath}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                }
+                return new Map();
+            }
+            let rows;
+            try {
+                const parsed = JSON.parse(raw);
+                rows = Array.isArray(parsed) ? parsed : [];
+            }
+            catch (err) {
+                console.warn(`[cdn-purge] manifest parse error ${manifestPath}: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
+                return new Map();
+            }
+            for (const row of rows) {
+                const tagPk = (_c = row === null || row === void 0 ? void 0 : row.tag) === null || _c === void 0 ? void 0 : _c.S;
+                const pathPk = (_d = row === null || row === void 0 ? void 0 : row.path) === null || _d === void 0 ? void 0 : _d.S;
+                if (typeof tagPk !== 'string' || typeof pathPk !== 'string')
+                    continue;
+                // 只接受当前 buildId 的行;OpenNext 已保证 prefix,但万一混入旧行就跳过
+                if (!tagPk.startsWith(pathPrefix))
+                    continue;
+                if (!pathPk.startsWith(pathPrefix))
+                    continue;
+                const tag = tagPk.slice(pathPrefix.length);
+                const p = pathPk.slice(pathPrefix.length);
+                if (!tag || !p)
+                    continue;
+                let bucket = map.get(tag);
+                if (!bucket) {
+                    bucket = new Set();
+                    map.set(tag, bucket);
+                }
+                bucket.add(p);
+            }
+            const result = new Map();
+            for (const [tag, set] of map) {
+                result.set(tag, Array.from(set));
+            }
+            return result;
+        })();
+        return manifestPromise;
+    }
+    /**
+     * 把若干 Next 路由 path 展开成需 purge 的 URL 列表:
+     *   - 跳过空串、去重(基于规范化后的 leading "/")
+     *   - 对每个 path 追加 /_next/data/{buildId}/{path}.json
+     *   - 拼上 https://{hostname}
+     */
+    function expandPathsToUrls(paths) {
+        const normalized = new Set();
+        for (const p of paths) {
+            if (!p)
+                continue;
+            normalized.add(ensureLeadingSlash(p));
+        }
+        if (normalized.size === 0)
+            return [];
+        const urls = new Set();
+        for (const p of normalized) {
+            urls.add(`https://${cfg.hostname}${p}`);
+            const rel = stripLeadingSlash(p);
+            // pages router ISR 必需;app router 多打一条无副作用
+            urls.add(`https://${cfg.hostname}/_next/data/${buildId}/${rel || 'index'}.json`);
+        }
+        return Array.from(urls);
+    }
+    async function refreshBatch(urls) {
+        var _a;
+        const body = {
+            hostname: cfg.hostname,
+            siteId: cfg.siteId,
+            urls,
+        };
+        let res;
+        try {
+            res = await (0, gateway_auth_1.gatewayFetch)(cfg, '/cache/refresh', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+                timeoutMs: REFRESH_TIMEOUT_MS,
+            });
+        }
+        catch (err) {
+            console.warn(`[cdn-purge] cache/refresh error (${urls.length} urls): ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            return;
+        }
+        if (!res.ok) {
+            let detail = '';
+            try {
+                detail = (await res.text()).slice(0, 200);
+            }
+            catch (_b) {
+                /* ignore */
+            }
+            console.warn(`[cdn-purge] cache/refresh failed status=${res.status} urls=${urls.length} ${detail}`);
+        }
+    }
+    async function refreshUrls(allUrls) {
+        if (allUrls.length === 0)
+            return;
+        const batches = [];
+        for (let i = 0; i < allUrls.length; i += URL_BATCH_SIZE) {
+            batches.push(allUrls.slice(i, i + URL_BATCH_SIZE));
+        }
+        // 并发上限 REFRESH_CONCURRENCY 的滑动窗口
+        let cursor = 0;
+        async function worker() {
+            while (cursor < batches.length) {
+                const idx = cursor++;
+                await refreshBatch(batches[idx]);
+            }
+        }
+        const workers = Array.from({ length: Math.min(REFRESH_CONCURRENCY, batches.length) }, () => worker());
+        await Promise.all(workers);
+    }
+    async function purgeByPaths(paths) {
+        var _a;
+        try {
+            const urls = expandPathsToUrls(paths);
+            await refreshUrls(urls);
+        }
+        catch (err) {
+            console.warn(`[cdn-purge] purgeByPaths error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    }
+    async function purgeByTags(tags) {
+        var _a;
+        try {
+            const uniqueTags = Array.from(new Set(tags
+                .map(t => (typeof t === 'string' ? t : ''))
+                .map(t => t.trim())
+                .filter(Boolean)));
+            if (uniqueTags.length === 0)
+                return;
+            const map = await loadManifest();
+            const merged = new Set();
+            for (const t of uniqueTags) {
+                const paths = map.get(t);
+                if (!paths)
+                    continue;
+                for (const p of paths)
+                    merged.add(p);
+            }
+            if (merged.size === 0)
+                return;
+            const urls = expandPathsToUrls(Array.from(merged));
+            await refreshUrls(urls);
+        }
+        catch (err) {
+            console.warn(`[cdn-purge] purgeByTags error: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    }
+    return { purgeByPaths, purgeByTags };
+}
+exports.createCdnPurgeClient = createCdnPurgeClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdn-purge.js","sourceRoot":"","sources":["../../src/runtime/cdn-purge.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CDN Purge Runtime\n *\n * 在 revalidateTag / revalidatePath 后,fire-and-forget 触发 ESA 边缘缓存失效。\n *\n * 设计原则:\n *   - tag → paths 反查走 **本地** manifest(build 时由 pcg build 把\n *     .open-next/dynamodb-provider/dynamodb-cache.json 嵌入 FC bundle),\n *     运行时第一次用到时 lazy 加载到内存 Map,后续 O(1) 查询,无网络往返\n *   - /cache/refresh 走 Gateway,沿用现有 HMAC 鉴权 + ESA 分流\n *   - 所有失败仅 warn,绝不抛错(purge 是优化,不是正确性)\n *   - hostname / siteId 缺失则 loadCdnPurgeConfig 返回 null,调用方降级 no-op\n *   - 跨 tag 反查结果去重,每 path 追加 /_next/data/{buildId}/{path}.json\n *   - 调 /cache/refresh 时按 100 URL/批、batch 内并发上限 4\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { CacheRefreshRequest } from '@pcg/protocol';\nimport {\n  loadGatewayAuthConfig,\n  gatewayFetch,\n  GatewayAuthConfig,\n} from './gateway-auth';\n\nconst REFRESH_TIMEOUT_MS = 15_000;\n\nconst URL_BATCH_SIZE = 100;\nconst REFRESH_CONCURRENCY = 4;\n\n// 与 build.ts 中 TAG_MANIFEST_FILENAME 保持一致(对侧是写入,这侧是读取)\nconst TAG_MANIFEST_FILENAME = '__pcg_tag_manifest.json';\n\nexport interface CdnPurgeConfig extends GatewayAuthConfig {\n  hostname: string;\n  siteId: string | number;\n  /**\n   * 覆盖默认 manifest 路径,主要给测试用。\n   * 默认 = path.join(__dirname, '__pcg_tag_manifest.json'),\n   * 即 FC bundle 内与 cache.cjs 同级。\n   */\n  manifestPath?: string;\n}\n\nexport interface CdnPurgeClient {\n  /**\n   * 异步触发 ESA 缓存失效。不阻塞调用方,失败仅 warn。\n   * 内部完成 path 去重 + ISR 数据路径补全 + 限流。\n   */\n  purgeByPaths(paths: string[]): Promise<void>;\n\n  /**\n   * tag → paths 反查 + purge。\n   * 反查走本地嵌入的 manifest 文件,无网络 IO。\n   */\n  purgeByTags(tags: string[]): Promise<void>;\n}\n\nfunction stripLeadingSlash(s: string): string {\n  return s.replace(/^\\/+/, '');\n}\n\nfunction ensureLeadingSlash(s: string): string {\n  return s.startsWith('/') ? s : `/${s}`;\n}\n\n/**\n * 从环境变量加载 purge 配置。\n *\n * 沿用 loadGatewayAuthConfig 的 5 个 env,额外读取:\n *   - ESA_CACHE_GW_HOSTNAME — 拼 purge URL 用\n *   - ESA_CACHE_GW_SITE_ID  — 透传给 /cache/refresh\n *\n * 缺一返回 null,调用方应跳过 purge(不影响 tag 写库)。\n */\nexport function loadCdnPurgeConfig(): CdnPurgeConfig | null {\n  const base = loadGatewayAuthConfig();\n  if (!base) return null;\n\n  const hostname = process.env.ESA_CACHE_GW_HOSTNAME;\n  const siteIdRaw = process.env.ESA_CACHE_GW_SITE_ID;\n\n  if (!hostname || !siteIdRaw) {\n    return null;\n  }\n\n  const siteIdNum = Number(siteIdRaw);\n  const siteId: string | number = Number.isFinite(siteIdNum)\n    ? siteIdNum\n    : siteIdRaw;\n\n  return {\n    ...base,\n    hostname,\n    siteId,\n  };\n}\n\n/**\n * dynamodb-provider/dynamodb-cache.json 的行格式 ——\n * 由 OpenNext build 直接产出,字段名固定为 DynamoDB 属性映射格式。\n */\ninterface DynamoTagRow {\n  tag: { S: string };\n  path: { S: string };\n  revalidatedAt?: { N: string };\n}\n\nexport function createCdnPurgeClient(cfg: CdnPurgeConfig): CdnPurgeClient {\n  const buildId = cfg.version;\n  const pathPrefix = `${buildId}/`;\n  const manifestPath =\n    cfg.manifestPath ?? path.join(__dirname, TAG_MANIFEST_FILENAME);\n\n  // lazy 加载;Promise 用于并发首次调用的合流\n  let manifestPromise: Promise<Map<string, string[]>> | null = null;\n\n  async function loadManifest(): Promise<Map<string, string[]>> {\n    if (manifestPromise) return manifestPromise;\n    manifestPromise = (async () => {\n      const map = new Map<string, Set<string>>();\n      let raw: string;\n      try {\n        raw = await fs.promises.readFile(manifestPath, 'utf-8');\n      } catch (err: any) {\n        // ENOENT 是常见情况(纯静态项目无 tag,或老版 CLI 未嵌入),静默降级\n        if (err?.code !== 'ENOENT') {\n          console.warn(\n            `[cdn-purge] manifest read error ${manifestPath}: ${err?.message ?? err}`\n          );\n        }\n        return new Map<string, string[]>();\n      }\n      let rows: DynamoTagRow[];\n      try {\n        const parsed = JSON.parse(raw);\n        rows = Array.isArray(parsed) ? parsed : [];\n      } catch (err: any) {\n        console.warn(\n          `[cdn-purge] manifest parse error ${manifestPath}: ${err?.message ?? err}`\n        );\n        return new Map<string, string[]>();\n      }\n\n      for (const row of rows) {\n        const tagPk = row?.tag?.S;\n        const pathPk = row?.path?.S;\n        if (typeof tagPk !== 'string' || typeof pathPk !== 'string') continue;\n        // 只接受当前 buildId 的行;OpenNext 已保证 prefix,但万一混入旧行就跳过\n        if (!tagPk.startsWith(pathPrefix)) continue;\n        if (!pathPk.startsWith(pathPrefix)) continue;\n        const tag = tagPk.slice(pathPrefix.length);\n        const p = pathPk.slice(pathPrefix.length);\n        if (!tag || !p) continue;\n        let bucket = map.get(tag);\n        if (!bucket) {\n          bucket = new Set<string>();\n          map.set(tag, bucket);\n        }\n        bucket.add(p);\n      }\n\n      const result = new Map<string, string[]>();\n      for (const [tag, set] of map) {\n        result.set(tag, Array.from(set));\n      }\n      return result;\n    })();\n    return manifestPromise;\n  }\n\n  /**\n   * 把若干 Next 路由 path 展开成需 purge 的 URL 列表:\n   *   - 跳过空串、去重(基于规范化后的 leading \"/\")\n   *   - 对每个 path 追加 /_next/data/{buildId}/{path}.json\n   *   - 拼上 https://{hostname}\n   */\n  function expandPathsToUrls(paths: string[]): string[] {\n    const normalized = new Set<string>();\n    for (const p of paths) {\n      if (!p) continue;\n      normalized.add(ensureLeadingSlash(p));\n    }\n    if (normalized.size === 0) return [];\n\n    const urls = new Set<string>();\n    for (const p of normalized) {\n      urls.add(`https://${cfg.hostname}${p}`);\n      const rel = stripLeadingSlash(p);\n      // pages router ISR 必需;app router 多打一条无副作用\n      urls.add(\n        `https://${cfg.hostname}/_next/data/${buildId}/${rel || 'index'}.json`\n      );\n    }\n    return Array.from(urls);\n  }\n\n  async function refreshBatch(urls: string[]): Promise<void> {\n    const body: CacheRefreshRequest = {\n      hostname: cfg.hostname,\n      siteId: cfg.siteId,\n      urls,\n    };\n\n    let res: Response;\n    try {\n      res = await gatewayFetch(cfg, '/cache/refresh', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(body),\n        timeoutMs: REFRESH_TIMEOUT_MS,\n      });\n    } catch (err: any) {\n      console.warn(\n        `[cdn-purge] cache/refresh error (${urls.length} urls): ${err?.message ?? err}`\n      );\n      return;\n    }\n\n    if (!res.ok) {\n      let detail = '';\n      try {\n        detail = (await res.text()).slice(0, 200);\n      } catch {\n        /* ignore */\n      }\n      console.warn(\n        `[cdn-purge] cache/refresh failed status=${res.status} urls=${urls.length} ${detail}`\n      );\n    }\n  }\n\n  async function refreshUrls(allUrls: string[]): Promise<void> {\n    if (allUrls.length === 0) return;\n\n    const batches: string[][] = [];\n    for (let i = 0; i < allUrls.length; i += URL_BATCH_SIZE) {\n      batches.push(allUrls.slice(i, i + URL_BATCH_SIZE));\n    }\n\n    // 并发上限 REFRESH_CONCURRENCY 的滑动窗口\n    let cursor = 0;\n    async function worker(): Promise<void> {\n      while (cursor < batches.length) {\n        const idx = cursor++;\n        await refreshBatch(batches[idx]);\n      }\n    }\n\n    const workers = Array.from(\n      { length: Math.min(REFRESH_CONCURRENCY, batches.length) },\n      () => worker()\n    );\n    await Promise.all(workers);\n  }\n\n  async function purgeByPaths(paths: string[]): Promise<void> {\n    try {\n      const urls = expandPathsToUrls(paths);\n      await refreshUrls(urls);\n    } catch (err: any) {\n      console.warn(`[cdn-purge] purgeByPaths error: ${err?.message ?? err}`);\n    }\n  }\n\n  async function purgeByTags(tags: string[]): Promise<void> {\n    try {\n      const uniqueTags = Array.from(\n        new Set(\n          tags\n            .map(t => (typeof t === 'string' ? t : ''))\n            .map(t => t.trim())\n            .filter(Boolean)\n        )\n      );\n      if (uniqueTags.length === 0) return;\n\n      const map = await loadManifest();\n\n      const merged = new Set<string>();\n      for (const t of uniqueTags) {\n        const paths = map.get(t);\n        if (!paths) continue;\n        for (const p of paths) merged.add(p);\n      }\n      if (merged.size === 0) return;\n\n      const urls = expandPathsToUrls(Array.from(merged));\n      await refreshUrls(urls);\n    } catch (err: any) {\n      console.warn(`[cdn-purge] purgeByTags error: ${err?.message ?? err}`);\n    }\n  }\n\n  return { purgeByPaths, purgeByTags };\n}\n"]}

package/dist/runtime/image-config.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 解析 next.config.images 并校验 /_next/image 的 url 参数。
+ *
+ * 配置来源:OpenNext build 完成后会把解析后的完整 next.config 写到
+ * <server-bundle>/.next/required-server-files.json,images 字段就是 Next 自己
+ * 在运行时用的最终形态。直接读这个文件可以避开 next.config 的 TS/ESM/JS 三种
+ * 形态解析,也无需在 build 阶段做额外抽取。
+ *
+ * 匹配算法:复用 Next 自己的 match-remote-pattern 模块——picomatch 的 glob
+ * 语义边界(`**` 跨段、`*` 单段、`?`、`{a,b}`)自己重写很容易跟 next dev
+ * 行为漂移。Next 必然在 server bundle 的 node_modules 里,运行时 require 即可。
+ *
+ * 边界行为(已与上层对齐):
+ * - 校验失败 → 上层 400(对齐 Next 默认行为)
+ * - required-server-files.json 缺失 → warn + 放行(兼容老产物,不阻断部署)
+ * - images.unoptimized=true → 跳过校验、照常代发(用户关了 Next 优化但仍走
+ *   wrapper,白名单职责让位给上游)
+ */
+interface RemotePattern {
+    protocol?: 'http' | 'https';
+    hostname: string;
+    port?: string;
+    pathname?: string;
+    search?: string;
+}
+declare type MatcherImpl = (domains: string[], remotePatterns: RemotePattern[], url: URL) => boolean;
+export interface ValidateResult {
+    ok: boolean;
+    reason?: string;
+}
+/**
+ * 校验 /_next/image 的 url 是否被允许。语义对齐 Next:
+ * - 同源(host header === url 的 host,含端口)始终放行
+ * - unoptimized:true 跳过校验
+ * - 否则必须命中 domains 或 remotePatterns 之一
+ */
+export declare function validateImageUrl(absoluteUrl: URL, hostHeader: string): ValidateResult;
+/** 测试用:重置缓存。生产代码不调用。 */
+export declare function _resetImageConfigCacheForTests(): void;
+/**
+ * 测试用:注入 matcher,绕过对真实 next 模块的 require。
+ * 传 null 模拟"matcher 不可用"分支。
+ */
+export declare function _setMatcherForTests(impl: MatcherImpl | null): void;
+export {};

package/dist/runtime/image-config.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * 解析 next.config.images 并校验 /_next/image 的 url 参数。
+ *
+ * 配置来源:OpenNext build 完成后会把解析后的完整 next.config 写到
+ * <server-bundle>/.next/required-server-files.json,images 字段就是 Next 自己
+ * 在运行时用的最终形态。直接读这个文件可以避开 next.config 的 TS/ESM/JS 三种
+ * 形态解析,也无需在 build 阶段做额外抽取。
+ *
+ * 匹配算法:复用 Next 自己的 match-remote-pattern 模块——picomatch 的 glob
+ * 语义边界(`**` 跨段、`*` 单段、`?`、`{a,b}`)自己重写很容易跟 next dev
+ * 行为漂移。Next 必然在 server bundle 的 node_modules 里,运行时 require 即可。
+ *
+ * 边界行为(已与上层对齐):
+ * - 校验失败 → 上层 400(对齐 Next 默认行为)
+ * - required-server-files.json 缺失 → warn + 放行(兼容老产物,不阻断部署)
+ * - images.unoptimized=true → 跳过校验、照常代发(用户关了 Next 优化但仍走
+ *   wrapper,白名单职责让位给上游)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._setMatcherForTests = exports._resetImageConfigCacheForTests = exports.validateImageUrl = void 0;
+const fs = require("fs");
+const path = require("path");
+let cachedConfig;
+let cachedMatcher;
+let warnedMatcherMissing = false;
+/**
+ * 路径解析与 node-server.ts 的 assets 解析同源:wrapper 启动时
+ * process.cwd() === server-functions/default/,所以 .next 就在 cwd 下。
+ */
+function configFilePath() {
+    return path.resolve(process.cwd(), '.next', 'required-server-files.json');
+}
+function loadImageConfig() {
+    var _a, _b, _c;
+    if (cachedConfig !== undefined)
+        return cachedConfig;
+    const filePath = configFilePath();
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch (err) {
+        console.warn(`[image-config] required-server-files.json not found at ${filePath} — allowing all image URLs (${(_a = err.code) !== null && _a !== void 0 ? _a : err.message})`);
+        cachedConfig = { mode: 'config-missing' };
+        return cachedConfig;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const images = (_c = (_b = parsed === null || parsed === void 0 ? void 0 : parsed.config) === null || _b === void 0 ? void 0 : _b.images) !== null && _c !== void 0 ? _c : {};
+        cachedConfig = {
+            mode: 'loaded',
+            images: {
+                remotePatterns: Array.isArray(images.remotePatterns)
+                    ? images.remotePatterns
+                    : [],
+                domains: Array.isArray(images.domains) ? images.domains : [],
+                unoptimized: images.unoptimized === true,
+            },
+        };
+        return cachedConfig;
+    }
+    catch (err) {
+        console.warn(`[image-config] failed to parse ${filePath}: ${err.message} — allowing all image URLs`);
+        cachedConfig = { mode: 'config-missing' };
+        return cachedConfig;
+    }
+}
+/**
+ * 拿 Next 自己的 hasRemoteMatch。失败一次后缓存 null,后续走严格 deny 分支。
+ * 用 eval('require') 让 esbuild 不去尝试解析 next 模块——wrapper bundle 由
+ * scripts/bundle-overrides.js 用 esbuild 打包,把 next 标了 external 是 belt-
+ * and-suspenders;eval 这一层确保即便 external 配错也打不进 bundle。
+ */
+function loadMatcher() {
+    if (cachedMatcher !== undefined)
+        return cachedMatcher;
+    try {
+        const dynamicRequire = eval('require');
+        const mod = dynamicRequire('next/dist/shared/lib/match-remote-pattern');
+        const hasRemoteMatch = mod === null || mod === void 0 ? void 0 : mod.hasRemoteMatch;
+        if (typeof hasRemoteMatch !== 'function') {
+            throw new Error('hasRemoteMatch not exported');
+        }
+        cachedMatcher = hasRemoteMatch;
+        return cachedMatcher;
+    }
+    catch (err) {
+        if (!warnedMatcherMissing) {
+            warnedMatcherMissing = true;
+            console.warn(`[image-config] cannot load next/dist/shared/lib/match-remote-pattern (${err.message}) — falling back to deny-external-only mode`);
+        }
+        cachedMatcher = null;
+        return null;
+    }
+}
+/**
+ * 校验 /_next/image 的 url 是否被允许。语义对齐 Next:
+ * - 同源(host header === url 的 host,含端口)始终放行
+ * - unoptimized:true 跳过校验
+ * - 否则必须命中 domains 或 remotePatterns 之一
+ */
+function validateImageUrl(absoluteUrl, hostHeader) {
+    const cfg = loadImageConfig();
+    if (cfg.mode === 'config-missing') {
+        return { ok: true, reason: 'config-missing' };
+    }
+    const { images } = cfg;
+    if (images.unoptimized) {
+        return { ok: true, reason: 'unoptimized' };
+    }
+    // host header 通常带端口,absoluteUrl.hostname 不带 —— 用 url.host(含端口)
+    // 比较;同时小写化避免大小写差异。
+    const reqHost = hostHeader.toLowerCase();
+    const urlHost = absoluteUrl.host.toLowerCase();
+    if (reqHost && reqHost === urlHost) {
+        return { ok: true, reason: 'same-origin' };
+    }
+    const matcher = loadMatcher();
+    if (matcher === null) {
+        return { ok: false, reason: 'matcher-unavailable' };
+    }
+    if (matcher(images.domains, images.remotePatterns, absoluteUrl)) {
+        return { ok: true, reason: 'pattern-match' };
+    }
+    return { ok: false, reason: 'remote-pattern-not-matched' };
+}
+exports.validateImageUrl = validateImageUrl;
+/** 测试用:重置缓存。生产代码不调用。 */
+function _resetImageConfigCacheForTests() {
+    cachedConfig = undefined;
+    cachedMatcher = undefined;
+    warnedMatcherMissing = false;
+}
+exports._resetImageConfigCacheForTests = _resetImageConfigCacheForTests;
+/**
+ * 测试用:注入 matcher,绕过对真实 next 模块的 require。
+ * 传 null 模拟"matcher 不可用"分支。
+ */
+function _setMatcherForTests(impl) {
+    cachedMatcher = impl;
+}
+exports._setMatcherForTests = _setMatcherForTests;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-config.js","sourceRoot":"","sources":["../../src/runtime/image-config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * 解析 next.config.images 并校验 /_next/image 的 url 参数。\n *\n * 配置来源:OpenNext build 完成后会把解析后的完整 next.config 写到\n * <server-bundle>/.next/required-server-files.json,images 字段就是 Next 自己\n * 在运行时用的最终形态。直接读这个文件可以避开 next.config 的 TS/ESM/JS 三种\n * 形态解析,也无需在 build 阶段做额外抽取。\n *\n * 匹配算法:复用 Next 自己的 match-remote-pattern 模块——picomatch 的 glob\n * 语义边界(`**` 跨段、`*` 单段、`?`、`{a,b}`)自己重写很容易跟 next dev\n * 行为漂移。Next 必然在 server bundle 的 node_modules 里,运行时 require 即可。\n *\n * 边界行为(已与上层对齐):\n * - 校验失败 → 上层 400(对齐 Next 默认行为)\n * - required-server-files.json 缺失 → warn + 放行(兼容老产物,不阻断部署)\n * - images.unoptimized=true → 跳过校验、照常代发(用户关了 Next 优化但仍走\n *   wrapper,白名单职责让位给上游)\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\n\ninterface RemotePattern {\n  protocol?: 'http' | 'https';\n  hostname: string;\n  port?: string;\n  pathname?: string;\n  search?: string;\n}\n\ninterface ImagesConfig {\n  remotePatterns: RemotePattern[];\n  domains: string[];\n  unoptimized: boolean;\n}\n\ntype LoadedConfig =\n  | { mode: 'config-missing' }\n  | { mode: 'loaded'; images: ImagesConfig };\n\ntype MatcherImpl = (\n  domains: string[],\n  remotePatterns: RemotePattern[],\n  url: URL\n) => boolean;\n\nlet cachedConfig: LoadedConfig | undefined;\nlet cachedMatcher: MatcherImpl | null | undefined;\nlet warnedMatcherMissing = false;\n\n/**\n * 路径解析与 node-server.ts 的 assets 解析同源:wrapper 启动时\n * process.cwd() === server-functions/default/,所以 .next 就在 cwd 下。\n */\nfunction configFilePath(): string {\n  return path.resolve(process.cwd(), '.next', 'required-server-files.json');\n}\n\nfunction loadImageConfig(): LoadedConfig {\n  if (cachedConfig !== undefined) return cachedConfig;\n\n  const filePath = configFilePath();\n  let raw: string;\n  try {\n    raw = fs.readFileSync(filePath, 'utf-8');\n  } catch (err: any) {\n    console.warn(\n      `[image-config] required-server-files.json not found at ${filePath} — allowing all image URLs (${err.code ?? err.message})`\n    );\n    cachedConfig = { mode: 'config-missing' };\n    return cachedConfig;\n  }\n\n  try {\n    const parsed = JSON.parse(raw);\n    const images = parsed?.config?.images ?? {};\n    cachedConfig = {\n      mode: 'loaded',\n      images: {\n        remotePatterns: Array.isArray(images.remotePatterns)\n          ? images.remotePatterns\n          : [],\n        domains: Array.isArray(images.domains) ? images.domains : [],\n        unoptimized: images.unoptimized === true,\n      },\n    };\n    return cachedConfig;\n  } catch (err: any) {\n    console.warn(\n      `[image-config] failed to parse ${filePath}: ${err.message} — allowing all image URLs`\n    );\n    cachedConfig = { mode: 'config-missing' };\n    return cachedConfig;\n  }\n}\n\n/**\n * 拿 Next 自己的 hasRemoteMatch。失败一次后缓存 null,后续走严格 deny 分支。\n * 用 eval('require') 让 esbuild 不去尝试解析 next 模块——wrapper bundle 由\n * scripts/bundle-overrides.js 用 esbuild 打包,把 next 标了 external 是 belt-\n * and-suspenders;eval 这一层确保即便 external 配错也打不进 bundle。\n */\nfunction loadMatcher(): MatcherImpl | null {\n  if (cachedMatcher !== undefined) return cachedMatcher;\n  try {\n    const dynamicRequire = eval('require') as NodeRequire;\n    const mod = dynamicRequire('next/dist/shared/lib/match-remote-pattern');\n    const hasRemoteMatch = mod?.hasRemoteMatch;\n    if (typeof hasRemoteMatch !== 'function') {\n      throw new Error('hasRemoteMatch not exported');\n    }\n    cachedMatcher = hasRemoteMatch as MatcherImpl;\n    return cachedMatcher;\n  } catch (err: any) {\n    if (!warnedMatcherMissing) {\n      warnedMatcherMissing = true;\n      console.warn(\n        `[image-config] cannot load next/dist/shared/lib/match-remote-pattern (${err.message}) — falling back to deny-external-only mode`\n      );\n    }\n    cachedMatcher = null;\n    return null;\n  }\n}\n\nexport interface ValidateResult {\n  ok: boolean;\n  reason?: string;\n}\n\n/**\n * 校验 /_next/image 的 url 是否被允许。语义对齐 Next:\n * - 同源(host header === url 的 host,含端口)始终放行\n * - unoptimized:true 跳过校验\n * - 否则必须命中 domains 或 remotePatterns 之一\n */\nexport function validateImageUrl(\n  absoluteUrl: URL,\n  hostHeader: string\n): ValidateResult {\n  const cfg = loadImageConfig();\n  if (cfg.mode === 'config-missing') {\n    return { ok: true, reason: 'config-missing' };\n  }\n\n  const { images } = cfg;\n  if (images.unoptimized) {\n    return { ok: true, reason: 'unoptimized' };\n  }\n\n  // host header 通常带端口,absoluteUrl.hostname 不带 —— 用 url.host(含端口)\n  // 比较;同时小写化避免大小写差异。\n  const reqHost = hostHeader.toLowerCase();\n  const urlHost = absoluteUrl.host.toLowerCase();\n  if (reqHost && reqHost === urlHost) {\n    return { ok: true, reason: 'same-origin' };\n  }\n\n  const matcher = loadMatcher();\n  if (matcher === null) {\n    return { ok: false, reason: 'matcher-unavailable' };\n  }\n  if (matcher(images.domains, images.remotePatterns, absoluteUrl)) {\n    return { ok: true, reason: 'pattern-match' };\n  }\n  return { ok: false, reason: 'remote-pattern-not-matched' };\n}\n\n/** 测试用:重置缓存。生产代码不调用。 */\nexport function _resetImageConfigCacheForTests(): void {\n  cachedConfig = undefined;\n  cachedMatcher = undefined;\n  warnedMatcherMissing = false;\n}\n\n/**\n * 测试用:注入 matcher,绕过对真实 next 模块的 require。\n * 传 null 模拟\"matcher 不可用\"分支。\n */\nexport function _setMatcherForTests(impl: MatcherImpl | null): void {\n  cachedMatcher = impl;\n}\n"]}

package/dist/runtime/image-proxy.d.ts

@@ -1,16 +1,17 @@
 /**
  * 图片优化代理（FC 内执行）
  *
- * 浏览器 GET /_pcg/image/optimize?url=...&w=...&q=... → ESA → FC（本模块）
+ * 浏览器 GET /_next/image?url=...&w=...&q=... → ESA → FC（本模块）
  * → 用 gatewayFetch 注入签名 4 header → Gateway /image/optimize
  * → 流式 pipe 响应回浏览器（Cache-Control / ETag / Vary 等头透传）
  *
  * `<img>` 标签发不出自定义 header，由 FC 在这里代发签名请求 —— 这是方案三的核心。
+ * 拦截 Next 内置的 /_next/image 路由,用户 next.config 无需配 custom loader。
  */
 /// <reference types="node" />
 import * as http from 'http';
 /**
- * 处理一个 /_pcg/image/optimize 请求。
+ * 处理一个 /_next/image 请求。
  * 由 node-server wrapper 在路径匹配后调用。
  */
 export declare function handleImageProxy(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;

package/dist/runtime/image-proxy.js

@@ -2,16 +2,18 @@
 /**
  * 图片优化代理（FC 内执行）
  *
- * 浏览器 GET /_pcg/image/optimize?url=...&w=...&q=... → ESA → FC（本模块）
+ * 浏览器 GET /_next/image?url=...&w=...&q=... → ESA → FC（本模块）
  * → 用 gatewayFetch 注入签名 4 header → Gateway /image/optimize
  * → 流式 pipe 响应回浏览器（Cache-Control / ETag / Vary 等头透传）
  *
  * `<img>` 标签发不出自定义 header，由 FC 在这里代发签名请求 —— 这是方案三的核心。
+ * 拦截 Next 内置的 /_next/image 路由,用户 next.config 无需配 custom loader。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleImageProxy = void 0;
 const stream_1 = require("stream");
 const gateway_auth_1 = require("./gateway-auth");
+const image_config_1 = require("./image-config");
 const GATEWAY_TIMEOUT_MS = 10000;
 /** 透传给浏览器的响应头白名单（避免泄露 Gateway 内部 header） */
 const PASSTHROUGH_HEADERS = [
@@ -48,7 +50,7 @@ function writeJson(res, status, body) {
     res.end(JSON.stringify(body));
 }
 /**
- * 处理一个 /_pcg/image/optimize 请求。
+ * 处理一个 /_next/image 请求。
  * 由 node-server wrapper 在路径匹配后调用。
  */
 async function handleImageProxy(req, res) {
@@ -74,6 +76,19 @@ async function handleImageProxy(req, res) {
             error: 'Cannot resolve absolute URL: missing Host header',
         });
     }
+    // 按 next.config.images.{remotePatterns,domains} 校验 —— 与 next dev 行为对齐
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(absoluteUrl);
+    }
+    catch (_a) {
+        return writeJson(res, 400, { error: 'Invalid url parameter' });
+    }
+    const hostHeader = req.headers['host'] || '';
+    const verdict = (0, image_config_1.validateImageUrl)(parsedUrl, hostHeader);
+    if (!verdict.ok) {
+        return writeJson(res, 400, { error: 'url not allowed' });
+    }
     // 加载签名配置
     const cfg = (0, gateway_auth_1.loadGatewayAuthConfig)();
     if (!cfg) {
@@ -146,4 +161,4 @@ async function handleImageProxy(req, res) {
     }
 }
 exports.handleImageProxy = handleImageProxy;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-proxy.js","sourceRoot":"","sources":["../../src/runtime/image-proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * 图片优化代理（FC 内执行）\n *\n * 浏览器 GET /_pcg/image/optimize?url=...&w=...&q=... → ESA → FC（本模块）\n * → 用 gatewayFetch 注入签名 4 header → Gateway /image/optimize\n * → 流式 pipe 响应回浏览器（Cache-Control / ETag / Vary 等头透传）\n *\n * `<img>` 标签发不出自定义 header，由 FC 在这里代发签名请求 —— 这是方案三的核心。\n */\n\nimport * as http from 'http';\nimport { Readable } from 'stream';\nimport { loadGatewayAuthConfig, gatewayFetch } from './gateway-auth';\n\nconst GATEWAY_TIMEOUT_MS = 10_000;\n\n/** 透传给浏览器的响应头白名单（避免泄露 Gateway 内部 header） */\nconst PASSTHROUGH_HEADERS = [\n  'content-type',\n  'content-length',\n  'cache-control',\n  'etag',\n  'vary',\n  'last-modified',\n  'content-security-policy',\n];\n\n/**\n * 把请求 URL 中的 `url=` 参数标准化成绝对 URL。\n * - 已经是 http(s):// → 原样\n * - 否则用 `${proto}://${host}${url}` 拼接，proto 取 x-forwarded-proto，否则 https\n */\nfunction resolveAbsoluteUrl(\n  rawUrl: string,\n  req: http.IncomingMessage\n): string | null {\n  if (rawUrl.startsWith('http://') || rawUrl.startsWith('https://')) {\n    return rawUrl;\n  }\n  const host = req.headers['host'];\n  if (!host) return null;\n  const protoHeader = req.headers['x-forwarded-proto'];\n  const proto =\n    (Array.isArray(protoHeader) ? protoHeader[0] : protoHeader) ||\n    (Array.isArray(protoHeader) ? protoHeader[0] : protoHeader) ||\n    'https';\n  const path = rawUrl.startsWith('/') ? rawUrl : `/${rawUrl}`;\n  return `${proto}://${host}${path}`;\n}\n\nfunction writeJson(res: http.ServerResponse, status: number, body: any): void {\n  res.statusCode = status;\n  res.setHeader('Content-Type', 'application/json; charset=utf-8');\n  res.end(JSON.stringify(body));\n}\n\n/**\n * 处理一个 /_pcg/image/optimize 请求。\n * 由 node-server wrapper 在路径匹配后调用。\n */\nexport async function handleImageProxy(\n  req: http.IncomingMessage,\n  res: http.ServerResponse\n): Promise<void> {\n  // 解析 query\n  const reqUrl = req.url || '';\n  const qIdx = reqUrl.indexOf('?');\n  if (qIdx === -1) {\n    return writeJson(res, 400, { error: 'Missing query parameters' });\n  }\n  const params = new URLSearchParams(reqUrl.slice(qIdx + 1));\n  const rawUrl = params.get('url');\n  const w = params.get('w');\n  const q = params.get('q');\n\n  if (!rawUrl || !w) {\n    return writeJson(res, 400, {\n      error: 'Missing required parameters: url, w',\n    });\n  }\n\n  // 标准化 url 参数为绝对 URL\n  const absoluteUrl = resolveAbsoluteUrl(rawUrl, req);\n  if (!absoluteUrl) {\n    return writeJson(res, 500, {\n      error: 'Cannot resolve absolute URL: missing Host header',\n    });\n  }\n\n  // 加载签名配置\n  const cfg = loadGatewayAuthConfig();\n  if (!cfg) {\n    return writeJson(res, 500, {\n      error: 'Gateway auth config missing',\n    });\n  }\n\n  // 构造 Gateway 请求路径\n  const upstreamParams = new URLSearchParams({ url: absoluteUrl, w });\n  if (q) upstreamParams.set('q', q);\n  const upstreamPath = `/image/optimize?${upstreamParams}`;\n\n  // 透传 If-None-Match 让 Gateway 走 304\n  const ifNoneMatch = req.headers['if-none-match'];\n  const upstreamHeaders: Record<string, string> = {};\n  if (typeof ifNoneMatch === 'string') {\n    upstreamHeaders['if-none-match'] = ifNoneMatch;\n  }\n  const accept = req.headers['accept'];\n  if (typeof accept === 'string') {\n    upstreamHeaders['accept'] = accept;\n  }\n\n  let upstream: Response;\n  try {\n    upstream = await gatewayFetch(cfg, upstreamPath, {\n      method: 'GET',\n      headers: upstreamHeaders,\n      timeoutMs: GATEWAY_TIMEOUT_MS,\n    });\n  } catch (err: any) {\n    if (err.name === 'AbortError') {\n      console.warn(\n        `[image-proxy] Gateway timeout after ${GATEWAY_TIMEOUT_MS}ms: ${absoluteUrl}`\n      );\n      return writeJson(res, 504, { error: 'Upstream timeout' });\n    }\n    console.warn(\n      `[image-proxy] Gateway fetch error: ${err.message} (url=${absoluteUrl})`\n    );\n    return writeJson(res, 502, { error: 'Bad gateway' });\n  }\n\n  // 透传状态码 + 白名单 header\n  res.statusCode = upstream.status;\n  for (const name of PASSTHROUGH_HEADERS) {\n    const value = upstream.headers.get(name);\n    if (value !== null) {\n      res.setHeader(name, value);\n    }\n  }\n\n  // 304 / 无 body 直接结束\n  if (upstream.status === 304 || !upstream.body) {\n    res.end();\n    return;\n  }\n\n  // 流式 pipe（避免大图 buffer 占内存）\n  try {\n    const nodeStream = Readable.fromWeb(upstream.body as any);\n    nodeStream.on('error', err => {\n      console.warn(`[image-proxy] Stream error: ${err.message}`);\n      if (!res.writableEnded) res.end();\n    });\n    nodeStream.pipe(res);\n  } catch (err: any) {\n    console.warn(`[image-proxy] Pipe setup failed: ${err.message}`);\n    if (!res.headersSent) {\n      writeJson(res, 502, { error: 'Stream setup failed' });\n    } else if (!res.writableEnded) {\n      res.end();\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-proxy.js","sourceRoot":"","sources":["../../src/runtime/image-proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * 图片优化代理（FC 内执行）\n *\n * 浏览器 GET /_next/image?url=...&w=...&q=... → ESA → FC（本模块）\n * → 用 gatewayFetch 注入签名 4 header → Gateway /image/optimize\n * → 流式 pipe 响应回浏览器（Cache-Control / ETag / Vary 等头透传）\n *\n * `<img>` 标签发不出自定义 header，由 FC 在这里代发签名请求 —— 这是方案三的核心。\n * 拦截 Next 内置的 /_next/image 路由,用户 next.config 无需配 custom loader。\n */\n\nimport * as http from 'http';\nimport { Readable } from 'stream';\nimport { loadGatewayAuthConfig, gatewayFetch } from './gateway-auth';\nimport { validateImageUrl } from './image-config';\n\nconst GATEWAY_TIMEOUT_MS = 10_000;\n\n/** 透传给浏览器的响应头白名单（避免泄露 Gateway 内部 header） */\nconst PASSTHROUGH_HEADERS = [\n  'content-type',\n  'content-length',\n  'cache-control',\n  'etag',\n  'vary',\n  'last-modified',\n  'content-security-policy',\n];\n\n/**\n * 把请求 URL 中的 `url=` 参数标准化成绝对 URL。\n * - 已经是 http(s):// → 原样\n * - 否则用 `${proto}://${host}${url}` 拼接，proto 取 x-forwarded-proto，否则 https\n */\nfunction resolveAbsoluteUrl(\n  rawUrl: string,\n  req: http.IncomingMessage\n): string | null {\n  if (rawUrl.startsWith('http://') || rawUrl.startsWith('https://')) {\n    return rawUrl;\n  }\n  const host = req.headers['host'];\n  if (!host) return null;\n  const protoHeader = req.headers['x-forwarded-proto'];\n  const proto =\n    (Array.isArray(protoHeader) ? protoHeader[0] : protoHeader) ||\n    (Array.isArray(protoHeader) ? protoHeader[0] : protoHeader) ||\n    'https';\n  const path = rawUrl.startsWith('/') ? rawUrl : `/${rawUrl}`;\n  return `${proto}://${host}${path}`;\n}\n\nfunction writeJson(res: http.ServerResponse, status: number, body: any): void {\n  res.statusCode = status;\n  res.setHeader('Content-Type', 'application/json; charset=utf-8');\n  res.end(JSON.stringify(body));\n}\n\n/**\n * 处理一个 /_next/image 请求。\n * 由 node-server wrapper 在路径匹配后调用。\n */\nexport async function handleImageProxy(\n  req: http.IncomingMessage,\n  res: http.ServerResponse\n): Promise<void> {\n  // 解析 query\n  const reqUrl = req.url || '';\n  const qIdx = reqUrl.indexOf('?');\n  if (qIdx === -1) {\n    return writeJson(res, 400, { error: 'Missing query parameters' });\n  }\n  const params = new URLSearchParams(reqUrl.slice(qIdx + 1));\n  const rawUrl = params.get('url');\n  const w = params.get('w');\n  const q = params.get('q');\n\n  if (!rawUrl || !w) {\n    return writeJson(res, 400, {\n      error: 'Missing required parameters: url, w',\n    });\n  }\n\n  // 标准化 url 参数为绝对 URL\n  const absoluteUrl = resolveAbsoluteUrl(rawUrl, req);\n  if (!absoluteUrl) {\n    return writeJson(res, 500, {\n      error: 'Cannot resolve absolute URL: missing Host header',\n    });\n  }\n\n  // 按 next.config.images.{remotePatterns,domains} 校验 —— 与 next dev 行为对齐\n  let parsedUrl: URL;\n  try {\n    parsedUrl = new URL(absoluteUrl);\n  } catch {\n    return writeJson(res, 400, { error: 'Invalid url parameter' });\n  }\n  const hostHeader = (req.headers['host'] as string) || '';\n  const verdict = validateImageUrl(parsedUrl, hostHeader);\n  if (!verdict.ok) {\n    return writeJson(res, 400, { error: 'url not allowed' });\n  }\n\n  // 加载签名配置\n  const cfg = loadGatewayAuthConfig();\n  if (!cfg) {\n    return writeJson(res, 500, {\n      error: 'Gateway auth config missing',\n    });\n  }\n\n  // 构造 Gateway 请求路径\n  const upstreamParams = new URLSearchParams({ url: absoluteUrl, w });\n  if (q) upstreamParams.set('q', q);\n  const upstreamPath = `/image/optimize?${upstreamParams}`;\n\n  // 透传 If-None-Match 让 Gateway 走 304\n  const ifNoneMatch = req.headers['if-none-match'];\n  const upstreamHeaders: Record<string, string> = {};\n  if (typeof ifNoneMatch === 'string') {\n    upstreamHeaders['if-none-match'] = ifNoneMatch;\n  }\n  const accept = req.headers['accept'];\n  if (typeof accept === 'string') {\n    upstreamHeaders['accept'] = accept;\n  }\n\n  let upstream: Response;\n  try {\n    upstream = await gatewayFetch(cfg, upstreamPath, {\n      method: 'GET',\n      headers: upstreamHeaders,\n      timeoutMs: GATEWAY_TIMEOUT_MS,\n    });\n  } catch (err: any) {\n    if (err.name === 'AbortError') {\n      console.warn(\n        `[image-proxy] Gateway timeout after ${GATEWAY_TIMEOUT_MS}ms: ${absoluteUrl}`\n      );\n      return writeJson(res, 504, { error: 'Upstream timeout' });\n    }\n    console.warn(\n      `[image-proxy] Gateway fetch error: ${err.message} (url=${absoluteUrl})`\n    );\n    return writeJson(res, 502, { error: 'Bad gateway' });\n  }\n\n  // 透传状态码 + 白名单 header\n  res.statusCode = upstream.status;\n  for (const name of PASSTHROUGH_HEADERS) {\n    const value = upstream.headers.get(name);\n    if (value !== null) {\n      res.setHeader(name, value);\n    }\n  }\n\n  // 304 / 无 body 直接结束\n  if (upstream.status === 304 || !upstream.body) {\n    res.end();\n    return;\n  }\n\n  // 流式 pipe（避免大图 buffer 占内存）\n  try {\n    const nodeStream = Readable.fromWeb(upstream.body as any);\n    nodeStream.on('error', err => {\n      console.warn(`[image-proxy] Stream error: ${err.message}`);\n      if (!res.writableEnded) res.end();\n    });\n    nodeStream.pipe(res);\n  } catch (err: any) {\n    console.warn(`[image-proxy] Pipe setup failed: ${err.message}`);\n    if (!res.headersSent) {\n      writeJson(res, 502, { error: 'Stream setup failed' });\n    } else if (!res.writableEnded) {\n      res.end();\n    }\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esa-pcg-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "CLI for building and deploying Next.js apps onto pages-cache-gateway (PCG)",
   "keywords": [
     "next",
@@ -19,7 +19,6 @@
   },
   "files": [
     "dist",
-    "runtime",
     "README.md",
     "LICENSE"
   ],
@@ -42,4 +41,4 @@
     "typescript": "~4.8.0"
   },
   "repository": "git@gitlab.alibaba-inc.com:edge-routine-tools/pages-cache-gateway.git"
-}
+}