esa-pcg-cli 0.1.0

package/dist/adapters/wrappers/node-server.d.ts

@@ -0,0 +1,57 @@
+/**
+ * pcg Node Server Wrapper
+ *
+ * OpenNext wrapper 的长进程形态:不依赖 FaaS runtime,自带 HTTP server 直接监听
+ * `process.env.PORT`(默认 3000),`node index.mjs` 即可独立运行。
+ *
+ * 单个请求会按以下顺序分发:
+ *   1. `/__health`                  → 200 OK(供 pcg serve / 容器就绪探针)
+ *   2. `/_pcg/image/*`             → image-proxy(签名 client 调 Gateway)
+ *   3. `.open-next/assets/<urlPath>` 命中 → 直接 pipe 文件流
+ *   4. 其他                          → OpenNext handler(Next SSR/API/RSC)
+ *
+ * 三段逻辑此前分散在 platform-function wrapper(image proxy + req→event 桥接)
+ * 与 `pcg serve` 父进程(静态资源 + reverse proxy)中;此次统一进 wrapper,
+ * 让 `pcg serve` 退化为纯子进程管理器。
+ */
+interface InternalEvent {
+    type: 'core';
+    method: string;
+    rawPath: string;
+    url: string;
+    body?: string;
+    headers: Record<string, string>;
+    query: Record<string, string | string[]>;
+    cookies: Record<string, string>;
+    remoteAddress: string;
+}
+interface StreamCreator {
+    writeHeaders(prelude: {
+        statusCode: number;
+        cookies: string[];
+        headers: Record<string, string>;
+    }): import('stream').Writable;
+    abortSignal?: AbortSignal;
+    onFinish?: () => void;
+}
+declare type OpenNextHandler = (event: InternalEvent, ctx: {
+    streamCreator: StreamCreator;
+}) => Promise<void>;
+/**
+ * OpenNext 在加载完 server bundle 后调用此函数,我们在此启动 HTTP server。
+ *
+ * assets 目录解析为 `<cwd>/../../assets`:OpenNext 默认产物结构是
+ * `.open-next/server-functions/default/index.mjs`,运行时无论是用户手动
+ * `cd` 后 `node index.mjs` 还是 `pcg serve` spawn(`cwd: serverDir`),
+ * `process.cwd()` 都等于 `server-functions/default/`,assets 必在 `../../assets/`。
+ */
+declare function wrapper(handler: OpenNextHandler): Promise<void>;
+/**
+ * OpenNext 默认导出契约:`{ wrapper, name, supportStreaming }`。
+ */
+declare const wrapperDef: {
+    wrapper: typeof wrapper;
+    name: string;
+    supportStreaming: boolean;
+};
+export default wrapperDef;

package/dist/adapters/wrappers/node-server.js

