@alipay/alipay-aipay 1.2.2 → 1.5.0

package/skill/references/normal/scripts/integration_message_runner.mjs

@@ -0,0 +1,1023 @@
+#!/usr/bin/env node
+
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { isWindowsPlatform } from './platform_compat.mjs';
+import { renderMessage } from './render_customer_message.mjs';
+import { emitTerminalMetric } from './telemetry.mjs';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const inspectorPath = path.join(scriptDir, 'project_route_inspector.sh');
+
+const productVariants = {
+  aipay: { variant: 'AIPAY', productName: 'AI 按量付费' },
+  webpay: { variant: 'WEBPAY', productName: 'AI 网页应用收款' },
+  apppay: { variant: 'APPPAY', productName: 'AI 移动应用收款' }
+};
+const currentProjectAliases = new Set(['.', './', '当前项目', '当前目录', '这个项目', '这个仓库', '这里']);
+const projectMarkerNames = [
+  'package.json',
+  'pom.xml',
+  'build.gradle',
+  'build.gradle.kts',
+  'settings.gradle',
+  'settings.gradle.kts',
+  'gradlew',
+  'mvnw',
+  'pyproject.toml',
+  'requirements.txt',
+  'Pipfile',
+  'poetry.lock',
+  'composer.json',
+  'artisan',
+  'manage.py'
+];
+const projectMarkerNameSet = new Set(projectMarkerNames);
+const skippedProjectDirs = new Set([
+  '.git',
+  '.hg',
+  '.svn',
+  '.cache',
+  '.gradle',
+  '.idea',
+  '.next',
+  '.nuxt',
+  '.pytest_cache',
+  '.tox',
+  '.Trash',
+  '.venv',
+  'Library',
+  '__pycache__',
+  'build',
+  'coverage',
+  'dist',
+  'node_modules',
+  'target',
+  'vendor'
+]);
+const sourceFileExtensions = new Set(['.java', '.kt', '.js', '.mjs', '.cjs', '.ts', '.tsx', '.py', '.php', '.cs']);
+const commentOnlyLinePattern = /^\s*(?:\/\/|#|\*|<!--)/;
+const webpayMarker = 'alipay\\.trade\\.page\\.pay|AlipayTradePagePay(Request|Model|Response)';
+const apppayMarker = 'alipay\\.trade\\.app\\.pay|AlipayTradeAppPay(Request|Model|Response)';
+const tradeQueryMarker = 'alipay\\.trade\\.query|AlipayTradeQuery(Request|Model|Response)|alipay_trade_query_response';
+const tradeRefundMarker = 'alipay\\.trade\\.refund|AlipayTradeRefund(Request|Model|Response)|alipay_trade_refund_response';
+const tradeRefundQueryMarker = 'alipay\\.trade\\.fastpay\\.refund\\.query|AlipayTradeFastpayRefundQuery(Request|Model|Response)|alipay_trade_fastpay_refund_query_response';
+const tradeCloseMarker = 'alipay\\.trade\\.close|AlipayTradeClose(Request|Model|Response)|alipay_trade_close_response';
+const tradeNotifyMarker = 'notify_url|notifyUrl|NotifyUrl|setNotifyUrl|异步通知';
+const aipayPaymentNeededMarker = 'Payment-Needed';
+const aipayPaymentProofMarker = 'Payment-Proof';
+const aipayPaymentValidationMarker = 'Payment-Validation';
+const aipayPaymentVerifyMarker = 'alipay\\.aipay\\.agent\\.payment\\.verify|AlipayAipayAgentPaymentVerify(Request|Model|Response)|alipay_aipay_agent_payment_verify_response';
+const aipayFulfillmentConfirmMarker = 'alipay\\.aipay\\.agent\\.fulfillment\\.confirm|AlipayAipayAgentFulfillmentConfirm(Request|Model|Response)|alipay_aipay_agent_fulfillment_confirm_response';
+const aipayMarker = `${aipayPaymentNeededMarker}|${aipayPaymentProofMarker}|${aipayPaymentVerifyMarker}|${aipayFulfillmentConfirmMarker}`;
+const internalPrefix = 'ALIPAY_AIPAY_INTERNAL:';
+const receiptKinds = Object.freeze({
+  startConfirmation: 'integration-start-confirmation',
+  checklist: 'integration-checklist-scope',
+  a2mExecution: 'integration-a2m-execution'
+});
+
+function parseArgs(argv) {
+  const command = argv[2];
+  const args = {};
+  for (let index = 3; index < argv.length; index += 1) {
+    const key = argv[index];
+    if (!key.startsWith('--')) throw new Error(`未知参数 ${key}`);
+    const value = argv[index + 1];
+    if (value === undefined || value.startsWith('--')) throw new Error(`参数 ${key} 缺少取值`);
+    const name = key.slice(2);
+    if (Object.prototype.hasOwnProperty.call(args, name)) throw new Error(`参数 ${key} 重复`);
+    args[name] = value;
+    index += 1;
+  }
+  return { command, args };
+}
+
+function required(args, name) {
+  const value = args[name];
+  if (typeof value !== 'string' || value.length === 0) throw new Error(`缺少参数 --${name}`);
+  return value;
+}
+
+function stripWrappingQuotes(value) {
+  const trimmed = value.trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+    (trimmed.startsWith('`') && trimmed.endsWith('`'))
+  ) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+
+function sanitizeProjectInput(raw) {
+  const value = stripWrappingQuotes(raw);
+  if (!value || value.length > 4096 || /[\u0000-\u001f\u007f`|]/.test(value)) {
+    throw new Error('project-input 必须是不含控制字符或 Markdown 边界的安全路径描述');
+  }
+  return value;
+}
+
+function normalizeBasePath(raw) {
+  const basePath = path.resolve(stripWrappingQuotes(raw));
+  if (!path.isAbsolute(basePath) || !fs.existsSync(basePath) || !fs.statSync(basePath).isDirectory()) {
+    throw new Error('base-path 必须是实际存在的绝对目录');
+  }
+  return fs.realpathSync(basePath);
+}
+
+function safeReaddir(directory) {
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function listProjectMarkers(directory) {
+  const markers = [];
+  for (const entry of safeReaddir(directory)) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    if (projectMarkerNameSet.has(entry.name)) {
+      markers.push(entry.name);
+    } else if (/\.(?:csproj|sln)$/i.test(entry.name)) {
+      markers.push(entry.name);
+    }
+  }
+  return markers.sort((left, right) => {
+    const leftIndex = projectMarkerNames.indexOf(left);
+    const rightIndex = projectMarkerNames.indexOf(right);
+    if (leftIndex >= 0 || rightIndex >= 0) {
+      if (leftIndex < 0) return 1;
+      if (rightIndex < 0) return -1;
+      return leftIndex - rightIndex;
+    }
+    return left.localeCompare(right);
+  });
+}
+
+function isRecognizableProjectRoot(directory) {
+  return listProjectMarkers(directory).length > 0;
+}
+
+function shouldSkipProjectDir(entry) {
+  return !entry.isDirectory() || entry.isSymbolicLink() || skippedProjectDirs.has(entry.name) || entry.name.startsWith('.');
+}
+
+function parseDepth(value) {
+  if (value === undefined) return 3;
+  if (!/^[0-4]$/.test(value)) throw new Error('max-depth 仅支持 0 到 4');
+  return Number(value);
+}
+
+function locateProjectCandidates(searchBasePath, maxDepth = 3, maxCandidates = 20, displayBasePath = searchBasePath, classificationBasePath = displayBasePath) {
+  const queue = [{ directory: searchBasePath, depth: 0 }];
+  const seen = new Set([searchBasePath]);
+  const candidates = [];
+
+  for (let index = 0; index < queue.length && candidates.length < maxCandidates; index += 1) {
+    const { directory, depth } = queue[index];
+    const markers = listProjectMarkers(directory);
+    if (markers.length > 0) {
+      const projectPath = fs.realpathSync(directory);
+      candidates.push({
+        projectPath,
+        relativePath: path.relative(displayBasePath, projectPath) || '.',
+        projectSelection: classifyExistingProject(
+          projectPath,
+          classificationBasePath,
+          projectPath === classificationBasePath ? '当前目录' : projectPath
+        ),
+        projectOrigin: 'EXISTING_PROJECT',
+        projectOriginLabel: '现有项目',
+        markers
+      });
+    }
+    if (depth >= maxDepth) continue;
+    const childDirs = safeReaddir(directory)
+      .filter((entry) => !shouldSkipProjectDir(entry))
+      .map((entry) => path.join(directory, entry.name))
+      .sort((left, right) => left.localeCompare(right));
+    for (const child of childDirs) {
+      let realChild;
+      try {
+        realChild = fs.realpathSync(child);
+      } catch {
+        continue;
+      }
+      if (seen.has(realChild)) continue;
+      seen.add(realChild);
+      queue.push({ directory: realChild, depth: depth + 1 });
+    }
+  }
+
+  return candidates;
+}
+
+function formatProjectCandidateHint(basePath, candidates) {
+  const visible = candidates.slice(0, 5);
+  if (visible.length === 0) return '';
+  return visible
+    .map((candidate) => {
+      const relative = candidate.relativePath || path.relative(basePath, candidate.projectPath) || '.';
+      return `${relative}（${candidate.markers.slice(0, 3).join('、')}）`;
+    })
+    .join('；');
+}
+
+function safeInline(value) {
+  return value.replace(/[`|\r\n]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function formatLocatedCandidateRows(candidates) {
+  if (candidates.length === 0) {
+    return '未找到可识别项目候选。可以提供更精确的项目文件夹，或说明要新建的目录。';
+  }
+  return candidates
+    .slice(0, 10)
+    .map((candidate, index) => {
+      const markers = candidate.markers.slice(0, 3).join('、');
+      return `${index + 1}. \`${safeInline(candidate.relativePath)}\`（识别依据：${markers}）`;
+    })
+    .join('\n');
+}
+
+function projectRootError(searchBasePath, prefix, displayBasePath = searchBasePath) {
+  const candidates = locateProjectCandidates(searchBasePath, 3, 5, displayBasePath, displayBasePath);
+  const markerHint = 'package.json、pom.xml、build.gradle、pyproject.toml、requirements.txt、composer.json、*.csproj 或 *.sln';
+  const candidateHint = formatProjectCandidateHint(displayBasePath, candidates);
+  if (candidateHint) {
+    return new Error(`${prefix}；请从候选项目中选择一个具体目录，或提供更精确路径。候选：${candidateHint}。如果要新建项目，请说明“在当前目录新建 pay-demo”或“新建项目”。项目根通常包含 ${markerHint}`);
+  }
+  return new Error(`${prefix}；未在指定目录下找到可识别项目候选。请提供现有服务端项目的具体目录，或说明“在当前目录新建 pay-demo”或“新建项目”。项目根通常包含 ${markerHint}`);
+}
+
+function isDefaultNewProjectRequest(input) {
+  return /^(?:帮我)?(?:新建|创建)(?:一个)?(?:默认)?(?:项目|目录)?$/u.test(input) ||
+    /^(?:帮我)?(?:新建|创建)(?:一个)?默认项目$/u.test(input);
+}
+
+function explicitNewArtifactRequest(input) {
+  return /^(?:请|麻烦)?(?:给我|帮我)?(?:新建|创建)(?:一个|个|一套)?[^,，。；;!?！？\r\n]{0,80}(?:项目|工程|网站|站点|商城|商店|店铺|应用程序|应用)(?:[,，。；;!?！？].*)?$/iu.test(input);
+}
+
+function looksLikeExplicitPath(value) {
+  return /^(?:[A-Za-z]:[\\/]|\\\\|[./~])/u.test(value) ||
+    /[\\/]/u.test(value) ||
+    /^[A-Za-z0-9._-]+$/u.test(value);
+}
+
+function extractNewProjectPath(input) {
+  const prefixed = '(?:请|麻烦)?(?:给我|帮我)?';
+  const currentRoot = '(?:当前目录|当前项目|这个项目|这个仓库|这里)';
+  const patterns = [
+    new RegExp(`^${prefixed}(?:在)?${currentRoot}(?:下|里)?(?:新建|创建)(?:一个)?(?:项目|目录)?\\s+(.+)$`, 'u'),
+    new RegExp(`^${prefixed}(?:新建|创建)(?:一个)?(?:项目|目录)(?:到|在)\\s*(.+)$`, 'u')
+  ];
+  for (const pattern of patterns) {
+    const match = input.match(pattern);
+    if (match?.[1]) {
+      const candidate = stripWrappingQuotes(match[1]);
+      if (looksLikeExplicitPath(candidate)) return candidate;
+    }
+  }
+
+  const simple = input.match(/^(?:请|麻烦)?(?:给我|帮我)?(?:新建|创建)(?:一个)?\s+(.+)$/u);
+  if (simple?.[1]) {
+    const candidate = stripWrappingQuotes(simple[1]);
+    if (looksLikeExplicitPath(candidate)) return candidate;
+  }
+  return '';
+}
+
+function isExplicitNewProjectRequest(input) {
+  return isDefaultNewProjectRequest(input) || explicitNewArtifactRequest(input) || extractNewProjectPath(input) !== '';
+}
+
+function parseExistingProjectPath(input) {
+  if (/^(?:请|麻烦)?(?:给我|帮我)?(?:在)?(?:当前目录|当前项目|这个项目|这个仓库|这里)(?:中|内|下|里)?新增.+$/u.test(input)) {
+    return '当前项目';
+  }
+  return input;
+}
+
+function hasDirectoryEntries(directory) {
+  try {
+    return safeReaddir(directory).length > 0;
+  } catch {
+    return true;
+  }
+}
+
+function prepareNewProject(projectPath) {
+  if (!path.isAbsolute(projectPath)) throw new Error('ROUTE_INSPECT_ERROR:projectPath 必须是绝对路径');
+  if (fs.existsSync(projectPath)) {
+    const stat = fs.lstatSync(projectPath);
+    if (stat.isSymbolicLink() || !stat.isDirectory() || hasDirectoryEntries(projectPath)) {
+      throw new Error('ROUTE_INSPECT_ERROR:NEW_PROJECT 路径必须尚不存在或为空且不能是符号链接');
+    }
+  }
+  return {
+    projectSelection: 'NEW_PROJECT',
+    projectOrigin: 'NEW_PROJECT',
+    projectOriginLabel: '本轮新建项目',
+    preparationStatus: 'READY'
+  };
+}
+
+function parseSingleJson(stdout, context) {
+  const trimmed = stdout.trim();
+  if (!trimmed) throw new Error(`${context} 未输出 JSON`);
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error();
+    return parsed;
+  } catch {
+    throw new Error(`${context} 未输出唯一合法 JSON 对象`);
+  }
+}
+
+function runUnixInspector(args, failureContext, jsonContext) {
+  const inspected = spawnSync('bash', [inspectorPath, ...args], {
+    encoding: 'utf8',
+    shell: false
+  });
+  if (inspected.status !== 0) {
+    const detail = (inspected.stderr || inspected.stdout || '').trim() || `退出码 ${inspected.status}`;
+    throw new Error(`${failureContext}失败：${detail}`);
+  }
+  return parseSingleJson(inspected.stdout, jsonContext);
+}
+
+function defaultNewProjectPath() {
+  const homeInput = process.env.HOME || os.homedir() || '';
+  if (!homeInput) throw new Error('无法确定用户目录；请提供明确的新项目路径');
+  const homePath = normalizeBasePath(homeInput);
+  const container = path.join(homePath, 'alipay-aipay-projects');
+  if (fs.existsSync(container)) {
+    const stat = fs.lstatSync(container);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      throw new Error('默认项目父目录不可用；请提供明确的新项目路径');
+    }
+  }
+  for (let index = 1; index <= 50; index += 1) {
+    const suffix = index === 1 ? '' : `-${index}`;
+    const candidate = path.join(container, `pay-demo${suffix}`);
+    if (!fs.existsSync(candidate)) return candidate;
+    const stat = fs.lstatSync(candidate);
+    if (stat.isDirectory() && !stat.isSymbolicLink() && !hasDirectoryEntries(candidate)) return candidate;
+  }
+  throw new Error('默认项目目录已被占用；请提供明确的新项目路径');
+}
+
+function parseNewProjectPath(input) {
+  const explicitPath = extractNewProjectPath(input);
+  if (explicitPath) return explicitPath;
+  if (isDefaultNewProjectRequest(input) || explicitNewArtifactRequest(input)) return defaultNewProjectPath();
+  return input;
+}
+
+function resolveAgainstBase(input, basePath) {
+  const candidate = path.isAbsolute(input) ? path.resolve(input) : path.resolve(basePath, input);
+  if (!path.isAbsolute(input)) {
+    const relative = path.relative(basePath, candidate);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+      throw new Error('相对项目路径必须位于 base-path 内；如需目录外项目，请提供绝对路径');
+    }
+  }
+  return candidate;
+}
+
+function resolveSearchBasePath(args, basePath) {
+  const rawInput = args['search-input'];
+  if (rawInput === undefined) return basePath;
+  const input = parseProjectSearchInput(sanitizeProjectInput(rawInput));
+  const candidate = currentProjectAliases.has(input) ? basePath : resolveAgainstBase(input, basePath);
+  const searchBasePath = fs.existsSync(candidate) ? fs.realpathSync(candidate) : candidate;
+  if (!fs.existsSync(searchBasePath) || !fs.statSync(searchBasePath).isDirectory()) {
+    throw new Error('search-input 必须指向实际存在的目录；可以使用当前目录、当前目录下子目录或绝对路径');
+  }
+  return searchBasePath;
+}
+
+function parseProjectSearchInput(input) {
+  const trimmed = stripWrappingQuotes(input);
+  if (/^(?:帮我)?(?:找|查找|定位)(?:一下)?(?:项目|项目目录|工程|工程目录)$/u.test(trimmed)) {
+    return '当前目录';
+  }
+  const patterns = [
+    /^(?:帮我)?(?:在|到)\s*(.+?)\s*(?:下|里|目录下|目录里)?(?:找|查找|定位)(?:一下)?(?:项目|项目目录|工程|工程目录)$/u,
+    /^(?:帮我)?(?:找|查找|定位)(?:一下)?\s*(.+?)\s*(?:下|里|目录下|目录里)?(?:的)?(?:项目|项目目录|工程|工程目录)$/u
+  ];
+  for (const pattern of patterns) {
+    const match = trimmed.match(pattern);
+    if (match?.[1]) return stripWrappingQuotes(match[1]);
+  }
+  return trimmed;
+}
+
+function classifyExistingProject(projectPath, basePath, rawInput) {
+  if (currentProjectAliases.has(rawInput)) return 'CURRENT_PROJECT';
+  const relative = path.relative(basePath, projectPath);
+  if (relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative))) {
+    return 'CURRENT_PROJECT';
+  }
+  return 'OTHER_PROJECT';
+}
+
+function isReadableDirectory(directory) {
+  try {
+    const stat = fs.statSync(directory);
+    if (!stat.isDirectory()) return false;
+    fs.accessSync(directory, fs.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sourceFiles(projectPath) {
+  const files = [];
+  const stack = [projectPath];
+  while (stack.length > 0) {
+    const directory = stack.pop();
+    for (const entry of safeReaddir(directory)) {
+      const entryPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.isSymbolicLink() && !skippedProjectDirs.has(entry.name)) stack.push(entryPath);
+        continue;
+      }
+      if (entry.isSymbolicLink() || !entry.isFile()) continue;
+      if (sourceFileExtensions.has(path.extname(entry.name))) files.push(entryPath);
+    }
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}
+
+function projectSnapshotFingerprint(projectPath) {
+  if (!path.isAbsolute(projectPath) || !isReadableDirectory(projectPath)) {
+    throw new Error('项目快照路径必须是可访问的绝对目录');
+  }
+  const canonicalPath = fs.realpathSync(projectPath);
+  const tracked = new Set(sourceFiles(canonicalPath));
+  for (const name of [...projectMarkerNames, '.alipay-sandbox.json', '.gitignore']) {
+    const candidate = path.join(canonicalPath, name);
+    try {
+      if (fs.statSync(candidate).isFile() && !fs.lstatSync(candidate).isSymbolicLink()) tracked.add(candidate);
+    } catch {
+      // Missing optional project facts do not enter the snapshot.
+    }
+  }
+  const hash = crypto.createHash('sha256');
+  hash.update(`project=${canonicalPath}\n`);
+  for (const file of [...tracked].sort((left, right) => left.localeCompare(right))) {
+    const stat = fs.statSync(file);
+    const relative = path.relative(canonicalPath, file);
+    hash.update(`${relative}\0${stat.size}\0`);
+    if (path.basename(file) === '.alipay-sandbox.json') {
+      hash.update(`${stat.mtimeMs}\n`);
+    } else {
+      hash.update(fs.readFileSync(file));
+      hash.update('\n');
+    }
+  }
+  return hash.digest('hex');
+}
+
+function encodeReceipt(payload) {
+  return Buffer.from(JSON.stringify(payload), 'utf8').toString('base64url');
+}
+
+function decodeReceipt(value, expectedKind) {
+  if (typeof value !== 'string' || !value) throw new Error('缺少 receipt');
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+  } catch {
+    throw new Error('receipt 不是合法编码');
+  }
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload) || payload.schema_ver !== 1 || payload.kind !== expectedKind) {
+    throw new Error('receipt 类型或版本非法');
+  }
+  return payload;
+}
+
+function scanPattern(files, pattern) {
+  const regex = new RegExp(pattern);
+  for (const file of files) {
+    let content;
+    try {
+      content = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue;
+    }
+    for (const line of content.split(/\r?\n/u)) {
+      if (!commentOnlyLinePattern.test(line) && regex.test(line)) return file;
+    }
+  }
+  return '';
+}
+
+function scanProjectRoute(productType, projectPath, projectSelection) {
+  if (!['aipay', 'webpay', 'apppay'].includes(productType)) {
+    throw new Error('ROUTE_INSPECT_ERROR:productType 非法');
+  }
+  if (!['CURRENT_PROJECT', 'OTHER_PROJECT', 'PREPARED_NEW_PROJECT'].includes(projectSelection)) {
+    throw new Error('ROUTE_INSPECT_ERROR:projectSelection 非法');
+  }
+  if (!path.isAbsolute(projectPath)) throw new Error('ROUTE_INSPECT_ERROR:projectPath 必须是绝对路径');
+  if (!isReadableDirectory(projectPath)) throw new Error('ROUTE_INSPECT_ERROR:项目路径不可访问');
+
+  const projectOrigin = projectSelection === 'PREPARED_NEW_PROJECT' ? 'NEW_PROJECT' : 'EXISTING_PROJECT';
+  const projectOriginLabel = projectSelection === 'PREPARED_NEW_PROJECT' ? '本轮新建项目' : '现有项目';
+  const targetMarker = productType === 'aipay' ? aipayMarker : productType === 'webpay' ? webpayMarker : apppayMarker;
+  const files = sourceFiles(projectPath);
+  const otherProducts = [];
+
+  if (scanPattern(files, webpayMarker) && productType !== 'webpay') otherProducts.push('AI 网页应用收款');
+  if (scanPattern(files, apppayMarker) && productType !== 'apppay') otherProducts.push('AI 移动应用收款');
+  if (scanPattern(files, aipayMarker) && productType !== 'aipay') otherProducts.push('AI 按量付费');
+
+  const otherProductsText = otherProducts.length > 0 ? otherProducts.join(',') : '无';
+  let integrationStatus;
+  let evidence;
+
+  if (!scanPattern(files, targetMarker)) {
+    if (otherProductsText === '无') {
+      integrationStatus = 'NO_PAYMENT';
+      evidence = projectSelection === 'PREPARED_NEW_PROJECT'
+        ? '固定检查器扫描本轮已初始化的新项目，未发现目标产品或其他受支持支付代码'
+        : '固定检查器未发现目标产品或其他受支持支付代码';
+    } else {
+      integrationStatus = 'OTHER_PRODUCT_ONLY';
+      evidence = '固定检查器只发现其他受支持支付产品代码';
+    }
+  } else {
+    const requiredPatterns = productType === 'aipay'
+      ? [aipayPaymentNeededMarker, aipayPaymentProofMarker, aipayPaymentVerifyMarker, aipayFulfillmentConfirmMarker, aipayPaymentValidationMarker]
+      : productType === 'webpay'
+        ? [webpayMarker, tradeQueryMarker, tradeRefundMarker, tradeRefundQueryMarker, tradeCloseMarker, tradeNotifyMarker]
+        : [apppayMarker, tradeQueryMarker, tradeRefundMarker, tradeRefundQueryMarker, tradeCloseMarker, tradeNotifyMarker];
+    const missing = requiredPatterns.filter((pattern) => !scanPattern(files, pattern));
+    integrationStatus = 'TARGET_PARTIAL';
+    evidence = missing.length === 0
+      ? '固定检查器逐项发现目标产品入口及全部核心接口标记，但静态扫描不能证明配置、安全、测试和 checklist 完成；必须进入 Integration 验证分支'
+      : '固定检查器发现目标产品代码，但至少一个核心接口标记缺失；不得按完整集成路由';
+  }
+
+  return {
+    projectSelection,
+    projectOrigin,
+    projectOriginLabel,
+    integrationStatus,
+    evidence,
+    otherProducts: otherProductsText
+  };
+}
+
+function runResolveProject(args) {
+  const intent = required(args, 'intent');
+  if (!['existing', 'new'].includes(intent)) throw new Error('intent 非法，仅支持 existing、new');
+  const basePath = normalizeBasePath(required(args, 'base-path'));
+  const input = sanitizeProjectInput(required(args, 'project-input'));
+
+  if (intent === 'existing') {
+    if (isExplicitNewProjectRequest(input)) {
+      throw new Error('明确新建项目请求必须使用 --intent new，不能改用当前项目');
+    }
+    const existingInput = parseExistingProjectPath(input);
+    const candidate = currentProjectAliases.has(existingInput) ? basePath : resolveAgainstBase(existingInput, basePath);
+    const projectPath = fs.existsSync(candidate) ? fs.realpathSync(candidate) : candidate;
+    if (!fs.existsSync(projectPath) || !fs.statSync(projectPath).isDirectory()) {
+      throw new Error('现有项目路径不可访问；请提供当前目录内相对路径或实际存在的绝对路径');
+    }
+    if (!isRecognizableProjectRoot(projectPath)) {
+      const prefix = currentProjectAliases.has(existingInput)
+        ? '当前目录不是可识别的项目根，不能直接作为现有项目扫描'
+        : '该路径未识别到项目根标记，不能确认是服务端项目根';
+      const searchBasePath = currentProjectAliases.has(input) ? basePath : projectPath;
+      throw projectRootError(searchBasePath, prefix, basePath);
+    }
+    return JSON.stringify({
+      projectPath,
+      projectSelection: classifyExistingProject(projectPath, basePath, existingInput),
+      projectOrigin: 'EXISTING_PROJECT',
+      projectOriginLabel: '现有项目'
+    });
+  }
+
+  const newPathInput = sanitizeProjectInput(parseNewProjectPath(input));
+  if (currentProjectAliases.has(newPathInput)) {
+    throw new Error('新项目必须明确尚不存在或为空的子目录名');
+  }
+  const projectPath = resolveAgainstBase(newPathInput, basePath);
+  const route = isWindowsPlatform()
+    ? prepareNewProject(projectPath)
+    : runUnixInspector(['prepare-new', projectPath], '新项目路径检查', '新项目路径检查器');
+  return JSON.stringify({ projectPath, ...route });
+}
+
+function runLocateProjects(args) {
+  const basePath = normalizeBasePath(required(args, 'base-path'));
+  const searchBasePath = resolveSearchBasePath(args, basePath);
+  const maxDepth = parseDepth(args['max-depth']);
+  const format = args.format || 'json';
+  if (!['json', 'message'].includes(format)) throw new Error('format 仅支持 json 或 message');
+  const candidates = locateProjectCandidates(searchBasePath, maxDepth, 20, basePath, basePath);
+  if (format === 'message') {
+    return renderMessage('integration.project_candidates.select', 'DEFAULT', {
+      searchBasePath,
+      candidateRows: formatLocatedCandidateRows(candidates)
+    });
+  }
+  return JSON.stringify({
+    basePath,
+    searchBasePath,
+    maxDepth,
+    candidates,
+    nextAction: '请选择一个候选项目目录作为现有项目，或说明要新建的目录，例如“在当前目录新建 pay-demo”或“新建项目”。'
+  });
+}
+
+function normalizeLanguage(input) {
+  const value = input.trim();
+  const compact = value.toLowerCase().replace(/[\s_.-]+/g, '');
+  if (compact === 'java') return 'Java';
+  if (compact === 'python' || compact === 'py' || compact === 'python3') return 'Python';
+  if (compact === 'nodejs' || compact === 'node' || compact === 'javascript' || compact === 'js') return 'Node.js';
+  if (compact === 'c#' || compact === 'csharp' || compact === 'dotnet' || compact === 'net') return 'C#';
+  if (compact === 'php') return 'PHP';
+  throw new Error('服务端语言非法，仅支持 Java、Python、Node.js、C#、PHP');
+}
+
+function startConfirmationFacts(args) {
+  const productType = required(args, 'product-type');
+  const mapping = productVariants[productType];
+  if (!mapping) throw new Error('product-type 非法，仅支持 aipay、webpay、apppay');
+
+  const projectPath = required(args, 'project-path');
+  const projectSelection = required(args, 'project-selection');
+  const language = normalizeLanguage(required(args, 'language'));
+  const framework = required(args, 'framework');
+  const productName = args['product-name'] || mapping.productName;
+  if (productName !== mapping.productName) throw new Error('product-name 与 product-type 不匹配');
+  if (!path.isAbsolute(projectPath)) throw new Error('project-path 必须是绝对路径');
+
+  const route = isWindowsPlatform()
+    ? scanProjectRoute(productType, projectPath, projectSelection)
+    : runUnixInspector(['scan', productType, projectPath, projectSelection], '项目检查', '项目检查器');
+  if (route.projectSelection !== projectSelection) throw new Error('项目检查结果与本轮 projectSelection 不一致');
+  const existing = projectSelection === 'CURRENT_PROJECT' || projectSelection === 'OTHER_PROJECT';
+  const preparedNew = projectSelection === 'PREPARED_NEW_PROJECT';
+  if (
+    !(preparedNew && route.projectOrigin === 'NEW_PROJECT' && route.projectOriginLabel === '本轮新建项目') &&
+    !(existing && route.projectOrigin === 'EXISTING_PROJECT' && route.projectOriginLabel === '现有项目')
+  ) {
+    throw new Error('项目来源与本轮项目选择不一致');
+  }
+  if (!['TARGET_PARTIAL', 'OTHER_PRODUCT_ONLY', 'NO_PAYMENT'].includes(route.integrationStatus)) {
+    throw new Error('项目集成状态不允许发起代码开发确认');
+  }
+  if (typeof route.evidence !== 'string' || typeof route.otherProducts !== 'string') {
+    throw new Error('项目检查结果缺少必要事实字段');
+  }
+
+  return {
+    productType,
+    variant: mapping.variant,
+    productName,
+    projectPath: fs.realpathSync(projectPath),
+    projectSelection,
+    language,
+    framework,
+    route,
+    projectFingerprint: projectSnapshotFingerprint(projectPath)
+  };
+}
+
+function confirmationReceipt(facts) {
+  return encodeReceipt({
+    schema_ver: 1,
+    kind: receiptKinds.startConfirmation,
+    product_type: facts.productType,
+    product_name: facts.productName,
+    project_path: facts.projectPath,
+    project_selection: facts.projectSelection,
+    language: facts.language,
+    framework: facts.framework,
+    project_fingerprint: facts.projectFingerprint,
+    route: {
+      project_origin: facts.route.projectOrigin,
+      project_origin_label: facts.route.projectOriginLabel,
+      integration_status: facts.route.integrationStatus,
+      evidence: facts.route.evidence,
+      other_products: facts.route.otherProducts
+    }
+  });
+}
+
+function renderStartConfirmation(facts) {
+  return renderMessage('integration.start.confirm', facts.variant, {
+    productName: facts.productName,
+    projectPath: facts.projectPath,
+    projectOriginLabel: facts.route.projectOriginLabel,
+    integrationStatus: facts.route.integrationStatus,
+    otherProducts: facts.route.otherProducts,
+    language: facts.language,
+    framework: facts.framework,
+    nextFlow: 'integration'
+  });
+}
+
+export function createStartConfirmation(args) {
+  const facts = startConfirmationFacts(args);
+  return { message: renderStartConfirmation(facts), receipt: confirmationReceipt(facts) };
+}
+
+export function validateStartConfirmationReceipt(receipt) {
+  const saved = decodeReceipt(receipt, receiptKinds.startConfirmation);
+  const facts = startConfirmationFacts({
+    'product-type': saved.product_type,
+    'product-name': saved.product_name,
+    'project-path': saved.project_path,
+    'project-selection': saved.project_selection,
+    language: saved.language,
+    framework: saved.framework
+  });
+  const currentReceipt = confirmationReceipt(facts);
+  if (currentReceipt === receipt) return { valid: true, receipt, productType: saved.product_type };
+  return {
+    valid: false,
+    receipt: currentReceipt,
+    message: renderStartConfirmation(facts),
+    productType: saved.product_type
+  };
+}
+
+export function createChecklistScopeReceipt(projectPath) {
+  const canonicalPath = fs.realpathSync(required({ projectPath }, 'projectPath'));
+  return encodeReceipt({
+    schema_ver: 1,
+    kind: receiptKinds.checklist,
+    project_path: canonicalPath,
+    project_fingerprint: projectSnapshotFingerprint(canonicalPath)
+  });
+}
+
+function validateChecklistScopeReceipt(receipt, expectedProjectPath) {
+  const payload = decodeReceipt(receipt, receiptKinds.checklist);
+  const canonicalExpectedPath = fs.realpathSync(expectedProjectPath);
+  return payload.project_path === canonicalExpectedPath
+    && projectSnapshotFingerprint(canonicalExpectedPath) === payload.project_fingerprint;
+}
+
+function a2mExecutionFacts(args) {
+  const projectPath = fs.realpathSync(required(args, 'project-path'));
+  if (!isReadableDirectory(projectPath)) throw new Error('A2M 联调项目路径不可访问');
+  const method = required(args, 'http-method').toUpperCase();
+  if (!['GET', 'POST'].includes(method)) throw new Error('http-method 仅支持 GET 或 POST');
+  let serviceUrl;
+  try {
+    serviceUrl = new URL(required(args, 'service-url'));
+  } catch {
+    throw new Error('service-url 不是合法 URL');
+  }
+  if (!['http:', 'https:'].includes(serviceUrl.protocol) || serviceUrl.username || serviceUrl.password || serviceUrl.hash) {
+    throw new Error('service-url 只允许不含凭据和 fragment 的 HTTP(S) URL');
+  }
+  let requestBodyHash = '';
+  const requestBodyFile = args['request-body-file'];
+  if (method === 'POST') {
+    if (!requestBodyFile || !path.isAbsolute(requestBodyFile)) throw new Error('POST 必须传入绝对 --request-body-file');
+    const stat = fs.lstatSync(requestBodyFile);
+    if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('request-body-file 必须是普通文件且不能是符号链接');
+    requestBodyHash = crypto.createHash('sha256').update(fs.readFileSync(requestBodyFile)).digest('hex');
+  } else if (requestBodyFile !== undefined) {
+    throw new Error('GET 禁止传入 request-body-file');
+  }
+  return {
+    project_path: projectPath,
+    project_fingerprint: projectSnapshotFingerprint(projectPath),
+    service_url: serviceUrl.href,
+    http_method: method,
+    request_body_sha256: requestBodyHash
+  };
+}
+
+function a2mExecutionReceipt(facts, state = 'READY') {
+  return encodeReceipt({
+    schema_ver: 1,
+    kind: receiptKinds.a2mExecution,
+    state,
+    ...facts
+  });
+}
+
+export function guardA2mExecution(args) {
+  const facts = a2mExecutionFacts(args);
+  const priorReceipt = args['prior-receipt'];
+  if (!priorReceipt) return { decision: 'RUN', receipt: a2mExecutionReceipt(facts) };
+  const prior = decodeReceipt(priorReceipt, receiptKinds.a2mExecution);
+  const unchanged = ['project_path', 'project_fingerprint', 'service_url', 'http_method', 'request_body_sha256']
+    .every((key) => prior[key] === facts[key]);
+  if (!unchanged) return { decision: 'RUN', receipt: a2mExecutionReceipt(facts) };
+  if (prior.state === 'PASSED') return { decision: 'REUSE_PASSED', receipt: priorReceipt };
+  if (prior.state === 'FAILED') return { decision: 'BLOCK_UNCHANGED', receipt: priorReceipt };
+  return { decision: 'UNKNOWN_PREVIOUS_EXECUTION', receipt: priorReceipt };
+}
+
+export function completeA2mExecution(receipt, outcome) {
+  if (!['PASSED', 'FAILED', 'INTERRUPTED'].includes(outcome)) {
+    throw new Error('outcome 仅支持 PASSED、FAILED、INTERRUPTED');
+  }
+  const prior = decodeReceipt(receipt, receiptKinds.a2mExecution);
+  if (prior.state !== 'READY') throw new Error('A2M execution receipt 已经终态化');
+  const { schema_ver, kind, state, ...facts } = prior;
+  void schema_ver;
+  void kind;
+  void state;
+  return a2mExecutionReceipt(facts, outcome);
+}
+
+function runContextRequired(args) {
+  return renderMessage('integration.context.required', 'DEFAULT', {
+    missingItems: required(args, 'missing-items')
+  });
+}
+
+function runProductClarify() {
+  return renderMessage('product.clarify', 'DEFAULT', {});
+}
+
+function runWindowsSandboxSetup() {
+  return renderMessage('sandbox.windows.manual_setup', 'DEFAULT', {});
+}
+
+function runLocalAcceptanceNotice() {
+  return renderMessage('integration.local_acceptance.notice', 'DEFAULT', {});
+}
+
+function runA2mTestStart() {
+  return renderMessage('a2m.test.start', 'DEFAULT', {});
+}
+
+function runServiceNotReady(args) {
+  return renderMessage('integration.service.not_ready', 'DEFAULT', {
+    recoveryAction: required(args, 'recovery-action')
+  });
+}
+
+function runSafetyCloseout(args) {
+  const variant = required(args, 'variant');
+  if (!['AIPAY', 'WEBPAY', 'APPPAY'].includes(variant)) throw new Error('variant 非法，仅支持 AIPAY、WEBPAY、APPPAY');
+  return renderMessage('integration.safety.closeout', variant, {
+    acceptanceSummary: required(args, 'acceptance-summary')
+  });
+}
+
+function runWindowsSandboxSummary(args) {
+  const summary = renderMessage('sandbox.environment.summary', 'DEFAULT', {
+    productName: required(args, 'product-name'),
+    configPath: required(args, 'config-path'),
+    environmentRows: required(args, 'environment-rows')
+  });
+  const reminder = renderMessage('sandbox.environment.reminder', 'WINDOWS', {});
+  return `${summary}\n\n${reminder}`;
+}
+
+async function readStdin() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+  return input.trim() ? JSON.parse(input) : {};
+}
+
+function checklistInputFromArgs(args) {
+  const mapping = {
+    'overall-result': 'overallResult',
+    'failed-items': 'failedItems',
+    'manual-items': 'manualItems',
+    'sandbox-result': 'sandboxResult',
+    'webpay-experience-result': 'webpayExperienceResult',
+    'sandbox-config-state': 'sandboxConfigState',
+    'blocking-defect-state': 'blockingDefectState',
+    'execution-mode': 'executionMode',
+    'next-flow-reminder': 'nextFlowReminder'
+  };
+  const hasTypedInput = Object.keys(mapping).some((name) => Object.prototype.hasOwnProperty.call(args, name));
+  if (!hasTypedInput) return null;
+
+  const input = {};
+  for (const [argName, fieldName] of Object.entries(mapping)) {
+    if (Object.prototype.hasOwnProperty.call(args, argName)) input[fieldName] = args[argName];
+  }
+  for (const requiredName of [
+    'overall-result',
+    'failed-items',
+    'manual-items',
+    'sandbox-config-state',
+    'blocking-defect-state',
+    'execution-mode',
+    'next-flow-reminder'
+  ]) {
+    required(args, requiredName);
+  }
+  return input;
+}
+
+async function runChecklistResult(args) {
+  const variant = required(args, 'variant');
+  if (!['AIPAY', 'WEBPAY', 'APPPAY'].includes(variant)) throw new Error('variant 非法，仅支持 AIPAY、WEBPAY、APPPAY');
+  const scopeReceipt = required(args, 'scope-receipt');
+  const projectPath = required(args, 'project-path');
+  if (!validateChecklistScopeReceipt(scopeReceipt, projectPath)) {
+    throw new Error('项目在当前 checklist 开始后发生变化；必须重新进入 checklist 阶段并重跑受影响检查');
+  }
+  const input = checklistInputFromArgs(args) || await readStdin();
+  const rendered = renderMessage('integration.checklist.result', variant, input);
+  if (input.executionMode === '仅代码开发') {
+    emitTerminalMetric({ rootIntent: 'integration_only', productType: variant });
+  }
+  return rendered;
+}
+
+async function main() {
+  const { command, args } = parseArgs(process.argv);
+  if (command === 'resolve-project') {
+    console.log(runResolveProject(args));
+    return;
+  }
+  if (command === 'locate-projects') {
+    console.log(runLocateProjects(args));
+    return;
+  }
+  if (command === 'start-confirm') {
+    const result = createStartConfirmation(args);
+    console.log(result.message);
+    process.stderr.write(`${internalPrefix}PROJECT_CONFIRM_RECEIPT=${result.receipt}\n`);
+    return;
+  }
+  if (command === 'checklist-scope-receipt') {
+    process.stderr.write(`${internalPrefix}CHECKLIST_SCOPE_RECEIPT=${createChecklistScopeReceipt(required(args, 'project-path'))}\n`);
+    return;
+  }
+  if (command === 'a2m-execution-guard') {
+    process.stderr.write(`${internalPrefix}A2M_EXECUTION=${JSON.stringify(guardA2mExecution(args))}\n`);
+    return;
+  }
+  if (command === 'a2m-execution-result') {
+    const receipt = completeA2mExecution(required(args, 'receipt'), required(args, 'outcome'));
+    process.stderr.write(`${internalPrefix}A2M_EXECUTION=${JSON.stringify({ decision: 'RECORDED', receipt })}\n`);
+    return;
+  }
+  if (command === 'context-required') {
+    console.log(runContextRequired(args));
+    return;
+  }
+  if (command === 'product-clarify') {
+    console.log(runProductClarify());
+    return;
+  }
+  if (command === 'windows-sandbox-setup') {
+    console.log(runWindowsSandboxSetup());
+    return;
+  }
+  if (command === 'local-acceptance-notice') {
+    console.log(runLocalAcceptanceNotice());
+    return;
+  }
+  if (command === 'a2m-test-start') {
+    console.log(runA2mTestStart());
+    return;
+  }
+  if (command === 'service-not-ready') {
+    console.log(runServiceNotReady(args));
+    return;
+  }
+  if (command === 'safety-closeout') {
+    console.log(runSafetyCloseout(args));
+    return;
+  }
+  if (command === 'windows-sandbox-summary') {
+    console.log(runWindowsSandboxSummary(args));
+    return;
+  }
+  if (command === 'checklist-result') {
+    console.log(await runChecklistResult(args));
+    return;
+  }
+  throw new Error('用法: integration_message_runner.mjs <resolve-project|locate-projects|start-confirm|checklist-scope-receipt|a2m-execution-guard|a2m-execution-result|context-required|product-clarify|windows-sandbox-setup|local-acceptance-notice|a2m-test-start|service-not-ready|safety-closeout|windows-sandbox-summary|checklist-result> ...');
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(`INTEGRATION_MESSAGE_ERROR:${error.message}`);
+    process.exitCode = 1;
+  });
+}