esa-pcg-cli 0.1.0

package/dist/commands/build.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildCommand = exports.runBuild = void 0;
+const path = require("path");
+const fs = require("fs/promises");
+const commander_1 = require("commander");
+const fs_1 = require("../util/fs");
+const default_open_next_config_1 = require("../config/default-open-next-config");
+// Mirror of OpenNext's NEXT_RELEASE_DATES (helper.js). Used to auto-pass
+// --force-unsupported-next when the user's Next major is past its 2-year window,
+// so pipeline builds don't fail on OpenNext's policy gate.
+const NEXT_RELEASE_DATES = {
+    16: '2025-10-21',
+    15: '2024-10-21',
+    14: '2023-10-26',
+    13: '2022-10-26',
+    12: '2021-10-26',
+};
+const NEXT_SUPPORT_WINDOW_YEARS = 2;
+async function detectNextMajor(projectDir) {
+    try {
+        const pkgPath = path.join(projectDir, 'node_modules', 'next', 'package.json');
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+        const major = parseInt(String(pkg.version).split('.')[0], 10);
+        return Number.isNaN(major) ? null : major;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function isNextMajorUnsupported(major) {
+    const releaseDate = NEXT_RELEASE_DATES[major];
+    if (!releaseDate)
+        return major < 12;
+    const eol = new Date(releaseDate);
+    eol.setFullYear(eol.getFullYear() + NEXT_SUPPORT_WINDOW_YEARS);
+    return Date.now() > eol.getTime();
+}
+// Path inside <projectDir> where we materialize override bundles so the
+// auto-generated open-next.config can reference them via a relative path.
+// Relative form needed because absolute __dirname paths break when the CLI is
+// ncc-bundled into a single file (subdirectory tree no longer exists).
+const PCG_OVERRIDES_REL = '.pcg/overrides';
+// Loader copied into <projectDir>/node_modules/.pcg/ at build time so
+// next.config can reference it as 'node_modules/.pcg/pcg-image-loader.js'
+// without writing into the user's source tree or adding esa-pcg-cli to
+// their package.json. node_modules is gitignored and webpack handles paths
+// under it natively.
+const PCG_IMAGE_LOADER_FILENAME = 'pcg-image-loader.js';
+const PCG_IMAGE_LOADER_REL_DIR = 'node_modules/.pcg';
+async function materializeImageLoader(projectDir) {
+    const src = path.join(__dirname, '..', '..', 'runtime', PCG_IMAGE_LOADER_FILENAME);
+    const destDir = path.join(projectDir, PCG_IMAGE_LOADER_REL_DIR);
+    const dest = path.join(destDir, PCG_IMAGE_LOADER_FILENAME);
+    try {
+        await fs.mkdir(destDir, { recursive: true });
+        await fs.copyFile(src, dest);
+    }
+    catch (err) {
+        if (err && err.code === 'ENOENT') {
+            throw new Error(`[build] runtime/${PCG_IMAGE_LOADER_FILENAME} missing from esa-pcg-cli, ` +
+                `or ${projectDir}/node_modules is missing. ` +
+                'Run `npm install` in the project, and reinstall esa-pcg-cli if its runtime/ is gone.');
+        }
+        throw err;
+    }
+}
+async function materializeOverrides(projectDir) {
+    // Lazy require — keeps the inline-overrides bundle out of the import graph
+    // for code paths that don't auto-generate the config.
+    let INLINE_OVERRIDES;
+    try {
+        ({ INLINE_OVERRIDES } = require('../_inline-overrides'));
+    }
+    catch (err) {
+        if (err && err.code === 'MODULE_NOT_FOUND') {
+            throw new Error('[build] dist/_inline-overrides.js missing from esa-pcg-cli. ' +
+                'The published package was built without scripts/bundle-overrides.js. ' +
+                'Reinstall a newer esa-pcg-cli (built with the full `pnpm build` pipeline).');
+        }
+        throw err;
+    }
+    const overridesRoot = path.join(projectDir, PCG_OVERRIDES_REL);
+    for (const [relPath, source] of Object.entries(INLINE_OVERRIDES)) {
+        const target = path.join(overridesRoot, relPath);
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, source);
+    }
+}
+async function cleanupOverrides(projectDir) {
+    const overridesRoot = path.join(projectDir, PCG_OVERRIDES_REL);
+    await fs.rm(overridesRoot, { recursive: true, force: true });
+    // Also try to remove the .pcg parent if it's empty; ignore if not.
+    await fs.rmdir(path.join(projectDir, '.pcg')).catch(() => { });
+}
+async function runBuild(opts) {
+    const projectDir = path.resolve(opts.dir);
+    const pkgJsonPath = path.join(projectDir, 'package.json');
+    try {
+        await fs.access(pkgJsonPath);
+    }
+    catch (_a) {
+        throw new Error(`Next.js project not found at ${projectDir} (no package.json)`);
+    }
+    const openNextDir = path.join(projectDir, '.open-next');
+    let configPath = opts.config;
+    let tempConfig = false;
+    if (!configPath) {
+        const candidates = ['open-next.config.ts', 'open-next.config.js'];
+        for (const c of candidates) {
+            const p = path.join(projectDir, c);
+            try {
+                await fs.access(p);
+                configPath = p;
+                break;
+            }
+            catch (_b) { }
+        }
+    }
+    if (!configPath) {
+        console.log('[build] No open-next.config found, generating default config...');
+        configPath = path.join(projectDir, 'open-next.config.ts');
+        await materializeOverrides(projectDir);
+        const configContent = (0, default_open_next_config_1.generateDefaultConfig)({
+            overridesDir: `./${PCG_OVERRIDES_REL}`,
+        });
+        await fs.writeFile(configPath, configContent);
+        tempConfig = true;
+    }
+    if (opts.dryRun) {
+        console.log('[build] Dry run mode — build plan:');
+        console.log(`  Project dir: ${projectDir}`);
+        console.log(`  Config: ${configPath}`);
+        console.log(`  Output: ${openNextDir}`);
+        return;
+    }
+    try {
+        if (await (0, fs_1.dirExists)(openNextDir)) {
+            console.log('[build] Cleaning old .open-next/ directory...');
+            await fs.rm(openNextDir, { recursive: true, force: true });
+        }
+        if (opts.debug) {
+            process.env.OPEN_NEXT_DEBUG = 'true';
+        }
+        let forceUnsupported = opts.forceUnsupportedNext === true;
+        if (!forceUnsupported && process.env.PCG_STRICT_NEXT_SUPPORT !== '1') {
+            const nextMajor = await detectNextMajor(projectDir);
+            if (nextMajor !== null && isNextMajorUnsupported(nextMajor)) {
+                console.warn(`[build] Next ${nextMajor}.x is past OpenNext's ${NEXT_SUPPORT_WINDOW_YEARS}-year support window — ` +
+                    'auto-enabling --force-unsupported-next. ' +
+                    'Set PCG_STRICT_NEXT_SUPPORT=1 to disable this behavior.');
+                forceUnsupported = true;
+            }
+        }
+        await materializeImageLoader(projectDir);
+        await checkImageLoaderConfig(projectDir);
+        console.log('[build] Running OpenNext build...');
+        const prevCwd = process.cwd();
+        try {
+            process.chdir(projectDir);
+            // OpenNext resolves `next` via process.cwd() / { paths: [appPath] },
+            // so loading it from the CLI's own node_modules still finds the user's Next.
+            const openNextBuild = require('@opennextjs/aws/build.js');
+            const relativeConfigPath = path.relative(projectDir, configPath);
+            await openNextBuild.build(relativeConfigPath, '@opennextjs/aws', forceUnsupported);
+        }
+        finally {
+            process.chdir(prevCwd);
+        }
+        console.log('[build] Build complete!');
+    }
+    finally {
+        if (tempConfig) {
+            try {
+                await fs.unlink(configPath);
+            }
+            catch (_c) {
+                console.warn('[build] Warning: failed to clean up temporary config file');
+            }
+            try {
+                await cleanupOverrides(projectDir);
+            }
+            catch (_d) {
+                console.warn(`[build] Warning: failed to clean up ${PCG_OVERRIDES_REL}/`);
+            }
+        }
+    }
+}
+exports.runBuild = runBuild;
+const NEXT_CONFIG_FILES = [
+    'next.config.js',
+    'next.config.mjs',
+    'next.config.ts',
+];
+async function readNextConfig(projectDir) {
+    for (const f of NEXT_CONFIG_FILES) {
+        try {
+            return await fs.readFile(path.join(projectDir, f), 'utf-8');
+        }
+        catch (_a) {
+            // try next candidate
+        }
+    }
+    return null;
+}
+/**
+ * Verify `next.config.{js,mjs,ts}` wires `images.loader = "custom"` AND
+ * `images.loaderFile` references the loader that `materializeImageLoader`
+ * just wrote into `<projectDir>/node_modules/.pcg/`. Without that wiring
+ * Next falls back to the built-in /_next/image handler and `<Image>` URLs
+ * never reach the wrapper's `/_pcg/image/*` route.
+ */
+async function checkImageLoaderConfig(projectDir) {
+    try {
+        const content = await readNextConfig(projectDir);
+        if (content === null)
+            return;
+        const hasCustomLoader = /loader\s*:\s*['"]custom['"]/.test(content);
+        const hasLoaderFile = content.includes('pcg-image-loader');
+        if (!hasCustomLoader || !hasLoaderFile) {
+            console.warn('[build] Warning: next.config must configure images.loader = "custom" ' +
+                'and set images.loaderFile to "node_modules/.pcg/pcg-image-loader.js" — ' +
+                'without both, <Image> URLs will not be routed through /_pcg/image/optimize.');
+        }
+    }
+    catch (_a) { }
+}
+function createBuildCommand() {
+    return new commander_1.Command('build')
+        .description('Build Next.js project for deployment via pages-cache-gateway')
+        .option('--dir <path>', 'Next.js project directory', '.')
+        .option('--config <path>', 'open-next.config.ts path')
+        .option('--debug', 'Enable debug mode')
+        .option('--dry-run', 'Show build plan without executing')
+        .option('--force-unsupported-next', 'Allow unsupported Next.js versions')
+        .action(async (options) => {
+        await runBuild({
+            dir: options.dir,
+            config: options.config,
+            debug: options.debug,
+            dryRun: options.dryRun,
+            forceUnsupportedNext: options.forceUnsupportedNext,
+        });
+    });
+}
+exports.createBuildCommand = createBuildCommand;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build.js","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs/promises';\nimport { Command } from 'commander';\nimport { dirExists } from '../util/fs';\nimport { generateDefaultConfig } from '../config/default-open-next-config';\n\n// Mirror of OpenNext's NEXT_RELEASE_DATES (helper.js). Used to auto-pass\n// --force-unsupported-next when the user's Next major is past its 2-year window,\n// so pipeline builds don't fail on OpenNext's policy gate.\nconst NEXT_RELEASE_DATES: Record<number, string> = {\n  16: '2025-10-21',\n  15: '2024-10-21',\n  14: '2023-10-26',\n  13: '2022-10-26',\n  12: '2021-10-26',\n};\nconst NEXT_SUPPORT_WINDOW_YEARS = 2;\n\nasync function detectNextMajor(projectDir: string): Promise<number | null> {\n  try {\n    const pkgPath = path.join(\n      projectDir,\n      'node_modules',\n      'next',\n      'package.json'\n    );\n    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));\n    const major = parseInt(String(pkg.version).split('.')[0], 10);\n    return Number.isNaN(major) ? null : major;\n  } catch {\n    return null;\n  }\n}\n\nfunction isNextMajorUnsupported(major: number): boolean {\n  const releaseDate = NEXT_RELEASE_DATES[major];\n  if (!releaseDate) return major < 12;\n  const eol = new Date(releaseDate);\n  eol.setFullYear(eol.getFullYear() + NEXT_SUPPORT_WINDOW_YEARS);\n  return Date.now() > eol.getTime();\n}\n\n// Path inside <projectDir> where we materialize override bundles so the\n// auto-generated open-next.config can reference them via a relative path.\n// Relative form needed because absolute __dirname paths break when the CLI is\n// ncc-bundled into a single file (subdirectory tree no longer exists).\nconst PCG_OVERRIDES_REL = '.pcg/overrides';\n\n// Loader copied into <projectDir>/node_modules/.pcg/ at build time so\n// next.config can reference it as 'node_modules/.pcg/pcg-image-loader.js'\n// without writing into the user's source tree or adding esa-pcg-cli to\n// their package.json. node_modules is gitignored and webpack handles paths\n// under it natively.\nconst PCG_IMAGE_LOADER_FILENAME = 'pcg-image-loader.js';\nconst PCG_IMAGE_LOADER_REL_DIR = 'node_modules/.pcg';\n\nasync function materializeImageLoader(projectDir: string): Promise<void> {\n  const src = path.join(\n    __dirname,\n    '..',\n    '..',\n    'runtime',\n    PCG_IMAGE_LOADER_FILENAME\n  );\n  const destDir = path.join(projectDir, PCG_IMAGE_LOADER_REL_DIR);\n  const dest = path.join(destDir, PCG_IMAGE_LOADER_FILENAME);\n  try {\n    await fs.mkdir(destDir, { recursive: true });\n    await fs.copyFile(src, dest);\n  } catch (err: any) {\n    if (err && err.code === 'ENOENT') {\n      throw new Error(\n        `[build] runtime/${PCG_IMAGE_LOADER_FILENAME} missing from esa-pcg-cli, ` +\n          `or ${projectDir}/node_modules is missing. ` +\n          'Run `npm install` in the project, and reinstall esa-pcg-cli if its runtime/ is gone.'\n      );\n    }\n    throw err;\n  }\n}\n\nasync function materializeOverrides(projectDir: string): Promise<void> {\n  // Lazy require — keeps the inline-overrides bundle out of the import graph\n  // for code paths that don't auto-generate the config.\n  let INLINE_OVERRIDES: Record<string, string>;\n  try {\n    ({ INLINE_OVERRIDES } = require('../_inline-overrides'));\n  } catch (err: any) {\n    if (err && err.code === 'MODULE_NOT_FOUND') {\n      throw new Error(\n        '[build] dist/_inline-overrides.js missing from esa-pcg-cli. ' +\n          'The published package was built without scripts/bundle-overrides.js. ' +\n          'Reinstall a newer esa-pcg-cli (built with the full `pnpm build` pipeline).'\n      );\n    }\n    throw err;\n  }\n  const overridesRoot = path.join(projectDir, PCG_OVERRIDES_REL);\n  for (const [relPath, source] of Object.entries(INLINE_OVERRIDES) as [\n    string,\n    string,\n  ][]) {\n    const target = path.join(overridesRoot, relPath);\n    await fs.mkdir(path.dirname(target), { recursive: true });\n    await fs.writeFile(target, source);\n  }\n}\n\nasync function cleanupOverrides(projectDir: string): Promise<void> {\n  const overridesRoot = path.join(projectDir, PCG_OVERRIDES_REL);\n  await fs.rm(overridesRoot, { recursive: true, force: true });\n  // Also try to remove the .pcg parent if it's empty; ignore if not.\n  await fs.rmdir(path.join(projectDir, '.pcg')).catch(() => {});\n}\n\nexport interface BuildOptions {\n  dir: string;\n  config?: string;\n  debug?: boolean;\n  dryRun?: boolean;\n  forceUnsupportedNext?: boolean;\n}\n\nexport async function runBuild(opts: BuildOptions): Promise<void> {\n  const projectDir = path.resolve(opts.dir);\n\n  const pkgJsonPath = path.join(projectDir, 'package.json');\n  try {\n    await fs.access(pkgJsonPath);\n  } catch {\n    throw new Error(\n      `Next.js project not found at ${projectDir} (no package.json)`\n    );\n  }\n\n  const openNextDir = path.join(projectDir, '.open-next');\n\n  let configPath = opts.config;\n  let tempConfig = false;\n\n  if (!configPath) {\n    const candidates = ['open-next.config.ts', 'open-next.config.js'];\n    for (const c of candidates) {\n      const p = path.join(projectDir, c);\n      try {\n        await fs.access(p);\n        configPath = p;\n        break;\n      } catch {}\n    }\n  }\n\n  if (!configPath) {\n    console.log(\n      '[build] No open-next.config found, generating default config...'\n    );\n    configPath = path.join(projectDir, 'open-next.config.ts');\n    await materializeOverrides(projectDir);\n    const configContent = generateDefaultConfig({\n      overridesDir: `./${PCG_OVERRIDES_REL}`,\n    });\n    await fs.writeFile(configPath, configContent);\n    tempConfig = true;\n  }\n\n  if (opts.dryRun) {\n    console.log('[build] Dry run mode — build plan:');\n    console.log(`  Project dir: ${projectDir}`);\n    console.log(`  Config: ${configPath}`);\n    console.log(`  Output: ${openNextDir}`);\n    return;\n  }\n\n  try {\n    if (await dirExists(openNextDir)) {\n      console.log('[build] Cleaning old .open-next/ directory...');\n      await fs.rm(openNextDir, { recursive: true, force: true });\n    }\n\n    if (opts.debug) {\n      process.env.OPEN_NEXT_DEBUG = 'true';\n    }\n\n    let forceUnsupported = opts.forceUnsupportedNext === true;\n    if (!forceUnsupported && process.env.PCG_STRICT_NEXT_SUPPORT !== '1') {\n      const nextMajor = await detectNextMajor(projectDir);\n      if (nextMajor !== null && isNextMajorUnsupported(nextMajor)) {\n        console.warn(\n          `[build] Next ${nextMajor}.x is past OpenNext's ${NEXT_SUPPORT_WINDOW_YEARS}-year support window — ` +\n            'auto-enabling --force-unsupported-next. ' +\n            'Set PCG_STRICT_NEXT_SUPPORT=1 to disable this behavior.'\n        );\n        forceUnsupported = true;\n      }\n    }\n\n    await materializeImageLoader(projectDir);\n    await checkImageLoaderConfig(projectDir);\n\n    console.log('[build] Running OpenNext build...');\n    const prevCwd = process.cwd();\n    try {\n      process.chdir(projectDir);\n      // OpenNext resolves `next` via process.cwd() / { paths: [appPath] },\n      // so loading it from the CLI's own node_modules still finds the user's Next.\n      const openNextBuild = require('@opennextjs/aws/build.js');\n      const relativeConfigPath = path.relative(projectDir, configPath!);\n      await openNextBuild.build(\n        relativeConfigPath,\n        '@opennextjs/aws',\n        forceUnsupported\n      );\n    } finally {\n      process.chdir(prevCwd);\n    }\n\n    console.log('[build] Build complete!');\n  } finally {\n    if (tempConfig) {\n      try {\n        await fs.unlink(configPath!);\n      } catch {\n        console.warn(\n          '[build] Warning: failed to clean up temporary config file'\n        );\n      }\n      try {\n        await cleanupOverrides(projectDir);\n      } catch {\n        console.warn(\n          `[build] Warning: failed to clean up ${PCG_OVERRIDES_REL}/`\n        );\n      }\n    }\n  }\n}\n\nconst NEXT_CONFIG_FILES = [\n  'next.config.js',\n  'next.config.mjs',\n  'next.config.ts',\n];\n\nasync function readNextConfig(projectDir: string): Promise<string | null> {\n  for (const f of NEXT_CONFIG_FILES) {\n    try {\n      return await fs.readFile(path.join(projectDir, f), 'utf-8');\n    } catch {\n      // try next candidate\n    }\n  }\n  return null;\n}\n\n/**\n * Verify `next.config.{js,mjs,ts}` wires `images.loader = \"custom\"` AND\n * `images.loaderFile` references the loader that `materializeImageLoader`\n * just wrote into `<projectDir>/node_modules/.pcg/`. Without that wiring\n * Next falls back to the built-in /_next/image handler and `<Image>` URLs\n * never reach the wrapper's `/_pcg/image/*` route.\n */\nasync function checkImageLoaderConfig(projectDir: string): Promise<void> {\n  try {\n    const content = await readNextConfig(projectDir);\n    if (content === null) return;\n    const hasCustomLoader = /loader\\s*:\\s*['\"]custom['\"]/.test(content);\n    const hasLoaderFile = content.includes('pcg-image-loader');\n    if (!hasCustomLoader || !hasLoaderFile) {\n      console.warn(\n        '[build] Warning: next.config must configure images.loader = \"custom\" ' +\n          'and set images.loaderFile to \"node_modules/.pcg/pcg-image-loader.js\" — ' +\n          'without both, <Image> URLs will not be routed through /_pcg/image/optimize.'\n      );\n    }\n  } catch {}\n}\n\nexport function createBuildCommand(): Command {\n  return new Command('build')\n    .description('Build Next.js project for deployment via pages-cache-gateway')\n    .option('--dir <path>', 'Next.js project directory', '.')\n    .option('--config <path>', 'open-next.config.ts path')\n    .option('--debug', 'Enable debug mode')\n    .option('--dry-run', 'Show build plan without executing')\n    .option('--force-unsupported-next', 'Allow unsupported Next.js versions')\n    .action(async options => {\n      await runBuild({\n        dir: options.dir,\n        config: options.config,\n        debug: options.debug,\n        dryRun: options.dryRun,\n        forceUnsupportedNext: options.forceUnsupportedNext,\n      });\n    });\n}\n"]}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+export interface DeployOptions {
+    dir: string;
+    localDev: boolean;
+    gateway: string;
+    token: string;
+    appId: string;
+    buildId: string;
+}
+export declare function runDeploy(opts: DeployOptions): Promise<void>;
+export declare function createDeployCommand(): Command;

package/dist/commands/deploy.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeployCommand = exports.runDeploy = void 0;
+const path = require("path");
+const fs = require("fs/promises");
+const commander_1 = require("commander");
+const oss_adapter_1 = require("../adapters/oss.adapter");
+const upload_cache_1 = require("./upload-cache");
+const fs_1 = require("../util/fs");
+async function fetchStsToken(gateway, token) {
+    const url = `${gateway}/deploy/sts-token`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`STS token request failed: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+}
+async function runDeploy(opts) {
+    const openNextDir = path.join(opts.dir, '.open-next');
+    if (!(await (0, fs_1.dirExists)(openNextDir))) {
+        throw new Error(`.open-next/ directory not found at ${openNextDir}`);
+    }
+    if (opts.localDev) {
+        await runLocalDeploy(opts);
+    }
+    else {
+        await runCentralDeploy(opts);
+    }
+}
+exports.runDeploy = runDeploy;
+/**
+ * Local-dev 模式：不再拷贝 assets/server-functions/cache 到 .pcg-local/。
+ * `pcg serve` 直接读 .open-next/，无需中间拷贝。
+ *
+ * 仅保留可选的"上传 cache 到 OSS"，方便本地测试覆盖真实 OSS 缓存路径。
+ */
+async function runLocalDeploy(opts) {
+    if (!opts.gateway || !opts.token) {
+        console.log('[deploy] local: nothing to do (no --gateway/--token; pcg serve reads .open-next/ directly)');
+        return;
+    }
+    try {
+        console.log(`[deploy] local: fetching STS credentials from ${opts.gateway}...`);
+        const stsCredentials = await fetchStsToken(opts.gateway, opts.token);
+        console.log('[deploy] local: uploading cache to OSS...');
+        const adapter = new oss_adapter_1.OSSUploadAdapter(stsCredentials);
+        const result = await (0, upload_cache_1.runUploadCache)({
+            dir: opts.dir,
+            appId: opts.appId,
+            buildId: opts.buildId,
+            adapter,
+        });
+        const ok = result.total - result.failed;
+        console.log(`[deploy] local deploy complete: cloud-cache=${ok}/${result.total}`);
+    }
+    catch (err) {
+        console.warn(`[deploy] local: cloud cache upload failed (${err.message})`);
+    }
+}
+async function runCentralDeploy(opts) {
+    if (!opts.gateway || !opts.token) {
+        throw new Error('Central mode requires --gateway and --token');
+    }
+    console.log('[deploy] central: platform deploy step (TBD)...');
+    console.log('[deploy] central: fetching STS credentials...');
+    const stsCredentials = await fetchStsToken(opts.gateway, opts.token);
+    const adapter = new oss_adapter_1.OSSUploadAdapter(stsCredentials);
+    const cacheResult = await (0, upload_cache_1.runUploadCache)({
+        dir: opts.dir,
+        appId: opts.appId,
+        buildId: opts.buildId,
+        adapter,
+    });
+    console.log(`[deploy] central deploy complete: cache=${cacheResult.total}`);
+}
+function createDeployCommand() {
+    return new commander_1.Command('deploy')
+        .description('Deploy Next.js build artifacts to cache gateway')
+        .option('-d, --dir <path>', 'Build output directory', '.')
+        .option('--local-dev', 'Local dev mode: only optional cache upload (pcg serve reads .open-next/ directly)')
+        .option('--gateway <url>', 'Gateway URL')
+        .option('--token <jwt>', 'JWT token')
+        .action(async (options) => {
+        const localDev = options.localDev || process.env.LOCAL_DEV === 'true';
+        const gateway = options.gateway || process.env.CACHE_SERVICE_ENDPOINT || (localDev ? 'http://localhost:7001' : '');
+        const token = options.token || process.env.CACHE_AUTH_TOKEN || '';
+        const appId = process.env.APP_ID || 'local_user/local_app';
+        let buildId = process.env.BUILD_ID || '';
+        if (!buildId) {
+            const buildIdPath = path.join(options.dir, '.open-next', 'assets', 'BUILD_ID');
+            try {
+                buildId = (await fs.readFile(buildIdPath, 'utf-8')).trim();
+            }
+            catch (_a) {
+                buildId = 'local_build';
+                console.warn(`[deploy] BUILD_ID not found at ${buildIdPath}, using fallback "${buildId}"`);
+            }
+        }
+        await runDeploy({
+            dir: options.dir,
+            localDev,
+            gateway,
+            token,
+            appId,
+            buildId,
+        });
+    });
+}
+exports.createDeployCommand = createDeployCommand;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy.js","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs/promises';\nimport { Command } from 'commander';\nimport { STSTokenResponse } from '@pcg/protocol';\nimport { OSSUploadAdapter } from '../adapters/oss.adapter';\nimport { runUploadCache } from './upload-cache';\nimport { dirExists } from '../util/fs';\n\nexport interface DeployOptions {\n  dir: string;\n  localDev: boolean;\n  gateway: string;\n  token: string;\n  appId: string;\n  buildId: string;\n}\n\nasync function fetchStsToken(gateway: string, token: string): Promise<STSTokenResponse> {\n  const url = `${gateway}/deploy/sts-token`;\n  const res = await fetch(url, {\n    method: 'POST',\n    headers: {\n      Authorization: `Bearer ${token}`,\n      'Content-Type': 'application/json',\n    },\n  });\n\n  if (!res.ok) {\n    throw new Error(`STS token request failed: ${res.status} ${res.statusText}`);\n  }\n\n  return res.json() as Promise<STSTokenResponse>;\n}\n\nexport async function runDeploy(opts: DeployOptions): Promise<void> {\n  const openNextDir = path.join(opts.dir, '.open-next');\n  if (!(await dirExists(openNextDir))) {\n    throw new Error(`.open-next/ directory not found at ${openNextDir}`);\n  }\n\n  if (opts.localDev) {\n    await runLocalDeploy(opts);\n  } else {\n    await runCentralDeploy(opts);\n  }\n}\n\n/**\n * Local-dev 模式：不再拷贝 assets/server-functions/cache 到 .pcg-local/。\n * `pcg serve` 直接读 .open-next/，无需中间拷贝。\n *\n * 仅保留可选的\"上传 cache 到 OSS\"，方便本地测试覆盖真实 OSS 缓存路径。\n */\nasync function runLocalDeploy(opts: DeployOptions): Promise<void> {\n  if (!opts.gateway || !opts.token) {\n    console.log(\n      '[deploy] local: nothing to do (no --gateway/--token; pcg serve reads .open-next/ directly)'\n    );\n    return;\n  }\n\n  try {\n    console.log(`[deploy] local: fetching STS credentials from ${opts.gateway}...`);\n    const stsCredentials = await fetchStsToken(opts.gateway, opts.token);\n\n    console.log('[deploy] local: uploading cache to OSS...');\n    const adapter = new OSSUploadAdapter(stsCredentials);\n    const result = await runUploadCache({\n      dir: opts.dir,\n      appId: opts.appId,\n      buildId: opts.buildId,\n      adapter,\n    });\n    const ok = result.total - result.failed;\n    console.log(\n      `[deploy] local deploy complete: cloud-cache=${ok}/${result.total}`\n    );\n  } catch (err: any) {\n    console.warn(`[deploy] local: cloud cache upload failed (${err.message})`);\n  }\n}\n\nasync function runCentralDeploy(opts: DeployOptions): Promise<void> {\n  if (!opts.gateway || !opts.token) {\n    throw new Error('Central mode requires --gateway and --token');\n  }\n\n  console.log('[deploy] central: platform deploy step (TBD)...');\n\n  console.log('[deploy] central: fetching STS credentials...');\n  const stsCredentials = await fetchStsToken(opts.gateway, opts.token);\n\n  const adapter = new OSSUploadAdapter(stsCredentials);\n  const cacheResult = await runUploadCache({\n    dir: opts.dir,\n    appId: opts.appId,\n    buildId: opts.buildId,\n    adapter,\n  });\n\n  console.log(`[deploy] central deploy complete: cache=${cacheResult.total}`);\n}\n\nexport function createDeployCommand(): Command {\n  return new Command('deploy')\n    .description('Deploy Next.js build artifacts to cache gateway')\n    .option('-d, --dir <path>', 'Build output directory', '.')\n    .option('--local-dev', 'Local dev mode: only optional cache upload (pcg serve reads .open-next/ directly)')\n    .option('--gateway <url>', 'Gateway URL')\n    .option('--token <jwt>', 'JWT token')\n    .action(async (options) => {\n      const localDev = options.localDev || process.env.LOCAL_DEV === 'true';\n      const gateway = options.gateway || process.env.CACHE_SERVICE_ENDPOINT || (localDev ? 'http://localhost:7001' : '');\n      const token = options.token || process.env.CACHE_AUTH_TOKEN || '';\n\n      const appId = process.env.APP_ID || 'local_user/local_app';\n      let buildId = process.env.BUILD_ID || '';\n      if (!buildId) {\n        const buildIdPath = path.join(options.dir, '.open-next', 'assets', 'BUILD_ID');\n        try {\n          buildId = (await fs.readFile(buildIdPath, 'utf-8')).trim();\n        } catch {\n          buildId = 'local_build';\n          console.warn(`[deploy] BUILD_ID not found at ${buildIdPath}, using fallback \"${buildId}\"`);\n        }\n      }\n\n      await runDeploy({\n        dir: options.dir,\n        localDev,\n        gateway,\n        token,\n        appId,\n        buildId,\n      });\n    });\n}\n"]}