@@ -0,0 +1,282 @@
+"use strict";
+/**
+ * pcg Node Server Wrapper
+ *
+ * OpenNext wrapper 的长进程形态:不依赖 FaaS runtime,自带 HTTP server 直接监听
+ * `process.env.PORT`(默认 3000),`node index.mjs` 即可独立运行。
+ *
+ * 单个请求会按以下顺序分发:
+ *   1. `/__health`                  → 200 OK(供 pcg serve / 容器就绪探针)
+ *   2. `/_pcg/image/*`             → image-proxy(签名 client 调 Gateway)
+ *   3. `.open-next/assets/<urlPath>` 命中 → 直接 pipe 文件流
+ *   4. 其他                          → OpenNext handler(Next SSR/API/RSC)
+ *
+ * 三段逻辑此前分散在 platform-function wrapper(image proxy + req→event 桥接)
+ * 与 `pcg serve` 父进程(静态资源 + reverse proxy)中;此次统一进 wrapper,
+ * 让 `pcg serve` 退化为纯子进程管理器。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const image_proxy_1 = require("../../runtime/image-proxy");
+// === 静态资源 MIME(与原 pcg serve 父进程实现保持一致) ===
+const MIME_TYPES = {
+    '.js': 'application/javascript',
+    '.mjs': 'application/javascript',
+    '.css': 'text/css',
+    '.html': 'text/html',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.map': 'application/json',
+    '.txt': 'text/plain',
+    '.webp': 'image/webp',
+};
+// === 请求 → InternalEvent 桥接工具 ===
+function parseQuery(url) {
+    const idx = url.indexOf('?');
+    if (idx === -1)
+        return {};
+    const params = {};
+    const searchParams = new URLSearchParams(url.slice(idx + 1));
+    for (const [key, value] of searchParams) {
+        const existing = params[key];
+        if (existing === undefined) {
+            params[key] = value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            params[key] = [existing, value];
+        }
+    }
+    return params;
+}
+function parseCookies(cookieHeader) {
+    if (!cookieHeader)
+        return {};
+    const cookies = {};
+    for (const pair of cookieHeader.split(';')) {
+        const eqIdx = pair.indexOf('=');
+        if (eqIdx === -1)
+            continue;
+        const name = pair.slice(0, eqIdx).trim();
+        const value = pair.slice(eqIdx + 1).trim();
+        if (name)
+            cookies[name] = value;
+    }
+    return cookies;
+}
+function flattenHeaders(rawHeaders) {
+    const headers = {};
+    for (const [key, value] of Object.entries(rawHeaders)) {
+        if (value === undefined)
+            continue;
+        headers[key.toLowerCase()] = Array.isArray(value)
+            ? value.join(', ')
+            : value;
+    }
+    return headers;
+}
+async function readBody(req) {
+    if (req.method === 'GET' || req.method === 'HEAD')
+        return undefined;
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        req.on('error', reject);
+    });
+}
+// === 静态资源 ===
+/**
+ * 服务 .open-next/assets/ 下的静态文件。
+ *
+ * 匹配两类:
+ *   1. `/_next/static/*` —— Next.js 生成的带 hash 资源,长缓存 immutable
+ *   2. `/<public-file>` —— `public/` 提取出来的根级静态文件,短缓存
+ *
+ * 不存在的路径返回 false 让上层 fallback 到 OpenNext handler(API / SSR /
+ * `_pcg/*` 等)。
+ */
+function serveStaticFile(assetsDir, req, res) {
+    var _a, _b;
+    const urlPath = (_b = (_a = req.url) === null || _a === void 0 ? void 0 : _a.split('?')[0]) !== null && _b !== void 0 ? _b : '/';
+    if (urlPath === '/' || !urlPath.startsWith('/'))
+        return false;
+    const filePath = path.join(assetsDir, urlPath);
+    const normalizedPath = path.normalize(filePath);
+    if (!normalizedPath.startsWith(assetsDir)) {
+        res.writeHead(403);
+        res.end();
+        return true;
+    }
+    let stat;
+    try {
+        stat = fs.statSync(normalizedPath);
+    }
+    catch (_c) {
+        return false;
+    }
+    if (!stat.isFile())
+        return false;
+    const ext = path.extname(normalizedPath);
+    const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+    const isHashedAsset = urlPath.startsWith('/_next/static/');
+    res.writeHead(200, {
+        'Content-Type': contentType,
+        'Content-Length': stat.size,
+        'Cache-Control': isHashedAsset
+            ? 'public, max-age=31536000, immutable'
+            : 'public, max-age=60',
+    });
+    fs.createReadStream(normalizedPath).pipe(res);
+    return true;
+}
+/**
+ * 把 OpenNext 提供的 handler 包成 http (req, res) 处理函数。
+ * 负责: body 读取、event 组装、流式响应、500 兜底。
+ */
+function bridgeOpenNextHandler(handler) {
+    return async (req, res) => {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            const rawUrl = req.url || '/';
+            const headers = flattenHeaders(req.headers);
+            const body = await readBody(req);
+            // OpenNext 内部对 event.url 执行 `new URL(...)`,必须是绝对 URL —— 用
+            // host header + x-forwarded-proto 还原,行为与 OpenNext 内置 node
+            // converter 一致 (@opennextjs/aws/dist/overrides/converters/node.js)。
+            const host = headers['host'] || `localhost:${(_a = process.env.PORT) !== null && _a !== void 0 ? _a : '3000'}`;
+            const proto = ((_c = (_b = headers['x-forwarded-proto']) === null || _b === void 0 ? void 0 : _b.split(',')[0]) === null || _c === void 0 ? void 0 : _c.trim()) || 'http';
+            const absoluteUrl = new URL(`${proto}://${host}${rawUrl}`);
+            const event = {
+                type: 'core',
+                method: req.method || 'GET',
+                rawPath: absoluteUrl.pathname,
+                url: absoluteUrl.href,
+                body,
+                headers,
+                query: parseQuery(rawUrl),
+                cookies: parseCookies(headers['cookie']),
+                remoteAddress: ((_e = (_d = headers['x-forwarded-for']) === null || _d === void 0 ? void 0 : _d.split(',')[0]) === null || _e === void 0 ? void 0 : _e.trim()) ||
+                    headers['x-real-ip'] ||
+                    ((_f = req.socket) === null || _f === void 0 ? void 0 : _f.remoteAddress) ||
+                    '127.0.0.1',
+            };
+            const abortController = new AbortController();
+            res.on('close', () => abortController.abort());
+            const streamCreator = {
+                writeHeaders(prelude) {
+                    res.setHeader('Set-Cookie', prelude.cookies);
+                    res.writeHead(prelude.statusCode, prelude.headers);
+                    res.flushHeaders();
+                    return res;
+                },
+                abortSignal: abortController.signal,
+            };
+            await handler(event, { streamCreator });
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                const isDev = process.env.NODE_ENV !== 'production';
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: 'Internal Server Error',
+                    ...(isDev && { message: err.message, stack: err.stack }),
+                }));
+            }
+            else if (!res.writableEnded) {
+                res.end();
+            }
+        }
+    };
+}
+/**
+ * OpenNext 在加载完 server bundle 后调用此函数,我们在此启动 HTTP server。
+ *
+ * assets 目录解析为 `<cwd>/../../assets`:OpenNext 默认产物结构是
+ * `.open-next/server-functions/default/index.mjs`,运行时无论是用户手动
+ * `cd` 后 `node index.mjs` 还是 `pcg serve` spawn(`cwd: serverDir`),
+ * `process.cwd()` 都等于 `server-functions/default/`,assets 必在 `../../assets/`。
+ */
+async function wrapper(handler) {
+    var _a;
+    const port = parseInt((_a = process.env.PORT) !== null && _a !== void 0 ? _a : '3000', 10);
+    const assetsDir = path.resolve(process.cwd(), '..', '..', 'assets');
+    if (!fs.existsSync(assetsDir)) {
+        console.warn(`[pcg-node] assets directory not found at ${assetsDir} — static file requests will fall through to Next handler`);
+    }
+    const dispatchToNext = bridgeOpenNextHandler(handler);
+    const server = http.createServer(async (req, res) => {
+        var _a, _b, _c;
+        const urlPath = (_b = (_a = req.url) === null || _a === void 0 ? void 0 : _a.split('?')[0]) !== null && _b !== void 0 ? _b : '/';
+        // 1. health check
+        if (urlPath === '/__health') {
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end('OK');
+            return;
+        }
+        // 2. 图片优化代理 —— `<img>` 发不出自定义签名 header,wrapper 在此代发
+        if ((_c = req.url) === null || _c === void 0 ? void 0 : _c.startsWith('/_pcg/image/')) {
+            try {
+                await (0, image_proxy_1.handleImageProxy)(req, res);
+            }
+            catch (err) {
+                console.error('[pcg-node] image-proxy error:', err);
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Image proxy failed' }));
+                }
+                else if (!res.writableEnded) {
+                    res.end();
+                }
+            }
+            return;
+        }
+        // 3. 静态资源(.open-next/assets/)
+        if (serveStaticFile(assetsDir, req, res))
+            return;
+        // 4. fallback —— OpenNext Next.js handler
+        await dispatchToNext(req, res);
+    });
+    // 优雅关闭:停止接收新连接,等 in-flight 请求自然结束,5s 兜底强制退出
+    let shuttingDown = false;
+    const shutdown = (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log(`[pcg-node] ${signal} received, shutting down...`);
+        server.close(() => process.exit(0));
+        setTimeout(() => process.exit(0), 5000).unref();
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    await new Promise(resolve => {
+        server.listen(port, () => {
+            console.log(`[pcg-node] Listening on port ${port}`);
+            console.log(`[pcg-node]   assets:  ${assetsDir}`);
+            console.log(`[pcg-node]   routes:  /__health, /_pcg/image/*, /_next/static/*, <next>`);
+            resolve();
+        });
+    });
+}
+/**
+ * OpenNext 默认导出契约:`{ wrapper, name, supportStreaming }`。
+ */
+const wrapperDef = {
+    wrapper,
+    name: 'pcg-node',
+    supportStreaming: true,
+};
+exports.default = wrapperDef;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-server.js","sourceRoot":"","sources":["../../../src/adapters/wrappers/node-server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * pcg Node Server Wrapper\n *\n * OpenNext wrapper 的长进程形态:不依赖 FaaS runtime,自带 HTTP server 直接监听\n * `process.env.PORT`(默认 3000),`node index.mjs` 即可独立运行。\n *\n * 单个请求会按以下顺序分发:\n *   1. `/__health`                  → 200 OK(供 pcg serve / 容器就绪探针)\n *   2. `/_pcg/image/*`             → image-proxy(签名 client 调 Gateway)\n *   3. `.open-next/assets/<urlPath>` 命中 → 直接 pipe 文件流\n *   4. 其他                          → OpenNext handler(Next SSR/API/RSC)\n *\n * 三段逻辑此前分散在 platform-function wrapper(image proxy + req→event 桥接)\n * 与 `pcg serve` 父进程(静态资源 + reverse proxy)中;此次统一进 wrapper,\n * 让 `pcg serve` 退化为纯子进程管理器。\n */\n\nimport * as http from 'http';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { handleImageProxy } from '../../runtime/image-proxy';\n\n// === OpenNext 接口类型(内联避免硬依赖 @opennextjs/aws) ===\n\ninterface InternalEvent {\n  type: 'core';\n  method: string;\n  rawPath: string;\n  url: string;\n  body?: string;\n  headers: Record<string, string>;\n  query: Record<string, string | string[]>;\n  cookies: Record<string, string>;\n  remoteAddress: string;\n}\n\ninterface StreamCreator {\n  writeHeaders(prelude: {\n    statusCode: number;\n    cookies: string[];\n    headers: Record<string, string>;\n  }): import('stream').Writable;\n  abortSignal?: AbortSignal;\n  onFinish?: () => void;\n}\n\ntype OpenNextHandler = (\n  event: InternalEvent,\n  ctx: { streamCreator: StreamCreator }\n) => Promise<void>;\n\n// === 静态资源 MIME(与原 pcg serve 父进程实现保持一致) ===\n\nconst MIME_TYPES: Record<string, string> = {\n  '.js': 'application/javascript',\n  '.mjs': 'application/javascript',\n  '.css': 'text/css',\n  '.html': 'text/html',\n  '.json': 'application/json',\n  '.png': 'image/png',\n  '.jpg': 'image/jpeg',\n  '.jpeg': 'image/jpeg',\n  '.gif': 'image/gif',\n  '.svg': 'image/svg+xml',\n  '.ico': 'image/x-icon',\n  '.woff': 'font/woff',\n  '.woff2': 'font/woff2',\n  '.ttf': 'font/ttf',\n  '.map': 'application/json',\n  '.txt': 'text/plain',\n  '.webp': 'image/webp',\n};\n\n// === 请求 → InternalEvent 桥接工具 ===\n\nfunction parseQuery(url: string): Record<string, string | string[]> {\n  const idx = url.indexOf('?');\n  if (idx === -1) return {};\n  const params: Record<string, string | string[]> = {};\n  const searchParams = new URLSearchParams(url.slice(idx + 1));\n  for (const [key, value] of searchParams) {\n    const existing = params[key];\n    if (existing === undefined) {\n      params[key] = value;\n    } else if (Array.isArray(existing)) {\n      existing.push(value);\n    } else {\n      params[key] = [existing, value];\n    }\n  }\n  return params;\n}\n\nfunction parseCookies(\n  cookieHeader: string | undefined\n): Record<string, string> {\n  if (!cookieHeader) return {};\n  const cookies: Record<string, string> = {};\n  for (const pair of cookieHeader.split(';')) {\n    const eqIdx = pair.indexOf('=');\n    if (eqIdx === -1) continue;\n    const name = pair.slice(0, eqIdx).trim();\n    const value = pair.slice(eqIdx + 1).trim();\n    if (name) cookies[name] = value;\n  }\n  return cookies;\n}\n\nfunction flattenHeaders(\n  rawHeaders: http.IncomingHttpHeaders\n): Record<string, string> {\n  const headers: Record<string, string> = {};\n  for (const [key, value] of Object.entries(rawHeaders)) {\n    if (value === undefined) continue;\n    headers[key.toLowerCase()] = Array.isArray(value)\n      ? value.join(', ')\n      : value;\n  }\n  return headers;\n}\n\nasync function readBody(\n  req: http.IncomingMessage\n): Promise<string | undefined> {\n  if (req.method === 'GET' || req.method === 'HEAD') return undefined;\n  return new Promise((resolve, reject) => {\n    const chunks: Buffer[] = [];\n    req.on('data', (chunk: Buffer) => chunks.push(chunk));\n    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));\n    req.on('error', reject);\n  });\n}\n\n// === 静态资源 ===\n\n/**\n * 服务 .open-next/assets/ 下的静态文件。\n *\n * 匹配两类:\n *   1. `/_next/static/*` —— Next.js 生成的带 hash 资源,长缓存 immutable\n *   2. `/<public-file>` —— `public/` 提取出来的根级静态文件,短缓存\n *\n * 不存在的路径返回 false 让上层 fallback 到 OpenNext handler(API / SSR /\n * `_pcg/*` 等)。\n */\nfunction serveStaticFile(\n  assetsDir: string,\n  req: http.IncomingMessage,\n  res: http.ServerResponse\n): boolean {\n  const urlPath = req.url?.split('?')[0] ?? '/';\n  if (urlPath === '/' || !urlPath.startsWith('/')) return false;\n\n  const filePath = path.join(assetsDir, urlPath);\n  const normalizedPath = path.normalize(filePath);\n  if (!normalizedPath.startsWith(assetsDir)) {\n    res.writeHead(403);\n    res.end();\n    return true;\n  }\n\n  let stat: fs.Stats;\n  try {\n    stat = fs.statSync(normalizedPath);\n  } catch {\n    return false;\n  }\n  if (!stat.isFile()) return false;\n\n  const ext = path.extname(normalizedPath);\n  const contentType = MIME_TYPES[ext] || 'application/octet-stream';\n  const isHashedAsset = urlPath.startsWith('/_next/static/');\n\n  res.writeHead(200, {\n    'Content-Type': contentType,\n    'Content-Length': stat.size,\n    'Cache-Control': isHashedAsset\n      ? 'public, max-age=31536000, immutable'\n      : 'public, max-age=60',\n  });\n  fs.createReadStream(normalizedPath).pipe(res);\n  return true;\n}\n\n/**\n * 把 OpenNext 提供的 handler 包成 http (req, res) 处理函数。\n * 负责: body 读取、event 组装、流式响应、500 兜底。\n */\nfunction bridgeOpenNextHandler(handler: OpenNextHandler) {\n  return async (\n    req: http.IncomingMessage,\n    res: http.ServerResponse\n  ): Promise<void> => {\n    try {\n      const rawUrl = req.url || '/';\n      const headers = flattenHeaders(req.headers);\n      const body = await readBody(req);\n\n      // OpenNext 内部对 event.url 执行 `new URL(...)`,必须是绝对 URL —— 用\n      // host header + x-forwarded-proto 还原,行为与 OpenNext 内置 node\n      // converter 一致 (@opennextjs/aws/dist/overrides/converters/node.js)。\n      const host = headers['host'] || `localhost:${process.env.PORT ?? '3000'}`;\n      const proto = headers['x-forwarded-proto']?.split(',')[0]?.trim() || 'http';\n      const absoluteUrl = new URL(`${proto}://${host}${rawUrl}`);\n\n      const event: InternalEvent = {\n        type: 'core',\n        method: req.method || 'GET',\n        rawPath: absoluteUrl.pathname,\n        url: absoluteUrl.href,\n        body,\n        headers,\n        query: parseQuery(rawUrl),\n        cookies: parseCookies(headers['cookie']),\n        remoteAddress:\n          headers['x-forwarded-for']?.split(',')[0]?.trim() ||\n          headers['x-real-ip'] ||\n          req.socket?.remoteAddress ||\n          '127.0.0.1',\n      };\n\n      const abortController = new AbortController();\n      res.on('close', () => abortController.abort());\n\n      const streamCreator: StreamCreator = {\n        writeHeaders(prelude) {\n          res.setHeader('Set-Cookie', prelude.cookies);\n          res.writeHead(prelude.statusCode, prelude.headers);\n          res.flushHeaders();\n          return res;\n        },\n        abortSignal: abortController.signal,\n      };\n\n      await handler(event, { streamCreator });\n    } catch (err: any) {\n      if (!res.headersSent) {\n        const isDev = process.env.NODE_ENV !== 'production';\n        res.writeHead(500, { 'Content-Type': 'application/json' });\n        res.end(\n          JSON.stringify({\n            error: 'Internal Server Error',\n            ...(isDev && { message: err.message, stack: err.stack }),\n          })\n        );\n      } else if (!res.writableEnded) {\n        res.end();\n      }\n    }\n  };\n}\n\n/**\n * OpenNext 在加载完 server bundle 后调用此函数,我们在此启动 HTTP server。\n *\n * assets 目录解析为 `<cwd>/../../assets`:OpenNext 默认产物结构是\n * `.open-next/server-functions/default/index.mjs`,运行时无论是用户手动\n * `cd` 后 `node index.mjs` 还是 `pcg serve` spawn(`cwd: serverDir`),\n * `process.cwd()` 都等于 `server-functions/default/`,assets 必在 `../../assets/`。\n */\nasync function wrapper(handler: OpenNextHandler): Promise<void> {\n  const port = parseInt(process.env.PORT ?? '3000', 10);\n  const assetsDir = path.resolve(process.cwd(), '..', '..', 'assets');\n  if (!fs.existsSync(assetsDir)) {\n    console.warn(\n      `[pcg-node] assets directory not found at ${assetsDir} — static file requests will fall through to Next handler`\n    );\n  }\n\n  const dispatchToNext = bridgeOpenNextHandler(handler);\n\n  const server = http.createServer(async (req, res) => {\n    const urlPath = req.url?.split('?')[0] ?? '/';\n\n    // 1. health check\n    if (urlPath === '/__health') {\n      res.writeHead(200, { 'Content-Type': 'text/plain' });\n      res.end('OK');\n      return;\n    }\n\n    // 2. 图片优化代理 —— `<img>` 发不出自定义签名 header,wrapper 在此代发\n    if (req.url?.startsWith('/_pcg/image/')) {\n      try {\n        await handleImageProxy(req, res);\n      } catch (err: any) {\n        console.error('[pcg-node] image-proxy error:', err);\n        if (!res.headersSent) {\n          res.writeHead(500, { 'Content-Type': 'application/json' });\n          res.end(JSON.stringify({ error: 'Image proxy failed' }));\n        } else if (!res.writableEnded) {\n          res.end();\n        }\n      }\n      return;\n    }\n\n    // 3. 静态资源(.open-next/assets/)\n    if (serveStaticFile(assetsDir, req, res)) return;\n\n    // 4. fallback —— OpenNext Next.js handler\n    await dispatchToNext(req, res);\n  });\n\n  // 优雅关闭:停止接收新连接,等 in-flight 请求自然结束,5s 兜底强制退出\n  let shuttingDown = false;\n  const shutdown = (signal: string): void => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n    console.log(`[pcg-node] ${signal} received, shutting down...`);\n    server.close(() => process.exit(0));\n    setTimeout(() => process.exit(0), 5000).unref();\n  };\n  process.on('SIGINT', () => shutdown('SIGINT'));\n  process.on('SIGTERM', () => shutdown('SIGTERM'));\n\n  await new Promise<void>(resolve => {\n    server.listen(port, () => {\n      console.log(`[pcg-node] Listening on port ${port}`);\n      console.log(`[pcg-node]   assets:  ${assetsDir}`);\n      console.log(`[pcg-node]   routes:  /__health, /_pcg/image/*, /_next/static/*, <next>`);\n      resolve();\n    });\n  });\n}\n\n/**\n * OpenNext 默认导出契约:`{ wrapper, name, supportStreaming }`。\n */\nconst wrapperDef = {\n  wrapper,\n  name: 'pcg-node',\n  supportStreaming: true,\n};\n\nexport default wrapperDef;\n"]}

