esa-pcg-cli 0.1.0

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

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

package/dist/runtime/image-proxy.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * 图片优化代理（FC 内执行）
+ *
+ * 浏览器 GET /_pcg/image/optimize?url=...&w=...&q=... → ESA → FC（本模块）
+ * → 用 gatewayFetch 注入签名 4 header → Gateway /image/optimize
+ * → 流式 pipe 响应回浏览器（Cache-Control / ETag / Vary 等头透传）
+ *
+ * `<img>` 标签发不出自定义 header，由 FC 在这里代发签名请求 —— 这是方案三的核心。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleImageProxy = void 0;
+const stream_1 = require("stream");
+const gateway_auth_1 = require("./gateway-auth");
+const GATEWAY_TIMEOUT_MS = 10000;
+/** 透传给浏览器的响应头白名单（避免泄露 Gateway 内部 header） */
+const PASSTHROUGH_HEADERS = [
+    'content-type',
+    'content-length',
+    'cache-control',
+    'etag',
+    'vary',
+    'last-modified',
+    'content-security-policy',
+];
+/**
+ * 把请求 URL 中的 `url=` 参数标准化成绝对 URL。
+ * - 已经是 http(s):// → 原样
+ * - 否则用 `${proto}://${host}${url}` 拼接，proto 取 x-forwarded-proto，否则 https
+ */
+function resolveAbsoluteUrl(rawUrl, req) {
+    if (rawUrl.startsWith('http://') || rawUrl.startsWith('https://')) {
+        return rawUrl;
+    }
+    const host = req.headers['host'];
+    if (!host)
+        return null;
+    const protoHeader = req.headers['x-forwarded-proto'];
+    const proto = (Array.isArray(protoHeader) ? protoHeader[0] : protoHeader) ||
+        (Array.isArray(protoHeader) ? protoHeader[0] : protoHeader) ||
+        'https';
+    const path = rawUrl.startsWith('/') ? rawUrl : `/${rawUrl}`;
+    return `${proto}://${host}${path}`;
+}
+function writeJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify(body));
+}
+/**
+ * 处理一个 /_pcg/image/optimize 请求。
+ * 由 node-server wrapper 在路径匹配后调用。
+ */
+async function handleImageProxy(req, res) {
+    // 解析 query
+    const reqUrl = req.url || '';
+    const qIdx = reqUrl.indexOf('?');
+    if (qIdx === -1) {
+        return writeJson(res, 400, { error: 'Missing query parameters' });
+    }
+    const params = new URLSearchParams(reqUrl.slice(qIdx + 1));
+    const rawUrl = params.get('url');
+    const w = params.get('w');
+    const q = params.get('q');
+    if (!rawUrl || !w) {
+        return writeJson(res, 400, {
+            error: 'Missing required parameters: url, w',
+        });
+    }
+    // 标准化 url 参数为绝对 URL
+    const absoluteUrl = resolveAbsoluteUrl(rawUrl, req);
+    if (!absoluteUrl) {
+        return writeJson(res, 500, {
+            error: 'Cannot resolve absolute URL: missing Host header',
+        });
+    }
+    // 加载签名配置
+    const cfg = (0, gateway_auth_1.loadGatewayAuthConfig)();
+    if (!cfg) {
+        return writeJson(res, 500, {
+            error: 'Gateway auth config missing',
+        });
+    }
+    // 构造 Gateway 请求路径
+    const upstreamParams = new URLSearchParams({ url: absoluteUrl, w });
+    if (q)
+        upstreamParams.set('q', q);
+    const upstreamPath = `/image/optimize?${upstreamParams}`;
+    // 透传 If-None-Match 让 Gateway 走 304
+    const ifNoneMatch = req.headers['if-none-match'];
+    const upstreamHeaders = {};
+    if (typeof ifNoneMatch === 'string') {
+        upstreamHeaders['if-none-match'] = ifNoneMatch;
+    }
+    const accept = req.headers['accept'];
+    if (typeof accept === 'string') {
+        upstreamHeaders['accept'] = accept;
+    }
+    let upstream;
+    try {
+        upstream = await (0, gateway_auth_1.gatewayFetch)(cfg, upstreamPath, {
+            method: 'GET',
+            headers: upstreamHeaders,
+            timeoutMs: GATEWAY_TIMEOUT_MS,
+        });
+    }
+    catch (err) {
+        if (err.name === 'AbortError') {
+            console.warn(`[image-proxy] Gateway timeout after ${GATEWAY_TIMEOUT_MS}ms: ${absoluteUrl}`);
+            return writeJson(res, 504, { error: 'Upstream timeout' });
+        }
+        console.warn(`[image-proxy] Gateway fetch error: ${err.message} (url=${absoluteUrl})`);
+        return writeJson(res, 502, { error: 'Bad gateway' });
+    }
+    // 透传状态码 + 白名单 header
+    res.statusCode = upstream.status;
+    for (const name of PASSTHROUGH_HEADERS) {
+        const value = upstream.headers.get(name);
+        if (value !== null) {
+            res.setHeader(name, value);
+        }
+    }
+    // 304 / 无 body 直接结束
+    if (upstream.status === 304 || !upstream.body) {
+        res.end();
+        return;
+    }
+    // 流式 pipe（避免大图 buffer 占内存）
+    try {
+        const nodeStream = stream_1.Readable.fromWeb(upstream.body);
+        nodeStream.on('error', err => {
+            console.warn(`[image-proxy] Stream error: ${err.message}`);
+            if (!res.writableEnded)
+                res.end();
+        });
+        nodeStream.pipe(res);
+    }
+    catch (err) {
+        console.warn(`[image-proxy] Pipe setup failed: ${err.message}`);
+        if (!res.headersSent) {
+            writeJson(res, 502, { error: 'Stream setup failed' });
+        }
+        else if (!res.writableEnded) {
+            res.end();
+        }
+    }
+}
+exports.handleImageProxy = handleImageProxy;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-proxy.js","sourceRoot":"","sources":["../../src/runtime/image-proxy.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAGH,mCAAkC;AAClC,iDAAqE;AAErE,MAAM,kBAAkB,GAAG,KAAM,CAAC;AAElC,4CAA4C;AAC5C,MAAM,mBAAmB,GAAG;IAC1B,cAAc;IACd,gBAAgB;IAChB,eAAe;IACf,MAAM;IACN,MAAM;IACN,eAAe;IACf,yBAAyB;CAC1B,CAAC;AAEF;;;;GAIG;AACH,SAAS,kBAAkB,CACzB,MAAc,EACd,GAAyB;IAEzB,IAAI,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;QACjE,OAAO,MAAM,CAAC;KACf;IACD,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACvB,MAAM,WAAW,GAAG,GAAG,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrD,MAAM,KAAK,GACT,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QAC3D,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;QAC3D,OAAO,CAAC;IACV,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC;IAC5D,OAAO,GAAG,KAAK,MAAM,IAAI,GAAG,IAAI,EAAE,CAAC;AACrC,CAAC;AAED,SAAS,SAAS,CAAC,GAAwB,EAAE,MAAc,EAAE,IAAS;IACpE,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC;IACxB,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,iCAAiC,CAAC,CAAC;IACjE,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;AAChC,CAAC;AAED;;;GAGG;AACI,KAAK,UAAU,gBAAgB,CACpC,GAAyB,EACzB,GAAwB;IAExB,WAAW;IACX,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC;IAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,IAAI,KAAK,CAAC,CAAC,EAAE;QACf,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,0BAA0B,EAAE,CAAC,CAAC;KACnE;IACD,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3D,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1B,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAE1B,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,EAAE;QACjB,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE;YACzB,KAAK,EAAE,qCAAqC;SAC7C,CAAC,CAAC;KACJ;IAED,oBAAoB;IACpB,MAAM,WAAW,GAAG,kBAAkB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACpD,IAAI,CAAC,WAAW,EAAE;QAChB,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE;YACzB,KAAK,EAAE,kDAAkD;SAC1D,CAAC,CAAC;KACJ;IAED,SAAS;IACT,MAAM,GAAG,GAAG,IAAA,oCAAqB,GAAE,CAAC;IACpC,IAAI,CAAC,GAAG,EAAE;QACR,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE;YACzB,KAAK,EAAE,6BAA6B;SACrC,CAAC,CAAC;KACJ;IAED,kBAAkB;IAClB,MAAM,cAAc,GAAG,IAAI,eAAe,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;IACpE,IAAI,CAAC;QAAE,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAClC,MAAM,YAAY,GAAG,mBAAmB,cAAc,EAAE,CAAC;IAEzD,mCAAmC;IACnC,MAAM,WAAW,GAAG,GAAG,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IACjD,MAAM,eAAe,GAA2B,EAAE,CAAC;IACnD,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE;QACnC,eAAe,CAAC,eAAe,CAAC,GAAG,WAAW,CAAC;KAChD;IACD,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACrC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;QAC9B,eAAe,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;KACpC;IAED,IAAI,QAAkB,CAAC;IACvB,IAAI;QACF,QAAQ,GAAG,MAAM,IAAA,2BAAY,EAAC,GAAG,EAAE,YAAY,EAAE;YAC/C,MAAM,EAAE,KAAK;YACb,OAAO,EAAE,eAAe;YACxB,SAAS,EAAE,kBAAkB;SAC9B,CAAC,CAAC;KACJ;IAAC,OAAO,GAAQ,EAAE;QACjB,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,EAAE;YAC7B,OAAO,CAAC,IAAI,CACV,uCAAuC,kBAAkB,OAAO,WAAW,EAAE,CAC9E,CAAC;YACF,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC,CAAC;SAC3D;QACD,OAAO,CAAC,IAAI,CACV,sCAAsC,GAAG,CAAC,OAAO,SAAS,WAAW,GAAG,CACzE,CAAC;QACF,OAAO,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CAAC;KACtD;IAED,qBAAqB;IACrB,GAAG,CAAC,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC;IACjC,KAAK,MAAM,IAAI,IAAI,mBAAmB,EAAE;QACtC,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,KAAK,KAAK,IAAI,EAAE;YAClB,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SAC5B;KACF;IAED,oBAAoB;IACpB,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;QAC7C,GAAG,CAAC,GAAG,EAAE,CAAC;QACV,OAAO;KACR;IAED,2BAA2B;IAC3B,IAAI;QACF,MAAM,UAAU,GAAG,iBAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAW,CAAC,CAAC;QAC1D,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE;YAC3B,OAAO,CAAC,IAAI,CAAC,+BAA+B,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YAC3D,IAAI,CAAC,GAAG,CAAC,aAAa;gBAAE,GAAG,CAAC,GAAG,EAAE,CAAC;QACpC,CAAC,CAAC,CAAC;QACH,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;KACtB;IAAC,OAAO,GAAQ,EAAE;QACjB,OAAO,CAAC,IAAI,CAAC,oCAAoC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE;YACpB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,qBAAqB,EAAE,CAAC,CAAC;SACvD;aAAM,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE;YAC7B,GAAG,CAAC,GAAG,EAAE,CAAC;SACX;KACF;AACH,CAAC;AAxGD,4CAwGC","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"]}

