esa-pcg-cli 0.1.2 → 0.1.4

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":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAEH,yBAAyB;AACzB,6BAA6B;AA0B7B,IAAI,YAAsC,CAAC;AAC3C,IAAI,aAA6C,CAAC;AAClD,IAAI,oBAAoB,GAAG,KAAK,CAAC;AAEjC;;;GAGG;AACH,SAAS,cAAc;IACrB,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,4BAA4B,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,eAAe;;IACtB,IAAI,YAAY,KAAK,SAAS;QAAE,OAAO,YAAY,CAAC;IAEpD,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAC;IAClC,IAAI,GAAW,CAAC;IAChB,IAAI;QACF,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;KAC1C;IAAC,OAAO,GAAQ,EAAE;QACjB,OAAO,CAAC,IAAI,CACV,0DAA0D,QAAQ,+BAA+B,MAAA,GAAG,CAAC,IAAI,mCAAI,GAAG,CAAC,OAAO,GAAG,CAC5H,CAAC;QACF,YAAY,GAAG,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;QAC1C,OAAO,YAAY,CAAC;KACrB;IAED,IAAI;QACF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,MAAM,GAAG,MAAA,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,MAAM,0CAAE,MAAM,mCAAI,EAAE,CAAC;QAC5C,YAAY,GAAG;YACb,IAAI,EAAE,QAAQ;YACd,MAAM,EAAE;gBACN,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC;oBAClD,CAAC,CAAC,MAAM,CAAC,cAAc;oBACvB,CAAC,CAAC,EAAE;gBACN,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC5D,WAAW,EAAE,MAAM,CAAC,WAAW,KAAK,IAAI;aACzC;SACF,CAAC;QACF,OAAO,YAAY,CAAC;KACrB;IAAC,OAAO,GAAQ,EAAE;QACjB,OAAO,CAAC,IAAI,CACV,kCAAkC,QAAQ,KAAK,GAAG,CAAC,OAAO,4BAA4B,CACvF,CAAC;QACF,YAAY,GAAG,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC;QAC1C,OAAO,YAAY,CAAC;KACrB;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW;IAClB,IAAI,aAAa,KAAK,SAAS;QAAE,OAAO,aAAa,CAAC;IACtD,IAAI;QACF,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAgB,CAAC;QACtD,MAAM,GAAG,GAAG,cAAc,CAAC,2CAA2C,CAAC,CAAC;QACxE,MAAM,cAAc,GAAG,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,cAAc,CAAC;QAC3C,IAAI,OAAO,cAAc,KAAK,UAAU,EAAE;YACxC,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;SAChD;QACD,aAAa,GAAG,cAA6B,CAAC;QAC9C,OAAO,aAAa,CAAC;KACtB;IAAC,OAAO,GAAQ,EAAE;QACjB,IAAI,CAAC,oBAAoB,EAAE;YACzB,oBAAoB,GAAG,IAAI,CAAC;YAC5B,OAAO,CAAC,IAAI,CACV,yEAAyE,GAAG,CAAC,OAAO,6CAA6C,CAClI,CAAC;SACH;QACD,aAAa,GAAG,IAAI,CAAC;QACrB,OAAO,IAAI,CAAC;KACb;AACH,CAAC;AAOD;;;;;GAKG;AACH,SAAgB,gBAAgB,CAC9B,WAAgB,EAChB,UAAkB;IAElB,MAAM,GAAG,GAAG,eAAe,EAAE,CAAC;IAC9B,IAAI,GAAG,CAAC,IAAI,KAAK,gBAAgB,EAAE;QACjC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;KAC/C;IAED,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;IACvB,IAAI,MAAM,CAAC,WAAW,EAAE;QACtB,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;KAC5C;IAED,+DAA+D;IAC/D,mBAAmB;IACnB,MAAM,OAAO,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;IACzC,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;IAC/C,IAAI,OAAO,IAAI,OAAO,KAAK,OAAO,EAAE;QAClC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;KAC5C;IAED,MAAM,OAAO,GAAG,WAAW,EAAE,CAAC;IAC9B,IAAI,OAAO,KAAK,IAAI,EAAE;QACpB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,CAAC;KACrD;IACD,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC,EAAE;QAC/D,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;KAC9C;IACD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,4BAA4B,EAAE,CAAC;AAC7D,CAAC;AA9BD,4CA8BC;AAED,wBAAwB;AACxB,SAAgB,8BAA8B;IAC5C,YAAY,GAAG,SAAS,CAAC;IACzB,aAAa,GAAG,SAAS,CAAC;IAC1B,oBAAoB,GAAG,KAAK,CAAC;AAC/B,CAAC;AAJD,wEAIC;AAED;;;GAGG;AACH,SAAgB,mBAAmB,CAAC,IAAwB;IAC1D,aAAa,GAAG,IAAI,CAAC;AACvB,CAAC;AAFD,kDAEC","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.js

@@ -13,6 +13,7 @@ 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 = [
@@ -75,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) {
@@ -147,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 /_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';\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  // 加载签名配置\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.2",
+  "version": "0.1.4",
   "description": "CLI for building and deploying Next.js apps onto pages-cache-gateway (PCG)",
   "keywords": [
     "next",