package/dist/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const build_1 = require("../commands/build");
+const deploy_1 = require("../commands/deploy");
+const upload_cache_1 = require("../commands/upload-cache");
+const serve_1 = require("../commands/serve");
+const purge_1 = require("../commands/purge");
+const program = new commander_1.Command();
+program
+    .name('pcg')
+    .description('CLI tool for building and deploying Next.js apps to pages-cache-gateway')
+    .version('0.1.0');
+program.addCommand((0, build_1.createBuildCommand)());
+program.addCommand((0, deploy_1.createDeployCommand)());
+program.addCommand((0, upload_cache_1.createUploadCacheCommand)());
+program.addCommand((0, serve_1.createServeCommand)());
+program.addCommand((0, purge_1.createPurgeCommand)());
+program.parse(process.argv);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jpbi9jbGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEseUNBQW9DO0FBQ3BDLDZDQUF1RDtBQUN2RCwrQ0FBeUQ7QUFDekQsMkRBQW9FO0FBQ3BFLDZDQUF1RDtBQUN2RCw2Q0FBdUQ7QUFFdkQsTUFBTSxPQUFPLEdBQUcsSUFBSSxtQkFBTyxFQUFFLENBQUM7QUFFOUIsT0FBTztLQUNKLElBQUksQ0FBQyxLQUFLLENBQUM7S0FDWCxXQUFXLENBQUMseUVBQXlFLENBQUM7S0FDdEYsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBRXBCLE9BQU8sQ0FBQyxVQUFVLENBQUMsSUFBQSwwQkFBa0IsR0FBRSxDQUFDLENBQUM7QUFDekMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxJQUFBLDRCQUFtQixHQUFFLENBQUMsQ0FBQztBQUMxQyxPQUFPLENBQUMsVUFBVSxDQUFDLElBQUEsdUNBQXdCLEdBQUUsQ0FBQyxDQUFDO0FBQy9DLE9BQU8sQ0FBQyxVQUFVLENBQUMsSUFBQSwwQkFBa0IsR0FBRSxDQUFDLENBQUM7QUFDekMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxJQUFBLDBCQUFrQixHQUFFLENBQUMsQ0FBQztBQUV6QyxPQUFPLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIiMhL3Vzci9iaW4vZW52IG5vZGVcblxuaW1wb3J0IHsgQ29tbWFuZCB9IGZyb20gJ2NvbW1hbmRlcic7XG5pbXBvcnQgeyBjcmVhdGVCdWlsZENvbW1hbmQgfSBmcm9tICcuLi9jb21tYW5kcy9idWlsZCc7XG5pbXBvcnQgeyBjcmVhdGVEZXBsb3lDb21tYW5kIH0gZnJvbSAnLi4vY29tbWFuZHMvZGVwbG95JztcbmltcG9ydCB7IGNyZWF0ZVVwbG9hZENhY2hlQ29tbWFuZCB9IGZyb20gJy4uL2NvbW1hbmRzL3VwbG9hZC1jYWNoZSc7XG5pbXBvcnQgeyBjcmVhdGVTZXJ2ZUNvbW1hbmQgfSBmcm9tICcuLi9jb21tYW5kcy9zZXJ2ZSc7XG5pbXBvcnQgeyBjcmVhdGVQdXJnZUNvbW1hbmQgfSBmcm9tICcuLi9jb21tYW5kcy9wdXJnZSc7XG5cbmNvbnN0IHByb2dyYW0gPSBuZXcgQ29tbWFuZCgpO1xuXG5wcm9ncmFtXG4gIC5uYW1lKCdwY2cnKVxuICAuZGVzY3JpcHRpb24oJ0NMSSB0b29sIGZvciBidWlsZGluZyBhbmQgZGVwbG95aW5nIE5leHQuanMgYXBwcyB0byBwYWdlcy1jYWNoZS1nYXRld2F5JylcbiAgLnZlcnNpb24oJzAuMS4wJyk7XG5cbnByb2dyYW0uYWRkQ29tbWFuZChjcmVhdGVCdWlsZENvbW1hbmQoKSk7XG5wcm9ncmFtLmFkZENvbW1hbmQoY3JlYXRlRGVwbG95Q29tbWFuZCgpKTtcbnByb2dyYW0uYWRkQ29tbWFuZChjcmVhdGVVcGxvYWRDYWNoZUNvbW1hbmQoKSk7XG5wcm9ncmFtLmFkZENvbW1hbmQoY3JlYXRlU2VydmVDb21tYW5kKCkpO1xucHJvZ3JhbS5hZGRDb21tYW5kKGNyZWF0ZVB1cmdlQ29tbWFuZCgpKTtcblxucHJvZ3JhbS5wYXJzZShwcm9jZXNzLmFyZ3YpO1xuIl19

package/dist/commands/build.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+export interface BuildOptions {
+    dir: string;
+    config?: string;
+    debug?: boolean;
+    dryRun?: boolean;
+    forceUnsupportedNext?: boolean;
+}
+export declare function runBuild(opts: BuildOptions): Promise<void>;
+export declare function createBuildCommand(): Command;