package/dist/util/fs.d.ts

@@ -0,0 +1,3 @@
+export declare function walkDir(dir: string): Promise<string[]>;
+export declare function dirExists(dir: string): Promise<boolean>;
+export declare function readJsonFile<T = unknown>(filePath: string): Promise<T>;

package/dist/util/fs.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJsonFile = exports.dirExists = exports.walkDir = void 0;
+const fs = require("fs/promises");
+const path = require("path");
+async function walkDir(dir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await walk(dir);
+    return files;
+}
+exports.walkDir = walkDir;
+async function dirExists(dir) {
+    try {
+        const stat = await fs.stat(dir);
+        return stat.isDirectory();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.dirExists = dirExists;
+async function readJsonFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return JSON.parse(content);
+}
+exports.readJsonFile = readJsonFile;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "esa-pcg-cli",
+  "version": "0.1.0",
+  "description": "CLI for building and deploying Next.js apps onto pages-cache-gateway (PCG)",
+  "keywords": [
+    "next",
+    "nextjs",
+    "opennext",
+    "cache",
+    "edge",
+    "deploy",
+    "pages-cache-gateway",
+    "pcg"
+  ],
+  "license": "MIT",
+  "main": "dist/bin/cli.js",
+  "bin": {
+    "pcg": "./dist/bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "runtime",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node scripts/inline-protocol.js && node scripts/bundle-overrides.js",
+    "prepublishOnly": "npm run build",
+    "test": "jest --config jest.config.js"
+  },
+  "dependencies": {
+    "ali-oss": "^6.23.0",
+    "commander": "^12.0.0"
+  },
+  "peerDependencies": {
+    "@opennextjs/aws": "^3.10.4"
+  },
+  "devDependencies": {
+    "@opennextjs/aws": "^3.10.4",
+    "@types/ali-oss": "^6.23.3",
+    "@types/jest": "^29.2.0",
+    "esbuild": "^0.25.4",
+    "jest": "^29.2.2",
+    "ts-jest": "^29.0.3",
+    "typescript": "~4.8.0"
+  }
+}

package/runtime/pcg-image-loader.js

@@ -0,0 +1,13 @@
+// Shipped with esa-pcg-cli. `pcg build` copies this file into
+// <projectDir>/node_modules/.pcg/, so next.config can reference it as
+// 'node_modules/.pcg/pcg-image-loader.js' without writing into the user's
+// source tree and without declaring esa-pcg-cli in package.json.
+// 图片请求走同域 /_pcg/image/optimize,由 FC 内的 wrapper 拦截后用签名 client 调 Gateway。
+export default function pcgImageLoader({ src, width, quality }) {
+  const params = new URLSearchParams({
+    url: src,
+    w: String(width),
+    q: String(quality || 75),
+  });
+  return `/_pcg/image/optimize?${params}`;
+}