package/dist/commands/purge.d.ts

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import { CacheRefreshResponse } from '../_protocol';
+export interface PurgeOptions {
+    gateway?: string;
+    secret?: string;
+    aliuid?: string;
+    routinename?: string;
+    version?: string;
+    hostname: string;
+    siteId: string | number;
+    urls: string[];
+    json?: boolean;
+}
+export declare function runPurge(opts: PurgeOptions): Promise<CacheRefreshResponse>;
+export declare function createPurgeCommand(): Command;

package/dist/commands/purge.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPurgeCommand = exports.runPurge = void 0;
+const fs = require("fs/promises");
+const commander_1 = require("commander");
+const gateway_auth_1 = require("../runtime/gateway-auth");
+const PURGE_TIMEOUT_MS = 30000;
+function resolveConfig(opts) {
+    const gateway = opts.gateway || process.env.ESA_CACHE_GW_GATEWAY_ENDPOINT;
+    const secret = opts.secret || process.env.ESA_CACHE_GW_AUTH_KEY;
+    const aliuid = opts.aliuid || process.env.ESA_CACHE_GW_ALIUID;
+    const routinename = opts.routinename || process.env.ESA_CACHE_GW_ROUTINENAME;
+    const version = opts.version || process.env.ESA_CACHE_GW_VERSION;
+    const missing = [];
+    if (!gateway)
+        missing.push('--gateway / ESA_CACHE_GW_GATEWAY_ENDPOINT');
+    if (!secret)
+        missing.push('--secret / ESA_CACHE_GW_AUTH_KEY');
+    if (!aliuid)
+        missing.push('--aliuid / ESA_CACHE_GW_ALIUID');
+    if (!routinename)
+        missing.push('--routinename / ESA_CACHE_GW_ROUTINENAME');
+    if (!version)
+        missing.push('--version / ESA_CACHE_GW_VERSION');
+    if (missing.length > 0) {
+        throw new Error(`Missing gateway auth config: ${missing.join(', ')}`);
+    }
+    return {
+        gatewayUrl: gateway.replace(/\/+$/, ''),
+        secret: secret,
+        aliuid: aliuid,
+        routinename: routinename,
+        version: version,
+    };
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+async function loadUrlsFile(filePath) {
+    const content = filePath === '-' ? await readStdin() : await fs.readFile(filePath, 'utf-8');
+    return content
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line.length > 0 && !line.startsWith('#'));
+}
+function dedupe(urls) {
+    return Array.from(new Set(urls.map(u => u.trim()).filter(Boolean)));
+}
+async function runPurge(opts) {
+    if (!opts.hostname)
+        throw new Error('hostname is required');
+    if (opts.siteId === undefined || opts.siteId === null || opts.siteId === '') {
+        throw new Error('siteId is required');
+    }
+    if (!Array.isArray(opts.urls) || opts.urls.length === 0) {
+        throw new Error('urls must be a non-empty array');
+    }
+    const cfg = resolveConfig(opts);
+    const body = {
+        hostname: opts.hostname,
+        siteId: opts.siteId,
+        urls: opts.urls,
+    };
+    const res = await (0, gateway_auth_1.gatewayFetch)(cfg, '/cache/refresh', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+        timeoutMs: PURGE_TIMEOUT_MS,
+    });
+    const text = await res.text();
+    let payload;
+    try {
+        payload = text ? JSON.parse(text) : {};
+    }
+    catch (_a) {
+        throw new Error(`Cache refresh: HTTP ${res.status}, non-JSON response: ${text.slice(0, 200)}`);
+    }
+    if (!res.ok) {
+        const msg = (payload === null || payload === void 0 ? void 0 : payload.error) || `HTTP ${res.status}`;
+        throw new Error(`Cache refresh failed: ${msg}`);
+    }
+    return payload;
+}
+exports.runPurge = runPurge;
+function createPurgeCommand() {
+    return new commander_1.Command('purge')
+        .description('Refresh CDN cache for a list of URLs via the gateway')
+        .option('--gateway <url>', 'Gateway URL (env: ESA_CACHE_GW_GATEWAY_ENDPOINT)')
+        .option('--secret <key>', 'HMAC secret (env: ESA_CACHE_GW_AUTH_KEY)')
+        .option('--aliuid <uid>', 'AliUid (env: ESA_CACHE_GW_ALIUID)')
+        .option('--routinename <name>', 'Routine name (env: ESA_CACHE_GW_ROUTINENAME)')
+        .option('--version <ver>', 'Version (env: ESA_CACHE_GW_VERSION)')
+        .requiredOption('-H, --hostname <host>', 'Hostname to refresh')
+        .requiredOption('-s, --site-id <id>', 'ESA siteId associated with hostname')
+        .option('-u, --url <url...>', 'URLs to refresh (repeatable / variadic)')
+        .option('-f, --urls-file <path>', 'File with one URL per line ("-" reads stdin; lines starting with "#" are skipped)')
+        .option('--json', 'Output raw JSON response instead of human-readable text')
+        .action(async (options) => {
+        var _a, _b, _c;
+        const fileUrls = options.urlsFile
+            ? await loadUrlsFile(options.urlsFile)
+            : [];
+        const flagUrls = Array.isArray(options.url) ? options.url : [];
+        const urls = dedupe([...flagUrls, ...fileUrls]);
+        try {
+            const result = await runPurge({
+                gateway: options.gateway,
+                secret: options.secret,
+                aliuid: options.aliuid,
+                routinename: options.routinename,
+                version: options.version,
+                hostname: options.hostname,
+                siteId: options.siteId,
+                urls,
+                json: options.json,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(`[purge] ok: backend=${result.backend} taskId=${(_a = result.taskId) !== null && _a !== void 0 ? _a : '-'} purged=${result.purgedUrlCount} apiRequestId=${(_b = result.apiRequestId) !== null && _b !== void 0 ? _b : '-'}`);
+            }
+        }
+        catch (err) {
+            console.error(`[purge] ${(_c = err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : String(err)}`);
+            process.exitCode = 1;
+        }
+    });
+}
+exports.createPurgeCommand = createPurgeCommand;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"purge.js","sourceRoot":"","sources":["../../src/commands/purge.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\nimport { Command } from 'commander';\nimport {\n  CacheRefreshRequest,\n  CacheRefreshResponse,\n} from '@pcg/protocol';\nimport { GatewayAuthConfig, gatewayFetch } from '../runtime/gateway-auth';\n\nconst PURGE_TIMEOUT_MS = 30_000;\n\nexport interface PurgeOptions {\n  gateway?: string;\n  secret?: string;\n  aliuid?: string;\n  routinename?: string;\n  version?: string;\n  hostname: string;\n  siteId: string | number;\n  urls: string[];\n  json?: boolean;\n}\n\ninterface ResolvedConfig extends GatewayAuthConfig {}\n\nfunction resolveConfig(opts: PurgeOptions): ResolvedConfig {\n  const gateway = opts.gateway || process.env.ESA_CACHE_GW_GATEWAY_ENDPOINT;\n  const secret = opts.secret || process.env.ESA_CACHE_GW_AUTH_KEY;\n  const aliuid = opts.aliuid || process.env.ESA_CACHE_GW_ALIUID;\n  const routinename = opts.routinename || process.env.ESA_CACHE_GW_ROUTINENAME;\n  const version = opts.version || process.env.ESA_CACHE_GW_VERSION;\n\n  const missing: string[] = [];\n  if (!gateway) missing.push('--gateway / ESA_CACHE_GW_GATEWAY_ENDPOINT');\n  if (!secret) missing.push('--secret / ESA_CACHE_GW_AUTH_KEY');\n  if (!aliuid) missing.push('--aliuid / ESA_CACHE_GW_ALIUID');\n  if (!routinename) missing.push('--routinename / ESA_CACHE_GW_ROUTINENAME');\n  if (!version) missing.push('--version / ESA_CACHE_GW_VERSION');\n  if (missing.length > 0) {\n    throw new Error(`Missing gateway auth config: ${missing.join(', ')}`);\n  }\n\n  return {\n    gatewayUrl: gateway!.replace(/\\/+$/, ''),\n    secret: secret!,\n    aliuid: aliuid!,\n    routinename: routinename!,\n    version: version!,\n  };\n}\n\nasync function readStdin(): Promise<string> {\n  const chunks: Buffer[] = [];\n  for await (const chunk of process.stdin) {\n    chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);\n  }\n  return Buffer.concat(chunks).toString('utf-8');\n}\n\nasync function loadUrlsFile(filePath: string): Promise<string[]> {\n  const content =\n    filePath === '-' ? await readStdin() : await fs.readFile(filePath, 'utf-8');\n  return content\n    .split(/\\r?\\n/)\n    .map(line => line.trim())\n    .filter(line => line.length > 0 && !line.startsWith('#'));\n}\n\nfunction dedupe(urls: string[]): string[] {\n  return Array.from(new Set(urls.map(u => u.trim()).filter(Boolean)));\n}\n\nexport async function runPurge(\n  opts: PurgeOptions\n): Promise<CacheRefreshResponse> {\n  if (!opts.hostname) throw new Error('hostname is required');\n  if (opts.siteId === undefined || opts.siteId === null || opts.siteId === '') {\n    throw new Error('siteId is required');\n  }\n  if (!Array.isArray(opts.urls) || opts.urls.length === 0) {\n    throw new Error('urls must be a non-empty array');\n  }\n\n  const cfg = resolveConfig(opts);\n  const body: CacheRefreshRequest = {\n    hostname: opts.hostname,\n    siteId: opts.siteId,\n    urls: opts.urls,\n  };\n\n  const res = await gatewayFetch(cfg, '/cache/refresh', {\n    method: 'POST',\n    headers: { 'Content-Type': 'application/json' },\n    body: JSON.stringify(body),\n    timeoutMs: PURGE_TIMEOUT_MS,\n  });\n\n  const text = await res.text();\n  let payload: any;\n  try {\n    payload = text ? JSON.parse(text) : {};\n  } catch {\n    throw new Error(\n      `Cache refresh: HTTP ${res.status}, non-JSON response: ${text.slice(0, 200)}`\n    );\n  }\n\n  if (!res.ok) {\n    const msg = payload?.error || `HTTP ${res.status}`;\n    throw new Error(`Cache refresh failed: ${msg}`);\n  }\n\n  return payload as CacheRefreshResponse;\n}\n\nexport function createPurgeCommand(): Command {\n  return new Command('purge')\n    .description('Refresh CDN cache for a list of URLs via the gateway')\n    .option('--gateway <url>', 'Gateway URL (env: ESA_CACHE_GW_GATEWAY_ENDPOINT)')\n    .option('--secret <key>', 'HMAC secret (env: ESA_CACHE_GW_AUTH_KEY)')\n    .option('--aliuid <uid>', 'AliUid (env: ESA_CACHE_GW_ALIUID)')\n    .option(\n      '--routinename <name>',\n      'Routine name (env: ESA_CACHE_GW_ROUTINENAME)'\n    )\n    .option('--version <ver>', 'Version (env: ESA_CACHE_GW_VERSION)')\n    .requiredOption('-H, --hostname <host>', 'Hostname to refresh')\n    .requiredOption('-s, --site-id <id>', 'ESA siteId associated with hostname')\n    .option('-u, --url <url...>', 'URLs to refresh (repeatable / variadic)')\n    .option(\n      '-f, --urls-file <path>',\n      'File with one URL per line (\"-\" reads stdin; lines starting with \"#\" are skipped)'\n    )\n    .option('--json', 'Output raw JSON response instead of human-readable text')\n    .action(async options => {\n      const fileUrls = options.urlsFile\n        ? await loadUrlsFile(options.urlsFile)\n        : [];\n      const flagUrls: string[] = Array.isArray(options.url) ? options.url : [];\n      const urls = dedupe([...flagUrls, ...fileUrls]);\n\n      try {\n        const result = await runPurge({\n          gateway: options.gateway,\n          secret: options.secret,\n          aliuid: options.aliuid,\n          routinename: options.routinename,\n          version: options.version,\n          hostname: options.hostname,\n          siteId: options.siteId,\n          urls,\n          json: options.json,\n        });\n\n        if (options.json) {\n          console.log(JSON.stringify(result, null, 2));\n        } else {\n          console.log(\n            `[purge] ok: backend=${result.backend} taskId=${result.taskId ?? '-'} purged=${result.purgedUrlCount} apiRequestId=${result.apiRequestId ?? '-'}`\n          );\n        }\n      } catch (err: any) {\n        console.error(`[purge] ${err?.message ?? String(err)}`);\n        process.exitCode = 1;\n      }\n    });\n}\n"]}

package/dist/commands/serve.d.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+export interface ServeOptions {
+    dir: string;
+    port: number;
+    gateway?: string;
+    /** 本地便利:`<aliuid>/<routinename>`,内部拆成 ESA_CACHE_GW_ALIUID + ROUTINENAME */
+    appId?: string;
+    /** HMAC secret,注入到 ESA_CACHE_GW_AUTH_KEY。优先级高于 token。 */
+    secret?: string;
+    /** @deprecated 旧 JWT,已不再使用,仅保留向后兼容 */
+    token?: string;
+}
+export declare function runServe(opts: ServeOptions): Promise<void>;
+export declare function createServeCommand(): Command;