openxiangda 1.0.269 → 1.0.271

package/lib/cli.js

@@ -164,6 +164,7 @@ const {
   resolveEnvironmentTarget,
   saveCandidate,
   sha256Canonical,
+  withLegacyReleaseForwardedFlags,
   withManagedReleaseForwardedFlags,
   withOnlineBaselineAdoptionFlags,
   withReleaseClientSessionArgs,
@@ -299,6 +300,7 @@ async function mainImpl(argv) {
   if (command === 'workflow') return workflow(rest);
   if (command === 'automation') return automation(rest);
   if (command === 'data-view') return dataView(rest);
+  if (command === 'webhook') return webhook(rest);
   if (command === 'scope') return scope(rest);
   if (command === 'route') return route(rest);
   if (command === 'public-access') return publicAccess(rest);
@@ -344,7 +346,7 @@ Usage:
   openxiangda status <runId> [--environment preproduction|production] [--json]
   openxiangda retry <runId> [--environment preproduction|production] [--json]
   openxiangda rollback <preproduction|production> --to <appReleaseId> [--json]
-  openxiangda release publish|begin|status|integration-status|renew|end [--change id] [--profile name] [--adopt-online-baseline --adoption-reason text] [--watch] [--json]
+  openxiangda release publish|begin|status|integration-status|renew|end [--change id] [--profile name] [--replace-manifest --reason text] [--adopt-online-baseline --adoption-reason text] [--watch] [--json]
   openxiangda release ship|candidate|deploy|reconcile|test|fail|promote|rollback [--candidate id] [--deployment id] [--environment target] [--replace-manifest] [--allow-runtime-rollback --reason text] [--adopt-online-baseline --adoption-reason text] [--confirm-production] [--json]
   openxiangda task status --change <id> [--profile name] [--watch] [--json]
   openxiangda release backend-head|backend-list|backend-detail|backend-diff|backend-rollback|backend-abort|backend-retry [releaseId] [--profile name] [--json]
@@ -389,6 +391,7 @@ Usage:
   openxiangda automation diagnose <automationCode|automationId> [--redact] [--json]
   openxiangda automation publish|enable|disable <automationCode|automationId>
   openxiangda data-view list|get|create|update|upsert|delete|status|refresh|query|stats <dataViewCode> [--profile name] [--json]
+  openxiangda webhook list|get|create|update|upsert|disable|deliveries|delivery [webhookCode] [deliveryId] [--json-file file] [--json]
   openxiangda scope dimension-list|dimension-upsert|grant-source-list|grant-source-upsert|policy-list|policy-upsert|sync|explain [code] [--json-file file]
   openxiangda route list|get|create|update|upsert|delete [--json-file file] [--dry-run] [--write-manifest]
   openxiangda public-access list|get|create|update|upsert|delete|ticket-create|session-test|grant-check [--json-file file]
@@ -1633,6 +1636,16 @@ async function runOpenXiangdaInProcess(args, options = {}) {
   let stdout = '';
   const originalWrite = process.stdout.write;
   const previousExitCode = process.exitCode;
+  const environment = Object.entries(options.env || {}).map(([key, value]) => ({
+    key,
+    existed: Object.prototype.hasOwnProperty.call(process.env, key),
+    value: process.env[key],
+    next: value,
+  }));
+  for (const entry of environment) {
+    if (entry.next === undefined || entry.next === null) delete process.env[entry.key];
+    else process.env[entry.key] = String(entry.next);
+  }
   process.exitCode = undefined;
   process.stdout.write = function capture(chunk, encoding, callback) {
     stdout += Buffer.isBuffer(chunk) ? chunk.toString(encoding) : String(chunk);
@@ -1660,6 +1673,10 @@ async function runOpenXiangdaInProcess(args, options = {}) {
     }
     throw error;
   } finally {
+    for (const entry of environment) {
+      if (entry.existed) process.env[entry.key] = entry.value;
+      else delete process.env[entry.key];
+    }
     process.stdout.write = originalWrite;
     process.exitCode = previousExitCode;
   }
@@ -2109,7 +2126,7 @@ function decorateEnvironmentReleaseSteps(steps, target, flags = {}) {
   for (const step of steps) {
     step.args = managedEnvironment
       ? withManagedReleaseForwardedFlags(step.id, step.args, flags)
-      : withOnlineBaselineAdoptionFlags(step.args, flags);
+      : withLegacyReleaseForwardedFlags(step.id, step.args, flags);
     if (!managedEnvironment) {
       step.command = commandFromArgs(step.args);
       continue;
@@ -2200,11 +2217,104 @@ function assertReleasePublishAdoptionScope(steps = [], flags = {}) {
   }
 }
 
+function assertReleasePublishManifestReplacementFlags(flags = {}) {
+  const replacementRequested = Boolean(flags['replace-manifest']);
+  const reasonSupplied = Object.prototype.hasOwnProperty.call(flags, 'reason');
+  const reason = String(flags.reason || '').trim();
+  if (!replacementRequested && reasonSupplied && !flags['allow-runtime-rollback']) {
+    const error = new Error(
+      'RELEASE_PUBLISH_REPLACEMENT_FLAG_REQUIRED: --reason 必须与 --replace-manifest 一起使用；命令已在任何发布租约或资源写入前终止'
+    );
+    error.code = 'RELEASE_PUBLISH_REPLACEMENT_FLAG_REQUIRED';
+    throw error;
+  }
+  if (replacementRequested && reason.length < 8) {
+    const error = new Error(
+      'RELEASE_PUBLISH_REPLACEMENT_REASON_REQUIRED: --replace-manifest 必须提供至少 8 个字符的 --reason；命令已在任何发布租约或资源写入前终止'
+    );
+    error.code = 'RELEASE_PUBLISH_REPLACEMENT_REASON_REQUIRED';
+    throw error;
+  }
+}
+
+function assertReleasePublishManifestReplacementScope(steps = [], flags = {}) {
+  if (!flags['replace-manifest']) return;
+  const replacementSteps = steps.filter(
+    step =>
+      step.id === 'backend-stage' &&
+      step.args?.includes('--replace-manifest') &&
+      (step.args.includes('--only') || step.args.includes('--code'))
+  );
+  if (replacementSteps.length !== 1) {
+    const error = new Error(
+      'RELEASE_PUBLISH_REPLACEMENT_SCOPE_REQUIRED: 当前发布计划没有唯一的精确 Backend stage 可接收 --replace-manifest；命令已在任何发布租约或资源写入前终止'
+    );
+    error.code = 'RELEASE_PUBLISH_REPLACEMENT_SCOPE_REQUIRED';
+    throw error;
+  }
+}
+
 function changeIdFromStep(step) {
   const index = step.args.indexOf('--change');
   return index >= 0 ? step.args[index + 1] : 'change';
 }
 
+function assertLegacyPageReleaseStaged(step, changeId, target) {
+  if (step.stagedKind !== 'PageRelease') return;
+  const file = stagedResourcesFileForChange(changeId, target.deploymentId);
+  const resources = fs.existsSync(file)
+    ? normalizeStagedAppReleaseResources(
+        JSON.parse(fs.readFileSync(file, 'utf8'))
+      )
+    : [];
+  const pageRelease = resources.find(resource => resource.kind === 'PageRelease');
+  if (pageRelease) {
+    assertLegacyPageReleaseCoverage(step, pageRelease);
+    return;
+  }
+  const error = new Error(
+    'PAGE_RELEASE_STAGE_EVIDENCE_REQUIRED: legacy workspace publish 未记录 staged PageRelease；已阻止 Root finalize，工作区发布脚本必须遵守 OPENXIANGDA_PAGE_STAGE_ONLY=1 并通过当前 OpenXiangda CLI 登记 staged child'
+  );
+  error.code = 'PAGE_RELEASE_STAGE_EVIDENCE_REQUIRED';
+  throw error;
+}
+
+function legacyWorkspaceStepPageCodes(step = {}) {
+  const onlyIndex = Array.isArray(step.args) ? step.args.indexOf('--only') : -1;
+  if (onlyIndex < 0) return [];
+  return unique(
+    String(step.args[onlyIndex + 1] || '')
+      .split(',')
+      .map(value => value.trim())
+      .filter(value => value.startsWith('pages/'))
+      .map(value => value.slice('pages/'.length))
+      .filter(Boolean)
+  ).sort();
+}
+
+function assertLegacyPageReleaseCoverage(step, pageRelease) {
+  const expected = legacyWorkspaceStepPageCodes(step);
+  const actual = unique(
+    Array.isArray(pageRelease?.metadata?.selectedPageCodes)
+      ? pageRelease.metadata.selectedPageCodes
+          .map(value => String(value || '').trim())
+          .filter(Boolean)
+      : []
+  ).sort();
+  if (
+    expected.length > 0 &&
+    expected.length === actual.length &&
+    expected.every((code, index) => code === actual[index])
+  ) {
+    return;
+  }
+  const error = new Error(
+    `PAGE_RELEASE_STAGE_SCOPE_MISMATCH: staged PageRelease selectedPageCodes 与 workspace 计划不一致；expected=${expected.join(',') || '-'} actual=${actual.join(',') || '-'}`
+  );
+  error.code = 'PAGE_RELEASE_STAGE_SCOPE_MISMATCH';
+  throw error;
+}
+
 async function publishWorkspaceRelease(config, target, flags = {}) {
   const changeId = readStringFlag(flags, 'change');
   const deploymentId = readStringFlag(flags, 'deployment-id') || null;
@@ -2214,6 +2324,7 @@ async function publishWorkspaceRelease(config, target, flags = {}) {
     fail('用法: openxiangda release publish --change <id> --profile <name>');
   }
   assertReleasePublishAdoptionFlags(flags);
+  assertReleasePublishManifestReplacementFlags(flags);
   assertManagedRuntimeRollbackFlags(flags);
   const releaseCandidate = flags.__verifiedCandidate
     ? assertLocalCandidate(flags.__verifiedCandidate)
@@ -2241,6 +2352,7 @@ async function publishWorkspaceRelease(config, target, flags = {}) {
   );
   decorateEnvironmentReleaseSteps(steps, target, flags);
   assertReleasePublishAdoptionScope(steps, flags);
+  assertReleasePublishManifestReplacementScope(steps, flags);
   const releaseScope = getSddChangeScope({
     cwd: process.cwd(),
     configText: readWorkspaceConfigText(),
@@ -2262,6 +2374,12 @@ async function publishWorkspaceRelease(config, target, flags = {}) {
     runtimeMode: plan.workspace.runtimeMode,
     targets: plan.activationTargets,
     commands: steps.map(step => step.command),
+    executionSteps: steps.map(step => ({
+      id: step.id,
+      command: step.command,
+      env: step.env || {},
+      stagedKind: step.stagedKind || null,
+    })),
     candidateHash: releaseCandidate?.candidateHash || null,
   });
   if (flags['dry-run']) {
@@ -2377,6 +2495,7 @@ async function publishWorkspaceRelease(config, target, flags = {}) {
       ...steps.map(step => ({
         id: step.id,
         command: step.command,
+        env: step.env || {},
         stagedKind: step.stagedKind,
         status: 'pending',
       })),
@@ -2476,7 +2595,10 @@ async function publishWorkspaceRelease(config, target, flags = {}) {
         execution
       );
       warn(`发布步骤开始: ${step.id}`);
-      const result = await runOpenXiangdaInProcess(step.args);
+      const result = await runOpenXiangdaInProcess(step.args, {
+        env: step.env,
+      });
+      assertLegacyPageReleaseStaged(step, changeId, target);
       journalStep.status = 'completed';
       journalStep.completedAt = new Date().toISOString();
       journalStep.result = summarizeReleaseStepResult(result);
@@ -5378,7 +5500,7 @@ async function release(args) {
   const { flags, positional } = parseArgs(rest);
   if (wantsSubcommandHelp(subcommand, flags)) {
     print([
-      '用法: openxiangda release publish|begin|status|explain|integration-status|renew|end [--change id] [--profile name] [--adopt-online-baseline --adoption-reason text] [--json]',
+      '用法: openxiangda release publish|begin|status|explain|integration-status|renew|end [--change id] [--profile name] [--replace-manifest --reason text] [--adopt-online-baseline --adoption-reason text] [--json]',
       '      openxiangda release ship|candidate|deploy|reconcile|test|fail|promote|rollback [--candidate id] [--deployment id] [--environment target] [--replace-manifest] [--allow-runtime-rollback --reason text] [--adopt-online-baseline --adoption-reason text] [--confirm-production] [--json]',
       '      openxiangda release backend-head|backend-list|backend-detail|backend-diff|backend-rollback|backend-abort|backend-retry [releaseId] [--profile name] [--json]',
       '      openxiangda release app-capture|app-head|app-list|app-detail|app-diff|app-post-commit|app-retry|app-prepare|app-verify|app-activate|app-finalize|app-rollback|app-abort [releaseId] [--staged-resources-json <JSON|file>] [--activate-staged-children] [--break-glass-adopt-verified-root --reason text] [--force-activate-without-validation] [--profile name] [--json]',
@@ -5391,6 +5513,7 @@ async function release(args) {
       '  openxiangda release ship --change <id> --profile <name> --confirm-production',
       '  openxiangda release fail --deployment <id> --message "UAT 未通过" --code UAT_FAILED --details-json <JSON|file> --environment preproduction --profile <name>',
       '  openxiangda release publish --change <id> --profile <name>',
+      '  openxiangda release publish --change <id> --profile <name> --replace-manifest --reason "已审查精确 Function manifest"',
       '  openxiangda release publish --change <id> --profile <name> --adopt-online-baseline --adoption-reason "已审计目标来自多次历史发布"',
       '  openxiangda release begin --change <id> --profile <name>',
       '  openxiangda resource publish function --only <code> --change <id> --profile <name>',
@@ -5411,6 +5534,7 @@ async function release(args) {
       '  - ship 当前不支持 --dry-run；任何未声明参数都会在 candidate/deployment 写入前 fail-closed。需要只读检查时使用 environment status/diff 与 release status。',
       '  - publish 默认等待租约并按私有执行日志恢复；上次写结果不确定时必须只读核对后显式 --resume-after-review。',
       '  - 旧式非环境托管 publish 也会把线上基线采纳意图仅透传给精确的 resource publish --only/--code 阶段；无精确资源阶段、原因不足或单独提供 reason 均在获取租约前 fail-closed。',
+      '  - 旧式非环境托管 publish 的 --replace-manifest 与 --reason 必须成对，只透传给唯一的精确 Backend Function/Automation stage，不进入 Form、Page、Workflow 或 App finalize。',
       '  - app-head 默认只输出紧凑 head 摘要；需要完整 manifest 时显式追加 --full。',
       '  - begin 获取应用级单写者 promotion lease；不同工作区仍可并行开发和验证。',
       '  - 带 --change 的 resource/runtime 写命令在没有本地 lease 时会自动 begin，并在后续命令复用。',
@@ -10357,6 +10481,7 @@ async function workspace(args) {
         connectors: {},
         dataViews: {},
         storageConfigs: {},
+        webhooks: {},
         scopeDimensions: {},
         scopeGrantSources: {},
         dataScopePolicies: {},
@@ -11405,6 +11530,105 @@ function outputPageResult(data, flags = {}) {
   print(JSON.stringify(data, null, 2));
 }
 
+const PAGE_PUBLISH_MAX_DEFINITIONS = 200;
+const PAGE_PUBLISH_MAX_JSON_BYTES = 2 * 1024 * 1024;
+
+function normalizePagePublishDefinitions(positional, flags = {}) {
+  const pageCode = String(positional?.[0] || '').trim();
+  const hasPagesJson = Object.prototype.hasOwnProperty.call(flags, 'pages-json');
+  let definitions;
+
+  if (hasPagesJson) {
+    if (pageCode) {
+      fail('page publish 使用 --pages-json 时不能再提供单页 pageCode');
+    }
+    const input = readJsonArg(readStringFlag(flags, 'pages-json'), 'pages-json');
+    definitions = Array.isArray(input) ? input : input?.pages;
+  } else {
+    if (!pageCode || !flags['entry-url']) {
+      fail(
+        '用法: openxiangda page publish <pageCode> --entry-url <url> --version <v> --build-id <id> [--activate]\n' +
+        '      openxiangda page publish --pages-json <JSON|file> --version <v> --build-id <id> [--activate]'
+      );
+    }
+    definitions = [
+      {
+        code: pageCode,
+        name: flags.name || pageCode,
+        description: flags.description || '',
+        route: flags.route ? JSON.parse(flags.route) : {},
+        props: flags.props ? JSON.parse(flags.props) : {},
+        runtime: {
+          entryUrl: flags['entry-url'],
+          cssUrls: splitList(flags['css-urls']),
+          jsUrls: splitList(flags['js-urls']),
+          framework: flags.framework || 'react',
+          frameworkVersion: flags['framework-version'] || '',
+          cssIsolation: flags['css-isolation'] || 'none',
+          format: flags.format || 'esm',
+        },
+        menu: flags.menu
+          ? {
+              enabled: true,
+              name: flags['menu-name'] || flags.name || pageCode,
+              parentId: flags['menu-parent-id'] || null,
+              icon: flags['menu-icon'] || null,
+            }
+          : { enabled: false },
+      },
+    ];
+  }
+
+  if (!Array.isArray(definitions) || definitions.length === 0) {
+    fail('PAGE_PUBLISH_DEFINITIONS_REQUIRED: pages-json 必须包含非空页面定义数组');
+  }
+  if (definitions.length > PAGE_PUBLISH_MAX_DEFINITIONS) {
+    fail(
+      `PAGE_PUBLISH_BATCH_TOO_LARGE: 单次最多发布 ${PAGE_PUBLISH_MAX_DEFINITIONS} 个页面`
+    );
+  }
+  const jsonBytes = Buffer.byteLength(JSON.stringify(definitions), 'utf8');
+  if (jsonBytes > PAGE_PUBLISH_MAX_JSON_BYTES) {
+    fail(
+      `PAGE_PUBLISH_BATCH_TOO_LARGE: 页面定义 JSON 不得超过 ${PAGE_PUBLISH_MAX_JSON_BYTES} 字节`
+    );
+  }
+
+  const seen = new Set();
+  return definitions.map((definition, index) => {
+    if (!definition || typeof definition !== 'object' || Array.isArray(definition)) {
+      fail(`PAGE_PUBLISH_DEFINITION_INVALID: pages-json[${index}] 必须是对象`);
+    }
+    const code = String(definition.code || '').trim();
+    const runtime = definition.runtime;
+    if (!code || code.length > 128) {
+      fail(
+        `PAGE_PUBLISH_DEFINITION_INVALID: pages-json[${index}].code 必须是 1-128 个字符`
+      );
+    }
+    const stableCode = code.toLowerCase();
+    if (seen.has(stableCode)) {
+      fail(`PAGE_PUBLISH_DEFINITION_DUPLICATE: 页面 code 重复: ${code}`);
+    }
+    seen.add(stableCode);
+    if (
+      !runtime ||
+      typeof runtime !== 'object' ||
+      Array.isArray(runtime) ||
+      !String(runtime.entryUrl || '').trim()
+    ) {
+      fail(
+        `PAGE_PUBLISH_DEFINITION_INVALID: 页面 ${code} 缺少 runtime.entryUrl`
+      );
+    }
+    return {
+      ...clonePlainJson(definition),
+      code,
+      name: String(definition.name || code),
+    };
+  });
+}
+
 async function page(args) {
   const [subcommand, ...rest] = args;
   const { flags, positional } = parseArgs(rest);
@@ -11526,78 +11750,128 @@ async function page(args) {
   }
 
   if (subcommand === 'publish') {
-    const [pageCode] = positional;
-    if (!pageCode || !flags['entry-url'] || !flags.version || !flags['build-id']) {
+    if (!flags.version || !flags['build-id']) {
       fail(
-        '用法: openxiangda page publish <pageCode> --entry-url <url> --version <v> --build-id <id> [--activate]'
+        '用法: openxiangda page publish <pageCode> --entry-url <url> --version <v> --build-id <id> [--activate]\n' +
+        '      openxiangda page publish --pages-json <JSON|file> --version <v> --build-id <id> [--activate]'
       );
     }
+    const pageDefinitions = normalizePagePublishDefinitions(positional, flags);
+    const pageCodes = pageDefinitions.map(definition => definition.code);
     await ensureDirectMutationPublishContext(config, target, flags, 'page publish');
     const frozen = await fetchFrozenPageSnapshot(config, target);
-    const currentPage = frozen.pageByCode.get(pageCode) || null;
-    const expectedRevision = currentPage ? Number(currentPage.revision) : 0;
     const activate = flags.activate === true;
-    const definition = {
-      code: pageCode,
-      name: flags.name || pageCode,
-      description: flags.description || '',
-      route: flags.route ? JSON.parse(flags.route) : {},
-      props: flags.props ? JSON.parse(flags.props) : {},
-      runtime: {
-        entryUrl: flags['entry-url'],
-        cssUrls: splitList(flags['css-urls']),
-        jsUrls: splitList(flags['js-urls']),
-        framework: flags.framework || 'react',
-        frameworkVersion: flags['framework-version'] || '',
-        cssIsolation: flags['css-isolation'] || 'none',
-        format: flags.format || 'esm',
-      },
-      menu: flags.menu
-        ? {
-            enabled: true,
-            name: flags['menu-name'] || flags.name || pageCode,
-            parentId: flags['menu-parent-id'] || null,
-            icon: flags['menu-icon'] || null,
-          }
-        : { enabled: false },
-      expectedRevision,
-    };
+    const definitions = pageDefinitions.map(definition => {
+      const currentPage = frozen.pageByCode.get(definition.code) || null;
+      return {
+        ...definition,
+        expectedRevision: currentPage ? Number(currentPage.revision) : 0,
+      };
+    });
+    const expectedRevisions = { ...frozen.expectedRevisions };
+    const expectedActiveAssets = { ...frozen.expectedActiveAssets };
+    for (const definition of definitions) {
+      expectedRevisions[definition.code] = definition.expectedRevision;
+      if (!Object.prototype.hasOwnProperty.call(expectedActiveAssets, definition.code)) {
+        expectedActiveAssets[definition.code] = null;
+      }
+    }
+    const singleCurrentPage =
+      definitions.length === 1
+        ? frozen.pageByCode.get(definitions[0].code) || null
+        : null;
     const data = await requestWithAuth(
       config,
       target.profileName,
       pageApiPath(target, '/publish'),
       {
         method: 'POST',
-        headers: { 'if-match': currentPage?.etag || '0' },
+        headers:
+          definitions.length === 1
+            ? { 'if-match': singleCurrentPage?.etag || '0' }
+            : {},
         body: {
           version: flags.version,
           buildId: flags['build-id'],
-          pages: [definition],
-          expectedRevision,
-          expectedRevisions: {
-            ...frozen.expectedRevisions,
-            [pageCode]: expectedRevision,
-          },
-          expectedActiveAssets: {
-            ...frozen.expectedActiveAssets,
-            [pageCode]: currentPage
-              ? frozen.expectedActiveAssets[pageCode]
-              : null,
-          },
+          pages: definitions,
+          ...(definitions.length === 1
+            ? { expectedRevision: definitions[0].expectedRevision }
+            : {}),
+          expectedRevisions,
+          expectedActiveAssets,
           expectedParent: frozen.expectedParent,
           stage: !activate,
           activate,
         },
       }
     );
-    const item = Array.isArray(data?.items) ? data.items[0] : null;
-    if (item?.pageId) {
-      savePageResource(target, pageCode, item.pageId, {
-        routeKey: item.routeKey,
-        legacyFormUuid: item.legacyFormUuid,
-      });
+    const items = Array.isArray(data?.items) ? data.items : [];
+    const itemByCode = new Map(
+      items.map(item => [String(item?.code || '').trim(), item])
+    );
+    const missingPageCodes = pageCodes.filter(code => !itemByCode.has(code));
+    if (missingPageCodes.length > 0) {
+      fail(
+        `PAGE_RELEASE_STAGE_SCOPE_MISMATCH: Page Release 响应缺少页面 ${missingPageCodes.join(',')}`
+      );
+    }
+    for (const pageCode of pageCodes) {
+      const item = itemByCode.get(pageCode);
+      if (item?.pageId) {
+        savePageResource(target, pageCode, item.pageId, {
+          routeKey: item.routeKey,
+          legacyFormUuid: item.legacyFormUuid,
+        });
+      }
     }
     if (!activate) {
+      const releaseId = String(data?.release?.id || '').trim();
+      const releaseHash = String(data?.release?.releaseHash || '').toLowerCase();
+      if (
+        !data?.staged ||
+        data?.activation ||
+        !releaseId ||
+        !/^[a-f0-9]{64}$/.test(releaseHash) ||
+        data?.release?.immutable !== true ||
+        String(data?.release?.version || '') !== String(flags.version) ||
+        String(data?.release?.buildId || '') !== String(flags['build-id'])
+      ) {
+        fail(
+          `PAGE_RELEASE_STAGE_REQUIRED: ${pageCodes.join(',')} 的非激活发布必须返回匹配 version/buildId 的 immutable staged releaseId 和 64 位 releaseHash`
+        );
+      }
+      const stagedChangeId =
+        readStringFlag(flags, 'change') ||
+        getStoredChangeBaseline(target)?.changeId;
+      const stagedResource = {
+        kind: 'PageRelease',
+        identity: { releaseId },
+        action: 'update',
+        hash: releaseHash,
+        revision: {
+          releaseId,
+          version: data.release.version,
+          buildId: data.release.buildId,
+        },
+        metadata: {
+          state: 'staged',
+          immutable: true,
+          parentReleaseId: data.release.parentReleaseId || null,
+          pageCount: items.length,
+          selectedPageCodes: [...pageCodes].sort(),
+          releasePageCodes: unique(
+            items
+              .map(item => String(item?.code || '').trim())
+              .filter(Boolean)
+          ).sort(),
+        },
+      };
+      data.stagedResource = stagedResource;
+      data.stagedResourcesFile = recordStagedAppReleaseResources(
+        stagedChangeId,
+        [stagedResource],
+        target
+      );
       retainCommandScopedPublishLease('staged-page');
     }
     const leaseCompletion = await finalizeCommandScopedPublishLease({
@@ -12543,6 +12817,93 @@ async function dataView(args) {
   fail('用法: openxiangda data-view list|get|create|update|upsert|delete|status|refresh|query|stats');
 }
 
+async function webhook(args) {
+  const { subcommand, rest } = parseSubcommandArgs(args);
+  const { flags, positional } = parseArgs(rest);
+  if (wantsSubcommandHelp(subcommand, flags)) {
+    print('用法: openxiangda webhook list|get|create|update|upsert|disable|deliveries|delivery [webhookCode] [deliveryId] [--json-file file] [--json]');
+    return;
+  }
+  const config = loadConfig();
+  const target = getWorkspaceTarget(
+    config,
+    flags.profile || config.currentProfile,
+    flags
+  );
+  const basePath = `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/webhooks`;
+
+  if (['list', 'get', 'create', 'update', 'upsert'].includes(subcommand)) {
+    return directResourceCrud(config, target, {
+      commandName: 'webhook',
+      subcommand,
+      flags,
+      positional,
+      resourceType: 'webhook',
+      basePath,
+      manifestDir: path.join('src', 'resources', 'webhooks'),
+      normalizeBody: normalizeWebhookManifest,
+      codeOf: body => body.code || body.resourceCode,
+      saveState: (code, data) => saveWebhookResource(target, code, data),
+    });
+  }
+
+  if (subcommand === 'disable') {
+    const code = positional[0] || flags.code;
+    if (!code) fail('用法: openxiangda webhook disable <webhookCode>');
+    const body = readDirectJsonBody(flags, 'webhook disable', {
+      optional: true,
+    });
+    if (flags['expected-revision'] !== undefined) {
+      body.expectedRevision = Number(flags['expected-revision']);
+    }
+    const data = await runDirectRequest(
+      config,
+      target,
+      flags,
+      {
+        method: 'POST',
+        path: apiPathWithPostDeleteAction(
+          `${basePath}/${encodeURIComponent(code)}`
+        ),
+        body,
+      },
+      { returnData: true }
+    );
+    if (!flags['dry-run']) saveWebhookResource(target, code, data);
+    return outputDirectResult({ action: 'disable', data }, flags);
+  }
+
+  if (subcommand === 'deliveries') {
+    const code = positional[0] || flags.code;
+    if (!code) fail('用法: openxiangda webhook deliveries <webhookCode>');
+    return runDirectRequest(config, target, flags, {
+      method: 'GET',
+      path: apiPathWithQuery(
+        `${basePath}/${encodeURIComponent(code)}/deliveries`,
+        {
+          page: flags.page,
+          pageSize: flags['page-size'] || flags.limit,
+          status: flags.status,
+        }
+      ),
+    });
+  }
+
+  if (subcommand === 'delivery') {
+    const code = positional[0] || flags.code;
+    const deliveryId = positional[1] || flags['delivery-id'];
+    if (!code || !deliveryId) {
+      fail('用法: openxiangda webhook delivery <webhookCode> <deliveryId>');
+    }
+    return runDirectRequest(config, target, flags, {
+      method: 'GET',
+      path: `${basePath}/${encodeURIComponent(code)}/deliveries/${encodeURIComponent(deliveryId)}`,
+    });
+  }
+
+  fail('用法: openxiangda webhook list|get|create|update|upsert|disable|deliveries|delivery');
+}
+
 async function scope(args) {
   const { subcommand, rest } = parseSubcommandArgs(args);
   const { flags, positional } = parseArgs(rest);
@@ -13962,16 +14323,19 @@ async function notification(args) {
   const { flags, positional } = parseArgs(rest);
   if (wantsSubcommandHelp(subcommand, flags)) {
     print([
-      '用法: openxiangda notification template-list|template-get|template-upsert|template-delete|type-list|type-get|type-upsert|type-delete|preview|send|batch-send|capabilities|dingding-preview|dingding-send',
+      '用法: openxiangda notification template-list|template-get|template-upsert|template-delete|type-list|type-get|type-upsert|type-delete|preview|capabilities|dingding-preview',
       '  preview <notificationType|templateCode> [--form-code code|--form-uuid FORM_XXX] --body-json \'{"payload":{"title":"测试"}}\'',
-      '  send <notificationType> --body-json \'{"recipientId":"USER_ID","payload":{"title":"测试"}}\' --force',
-      '  batch-send <notificationType> --body-json \'{"recipients":[{"recipientId":"USER_ID","payload":{}}]}\' --force',
       '  capabilities --json',
       '  dingding-preview <notificationType> [--template-code code|--template-id id] --body-json \'{"payload":{"title":"测试"}}\'',
-      '  dingding-send <notificationType> --body-json \'{"recipientId":"USER_ID","payload":{"title":"测试"}}\' --force',
+      '  页面和 CLI 不再直接发送通知；请使用 openxiangda function invoke <functionCode> --body-json \'{"input":{"businessId":"..."}}\'',
     ].join('\n'));
     return;
   }
+  if (['send', 'batch-send', 'dingding-send'].includes(subcommand)) {
+    fail(
+      'DIRECT_NOTIFICATION_SEND_REMOVED: CLI 不再直接发送通知，请使用具名 App Function，并通过 openxiangda function invoke <functionCode> 调用'
+    );
+  }
   const config = loadConfig();
   const target = getWorkspaceTarget(config, flags.profile || config.currentProfile, flags);
   const appPrefix = `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/notifications`;
@@ -14070,45 +14434,30 @@ async function notification(args) {
       strictEnvelope: true,
     });
   }
-  if (subcommand === 'dingding-preview' || subcommand === 'dingding-send') {
-    if (subcommand === 'dingding-send' && !flags.force) {
-      fail('openxiangda notification dingding-send 是发送动作，必须加 --force');
-    }
+  if (subcommand === 'dingding-preview') {
     const code = positional[0] || flags.code;
     const rawBody = readDirectJsonBody(flags, `notification ${subcommand}`, { optional: true });
     const body = buildDingTalkNotificationActionBody(target, code, rawBody, flags);
     return runDirectRequest(config, target, flags, {
       method: 'POST',
-      path: `${appPrefix}/dingtalk/${subcommand === 'dingding-send' ? 'send' : 'preview'}`,
+      path: `${appPrefix}/dingtalk/preview`,
       body,
       strictEnvelope: true,
     }, { controlPlaneMutation: false });
   }
-  if (['preview', 'send', 'batch-send'].includes(subcommand)) {
-    if ((subcommand === 'send' || subcommand === 'batch-send') && !flags.force) {
-      fail(`openxiangda notification ${subcommand} 是发送动作，必须加 --force`);
-    }
+  if (subcommand === 'preview') {
     const code = positional[0] || flags.code;
     const rawBody = readDirectJsonBody(flags, `notification ${subcommand}`, { optional: true });
-    const body =
-      subcommand === 'preview'
-        ? await normalizeNotificationPreviewBody(config, target, code, rawBody, flags)
-        : normalizeNotificationActionBody(subcommand, code, rawBody);
-    const actionPath =
-      subcommand === 'preview'
-        ? 'templates/preview'
-        : subcommand === 'batch-send'
-          ? 'batch-send-by-type'
-          : 'send-by-type';
+    const body = await normalizeNotificationPreviewBody(config, target, code, rawBody, flags);
     return runDirectRequest(config, target, flags, {
       method: 'POST',
-      path: `${appPrefix}/${actionPath}`,
+      path: `${appPrefix}/templates/preview`,
       body,
       strictEnvelope: true,
     }, { controlPlaneMutation: false });
   }
 
-  fail('用法: openxiangda notification template-list|template-get|template-upsert|template-delete|type-list|type-get|type-upsert|type-delete|preview|send|batch-send|capabilities|dingding-preview|dingding-send');
+  fail('用法: openxiangda notification template-list|template-get|template-upsert|template-delete|type-list|type-get|type-upsert|type-delete|preview|capabilities|dingding-preview');
 }
 
 async function organization(args) {
@@ -17097,6 +17446,7 @@ async function commands(args) {
       'workflow compile|list|create|bind|pull|publish|delete|validate',
       'automation list|create|bind|pull|publish|unpublish|enable|disable|delete|validate|cron-validate',
       'data-view list|get|create|update|upsert|delete|status|refresh|query|stats',
+      'webhook list|get|create|update|upsert|disable|deliveries|delivery',
       'route list|get|create|update|upsert|delete',
       'public-access list|get|create|update|upsert|delete|ticket-create|session-test|grant-check',
       'auth-config list|get|create|update|upsert|delete|methods',
@@ -17119,6 +17469,7 @@ async function commands(args) {
     resourceNotes: [
       'For formal multi-resource development, prefer src/resources/** + openxiangda resource validate|plan|publish.',
       'Use first-class route/public-access/auth-config/function/connector/notification/data-view/menu/permission commands for discovery, diagnosis, dry-run, and small live fixes.',
+      'Inbound Webhooks are declared in src/resources/webhooks and route only to a fixed App Function. Provider secrets belong in top-level Function secretRefs; signature verification must use input.rawBody before any data access.',
       'public-access is the new React SPA public policy resource for /view/:appType/public/* routes; page code should use PublicAccessGate, and Page SDK hooks must stay inside OpenXiangdaProvider + OpenXiangdaPageProvider.',
       'settings public-access is legacy form public-access compatibility/repair and should not be used for new React SPA apps.',
       'Direct live mutation commands should use --dry-run first and --write-manifest when the repository should remain source of truth.',
@@ -17513,6 +17864,7 @@ function directManifestDir(resourceType) {
     connector: path.join('src', 'resources', 'connectors'),
     notification: path.join('src', 'resources', 'notifications'),
     'data-view': path.join('src', 'resources', 'data-views'),
+    webhook: path.join('src', 'resources', 'webhooks'),
     menu: path.join('src', 'resources', 'menus'),
     role: path.join('src', 'resources', 'roles'),
     'page-permission-group': path.join('src', 'resources', 'permissions', 'page-groups'),
@@ -17532,6 +17884,7 @@ function removeDirectStateResource(target, resourceType, code) {
     function: 'functions',
     connector: 'connectors',
     'data-view': 'dataViews',
+    webhook: 'webhooks',
   };
   const bucket = buckets[resourceType];
   if (!bucket || !target.bound.resources?.[bucket]?.[code]) return;
@@ -17854,6 +18207,7 @@ function ensureResourceBuckets(bound) {
   bound.resources.connectors = bound.resources.connectors || {};
   bound.resources.dataViews = bound.resources.dataViews || {};
   bound.resources.storageConfigs = bound.resources.storageConfigs || {};
+  bound.resources.webhooks = bound.resources.webhooks || {};
   bound.resources.authConfigs = bound.resources.authConfigs || {};
   bound.resources.routes = bound.resources.routes || {};
   bound.resources.publicAccessPolicies = bound.resources.publicAccessPolicies || {};
@@ -18199,6 +18553,29 @@ function saveStorageConfigResource(target, storageCode, storageConfigId, extra =
   }, keys);
 }
 
+function saveWebhookResource(target, webhookCode, data = {}) {
+  const keys = [
+    'webhookId',
+    'endpointId',
+    'callbackPath',
+    'callbackUrl',
+    'targetFunctionCode',
+    'idempotencyQueryParam',
+    'maxBodyBytes',
+    'status',
+    'revision',
+  ];
+  const callbackPath = String(data?.callbackPath || '').trim();
+  const callbackUrl = callbackPath
+    ? `${String(target.profile?.baseUrl || '').replace(/\/+$/, '')}${callbackPath}`
+    : data?.callbackUrl;
+  saveStateResource(target, 'webhooks', webhookCode, {
+    ...pickStateFields(data, keys),
+    webhookId: data?.id || data?.webhookId,
+    callbackUrl,
+  }, keys);
+}
+
 function saveScopeResource(target, bucket, code, data = {}) {
   if (!bucket || !code) return;
   const keys = ['id', 'resourceCode', 'name', 'updatedAt'];
@@ -18347,6 +18724,7 @@ const RESOURCE_SPECS = [
   { key: 'functions', dir: 'functions', topFiles: ['functions.json'], pluralKeys: ['functions'] },
   { key: 'dataViews', dir: 'data-views', topFiles: ['data-views.json'], pluralKeys: ['dataViews', 'data-views'] },
   { key: 'storageConfigs', dir: 'storage', topFiles: ['storage.json'], pluralKeys: ['storageConfigs', 'storage'] },
+  { key: 'webhooks', dir: 'webhooks', topFiles: ['webhooks.json'], pluralKeys: ['webhooks'] },
   { key: 'authConfigs', dir: 'auth', topFiles: ['auth.json'], pluralKeys: ['authConfigs', 'auth'] },
   { key: 'routes', dir: 'routes', topFiles: ['routes.json'], pluralKeys: ['routes'] },
   {
@@ -18426,6 +18804,8 @@ const RESOURCE_TYPE_ALIASES = new Map([
   ['oss', 'storageConfigs'],
   ['oss-config', 'storageConfigs'],
   ['oss-configs', 'storageConfigs'],
+  ['webhook', 'webhooks'],
+  ['webhooks', 'webhooks'],
   ['auth', 'authConfigs'],
   ['auth-config', 'authConfigs'],
   ['auth-configs', 'authConfigs'],
@@ -19138,6 +19518,7 @@ function generateResourceTypes(manifest, outputFile) {
   const dataViewCodes = unique((manifest.dataViews || []).map(item => item.code).filter(Boolean));
   const functionCodes = unique((manifest.functions || []).map(item => item.code).filter(Boolean));
   const storageConfigCodes = unique((manifest.storageConfigs || []).map(item => item.code).filter(Boolean));
+  const webhookCodes = unique((manifest.webhooks || []).map(item => item.code).filter(Boolean));
   const authConfigCodes = unique((manifest.authConfigs || []).map(item => item.code).filter(Boolean));
   const publicAccessPolicyCodes = unique((manifest.publicAccessPolicies || []).map(item => item.code).filter(Boolean));
   const scopeDimensionCodes = unique((manifest.scopeDimensions || []).map(item => item.code).filter(Boolean));
@@ -19162,6 +19543,9 @@ function generateResourceTypes(manifest, outputFile) {
     `export const storageConfigCodes = ${JSON.stringify(storageConfigCodes, null, 2)} as const`,
     'export type StorageConfigCode = typeof storageConfigCodes[number]',
     '',
+    `export const webhookCodes = ${JSON.stringify(webhookCodes, null, 2)} as const`,
+    'export type WebhookCode = typeof webhookCodes[number]',
+    '',
     `export const functionCodes = ${JSON.stringify(functionCodes, null, 2)} as const`,
     'export type FunctionCode = typeof functionCodes[number]',
     '',
@@ -19196,6 +19580,7 @@ function generateResourceTypes(manifest, outputFile) {
     pagePermissionGroups: pagePermissionGroupCodes.length,
     dataViews: dataViewCodes.length,
     storageConfigs: storageConfigCodes.length,
+    webhooks: webhookCodes.length,
     functions: functionCodes.length,
     authConfigs: authConfigCodes.length,
     publicAccessPolicies: publicAccessPolicyCodes.length,
@@ -19273,6 +19658,50 @@ function validateResourceItem(kind, item, errors, warnings) {
     validateFunctionRuntimeInvoke(label, item, errors, warnings);
     validateFunctionPerformancePolicies(label, item, errors);
   }
+  if (kind === 'webhooks') {
+    const allowed = new Set([
+      'code',
+      'resourceCode',
+      'name',
+      'description',
+      'targetFunctionCode',
+      'idempotencyQueryParam',
+      'maxBodyBytes',
+      'status',
+    ]);
+    const unsupported = Object.keys(item).filter(
+      key => !key.startsWith('__') && !allowed.has(key)
+    );
+    if (unsupported.length > 0) {
+      errors.push(`${label}: 包含不支持的字段 ${unsupported.join(', ')}`);
+    }
+    if (!item.name) errors.push(`${label}: 缺少 name`);
+    if (!/^[A-Za-z][A-Za-z0-9_]{1,127}$/.test(String(item.targetFunctionCode || ''))) {
+      errors.push(`${label}: targetFunctionCode 格式不正确`);
+    }
+    if (
+      item.idempotencyQueryParam !== undefined &&
+      !/^[A-Za-z][A-Za-z0-9_.-]{0,127}$/.test(
+        String(item.idempotencyQueryParam)
+      )
+    ) {
+      errors.push(`${label}: idempotencyQueryParam 格式不正确`);
+    }
+    const maxBodyBytes = Number(item.maxBodyBytes || 262144);
+    if (
+      !Number.isInteger(maxBodyBytes) ||
+      maxBodyBytes < 1024 ||
+      maxBodyBytes > 1048576
+    ) {
+      errors.push(`${label}: maxBodyBytes 必须在 1024 到 1048576 之间`);
+    }
+    if (!['active', 'disabled'].includes(String(item.status || 'active'))) {
+      errors.push(`${label}: status 只能是 active 或 disabled`);
+    }
+    if (Object.keys(item).some(key => /secret|signature|hmac/i.test(key))) {
+      errors.push(`${label}: Webhook manifest 不能包含 Secret 或供应商验签配置`);
+    }
+  }
   if (kind === 'dataViews') {
     const definition = item.definition || item;
     const viewType = String(definition.viewType || 'row').toLowerCase();
@@ -20384,6 +20813,7 @@ async function buildResourcePlan(
   await addAutomationPlanActions(config, target, actions, manifest.automations, existing.automations);
   addPlanActions(actions, 'dataView', manifest.dataViews, existing.dataViews, (item, current) => dataViewEquals(target.bound, item, current));
   addPlanActions(actions, 'storageConfig', manifest.storageConfigs, existing.storageConfigs, (item, current) => storageConfigEquals(item, current));
+  addPlanActions(actions, 'webhook', manifest.webhooks, existing.webhooks, webhookEquals);
   addPlanActions(actions, 'scopeDimension', manifest.scopeDimensions, existing.scopeDimensions, (item, current) => scopeDimensionEquals(target.bound, item, current));
   addPlanActions(actions, 'scopeGrantSource', manifest.scopeGrantSources, existing.scopeGrantSources, (item, current) => scopeGrantSourceEquals(target.bound, item, current));
   addPlanActions(actions, 'dataScopePolicy', manifest.dataScopePolicies, existing.dataScopePolicies, dataScopePolicyEquals);
@@ -22244,6 +22674,7 @@ async function publishResourceManifest(config, target, manifest, options = {}) {
   await publishDataScopePolicyResources(config, target, manifest.dataScopePolicies || [], result, publishOptions);
   await publishDataViewResources(config, target, manifest.dataViews || [], result, publishOptions);
   await publishStorageConfigResources(config, target, manifest.storageConfigs || [], result, publishOptions);
+  await publishWebhookResources(config, target, manifest.webhooks || [], result, publishOptions);
   await publishPublicAccessPolicyResources(config, target, manifest.publicAccessPolicies || [], result, publishOptions);
   await publishPagePermissionGroupResources(config, target, manifest.pagePermissionGroups || [], result, publishOptions);
   await publishFormPermissionGroupResources(
@@ -22390,6 +22821,7 @@ const GENERIC_RESOURCE_KEY_BY_PLAN_KIND = Object.freeze({
   publicAccessPolicy: 'publicAccessPolicies',
   dataView: 'dataViews',
   storageConfig: 'storageConfigs',
+  webhook: 'webhooks',
   scopeDimension: 'scopeDimensions',
   scopeGrantSource: 'scopeGrantSources',
   dataScopePolicy: 'dataScopePolicies',
@@ -22898,6 +23330,7 @@ async function fetchExistingResourceMaps(config, target, manifest) {
     automations: new Map(),
     dataViews: new Map(),
     storageConfigs: new Map(),
+    webhooks: new Map(),
     scopeDimensions: new Map(),
     scopeGrantSources: new Map(),
     dataScopePolicies: new Map(),
@@ -23124,6 +23557,21 @@ async function fetchExistingResourceMaps(config, target, manifest) {
       });
     }
   }
+  if ((manifest.webhooks || []).length > 0) {
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      apiPathWithQuery(
+        `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/webhooks`,
+        { page: 1, pageSize: 1000 }
+      )
+    );
+    indexByCode(
+      maps.webhooks,
+      normalizeItems(data),
+      item => item.code || item.resourceCode
+    );
+  }
   if ((manifest.scopeDimensions || []).length > 0) {
     const data = await requestWithAuth(
       config,
@@ -25115,6 +25563,45 @@ async function publishStorageConfigResources(config, target, storageConfigs, res
   }
 }
 
+async function publishWebhookResources(config, target, webhooks, result, options = {}) {
+  for (const webhookItem of webhooks) {
+    const code = webhookItem.code || webhookItem.resourceCode;
+    if (shouldSkipNoopResource(options, 'webhook', code)) {
+      recordNoopResource(result, 'webhook', code, options);
+      continue;
+    }
+    const existing = await findExistingWebhook(config, target, code);
+    const existingRevision = Number(existing?.revision);
+    const body = {
+      ...normalizeWebhookManifest(webhookItem),
+      expectedRevision:
+        existing && Number.isInteger(existingRevision) && existingRevision > 0
+          ? existingRevision
+          : existing
+            ? undefined
+            : 0,
+    };
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      existing
+        ? `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/webhooks/${encodeURIComponent(code)}`
+        : `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/webhooks`,
+      { method: 'POST', body }
+    );
+    saveWebhookResource(target, code, data);
+    result.published.push({
+      kind: 'webhook',
+      code,
+      action: existing ? 'update' : 'create',
+      id: data?.id,
+      endpointId: data?.endpointId,
+      callbackPath: data?.callbackPath,
+      status: data?.status,
+    });
+  }
+}
+
 async function publishDataViewPermissionGroups(config, target, dataViewCode, permissionGroups) {
   await requestWithAuth(
     config,
@@ -25279,6 +25766,25 @@ async function findExistingStorageConfig(config, target, code) {
   return null;
 }
 
+async function findExistingWebhook(config, target, code) {
+  const state = target.bound.resources?.webhooks?.[code];
+  const byCode = await requestOptionalWithAuth(
+    config,
+    target.profileName,
+    `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/webhooks/${encodeURIComponent(code)}`
+  );
+  if (byCode?.id) return byCode;
+  if (state?.webhookId) {
+    return {
+      id: state.webhookId,
+      code,
+      revision: state.revision,
+      endpointId: state.endpointId,
+    };
+  }
+  return null;
+}
+
 async function findExistingAutomation(config, target, code) {
   const stateId = target.bound.resources?.automations?.[code]?.automationId;
   if (stateId) {
@@ -25557,6 +26063,22 @@ async function collectPruneResourceCandidates(config, target, manifest) {
         item => item.code || item.resourceCode
       );
     }
+    if (enabled('webhooks')) {
+      const data = await requestWithAuth(
+        config,
+        target.profileName,
+        apiPathWithQuery(`${appPath}/webhooks`, {
+          page: 1,
+          pageSize: 1000,
+        })
+      );
+      append(
+        'webhook',
+        desiredCodes(manifest.webhooks),
+        normalizeItems(data),
+        item => item.code || item.resourceCode
+      );
+    }
     if (enabled('publicAccessPolicies')) {
       const data = await requestWithAuth(
         config,
@@ -25747,6 +26269,21 @@ async function pruneFrozenResourceCandidate(config, target, result, candidate) {
     if (kind === 'storageConfig') {
       return postDelete(`${appPath}/storage-configs/${encodeURIComponent(code)}`);
     }
+    if (kind === 'webhook') {
+      return requestWithAuth(
+        config,
+        target.profileName,
+        apiPathWithPostDeleteAction(
+          `${appPath}/webhooks/${encodeURIComponent(code)}`
+        ),
+        {
+          method: 'POST',
+          body: candidate.frozenRevision
+            ? { expectedRevision: candidate.frozenRevision }
+            : {},
+        }
+      );
+    }
     if (kind === 'publicAccessPolicy') {
       return postDelete(`${appPath}/public-access/policies/${encodeURIComponent(code)}`);
     }
@@ -26147,6 +26684,7 @@ function removeStateResource(target, kind, code) {
     publicAccessPolicy: 'publicAccessPolicies',
     dataView: 'dataViews',
     storageConfig: 'storageConfigs',
+    webhook: 'webhooks',
     pagePermissionGroup: 'pagePermissionGroups',
     formPermissionGroup: 'formPermissionGroups',
   };
@@ -26449,6 +26987,22 @@ async function pullResources(config, target) {
     written.push(path.relative(process.cwd(), filePath));
   }
 
+  const webhooks = await requestWithAuth(
+    config,
+    target.profileName,
+    apiPathWithQuery(
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/webhooks`,
+      { page: 1, pageSize: 1000 }
+    )
+  );
+  for (const webhookItem of normalizeItems(webhooks)) {
+    const code = webhookItem.code || webhookItem.resourceCode || webhookItem.id;
+    const filePath = path.join(baseDir, 'webhooks', `${code}.json`);
+    writeResourceJsonFile(filePath, toPulledWebhook(webhookItem));
+    written.push(path.relative(process.cwd(), filePath));
+    saveWebhookResource(target, code, webhookItem);
+  }
+
   const pageGroups = await requestWithAuth(
     config,
     target.profileName,
@@ -26722,6 +27276,18 @@ function toPulledStorageConfig(storageConfig) {
   });
 }
 
+function toPulledWebhook(webhookItem) {
+  return stripUndefinedValues({
+    code: webhookItem.code || webhookItem.resourceCode,
+    name: webhookItem.name,
+    description: webhookItem.description || '',
+    targetFunctionCode: webhookItem.targetFunctionCode,
+    idempotencyQueryParam: webhookItem.idempotencyQueryParam || 'nonce',
+    maxBodyBytes: webhookItem.maxBodyBytes || 262144,
+    status: webhookItem.status || 'active',
+  });
+}
+
 function rewriteDataViewDefinitionForManifest(definition, lookups) {
   rewriteDataViewSourceForManifest(definition.base, lookups);
   for (const join of definition.joins || []) {
@@ -27174,6 +27740,61 @@ function normalizeStorageConfigManifest(storageConfig) {
   });
 }
 
+function normalizeWebhookManifest(webhook) {
+  const code = String(webhook.code || webhook.resourceCode || '').trim();
+  const allowed = new Set([
+    'code',
+    'resourceCode',
+    'name',
+    'description',
+    'targetFunctionCode',
+    'idempotencyQueryParam',
+    'maxBodyBytes',
+    'status',
+  ]);
+  const unsupported = Object.keys(webhook).filter(
+    key => !key.startsWith('__') && !allowed.has(key)
+  );
+  if (unsupported.length > 0) {
+    fail(`webhook:${code || '<unknown>'} 包含不支持的字段 ${unsupported.join(', ')}`);
+  }
+  if (!/^[A-Za-z][A-Za-z0-9_]{1,127}$/.test(code)) {
+    fail('Webhook code 格式不正确');
+  }
+  const targetFunctionCode = String(webhook.targetFunctionCode || '').trim();
+  if (!/^[A-Za-z][A-Za-z0-9_]{1,127}$/.test(targetFunctionCode)) {
+    fail(`webhook:${code} targetFunctionCode 格式不正确`);
+  }
+  const idempotencyQueryParam = String(
+    webhook.idempotencyQueryParam || 'nonce'
+  ).trim();
+  if (!/^[A-Za-z][A-Za-z0-9_.-]{0,127}$/.test(idempotencyQueryParam)) {
+    fail(`webhook:${code} idempotencyQueryParam 格式不正确`);
+  }
+  const maxBodyBytes = Number(webhook.maxBodyBytes || 262144);
+  if (
+    !Number.isInteger(maxBodyBytes) ||
+    maxBodyBytes < 1024 ||
+    maxBodyBytes > 1048576
+  ) {
+    fail(`webhook:${code} maxBodyBytes 必须在 1024 到 1048576 之间`);
+  }
+  const status = String(webhook.status || 'active');
+  if (!['active', 'disabled'].includes(status)) {
+    fail(`webhook:${code} status 只能是 active 或 disabled`);
+  }
+  return stripUndefinedValues({
+    code,
+    name: String(webhook.name || code).trim(),
+    description:
+      webhook.description === undefined ? '' : String(webhook.description),
+    targetFunctionCode,
+    idempotencyQueryParam,
+    maxBodyBytes,
+    status,
+  });
+}
+
 function normalizeStorageCorsForPublish(cors) {
   if (cors === undefined || cors === null || cors === '') return undefined;
   const managed =
@@ -28321,6 +28942,21 @@ function storageConfigEquals(desired, existing) {
   );
 }
 
+function webhookEquals(desired, existing) {
+  if (!existing) return false;
+  const expected = normalizeWebhookManifest(desired);
+  return (
+    String(existing.code || existing.resourceCode || '') === expected.code &&
+    String(existing.name || '') === expected.name &&
+    String(existing.description || '') === expected.description &&
+    String(existing.targetFunctionCode || '') === expected.targetFunctionCode &&
+    String(existing.idempotencyQueryParam || 'nonce') ===
+      expected.idempotencyQueryParam &&
+    Number(existing.maxBodyBytes || 262144) === expected.maxBodyBytes &&
+    String(existing.status || 'active') === expected.status
+  );
+}
+
 function routeEquals(desired, existing) {
   if (!existing) return false;
   const expected = normalizeRouteManifest(desired);
@@ -31135,6 +31771,9 @@ function buildWorkspacePublishEnv(
   env.OPENXIANGDA_BASE_URL = profile.baseUrl;
   env.OPENXIANGDA_ACCESS_TOKEN = profile.token.accessToken;
   env.OPENXIANGDA_APP_TYPE = appType;
+  if (!env.OPENXIANGDA_CLI) {
+    env.OPENXIANGDA_CLI = path.resolve(__dirname, '..', 'bin', 'openxiangda.js');
+  }
   if (targetName) env.OPENXIANGDA_TARGET = targetName;
   else delete env.OPENXIANGDA_TARGET;
   env.OPENXIANGDA_GLOBAL_ENV_KEYS = injectedGlobalKeys.join(',');
@@ -31144,8 +31783,11 @@ function buildWorkspacePublishEnv(
 }
 
 module.exports = {
+  assertLegacyPageReleaseCoverage,
   assertReleasePublishAdoptionFlags,
   assertReleasePublishAdoptionScope,
+  assertReleasePublishManifestReplacementFlags,
+  assertReleasePublishManifestReplacementScope,
   assertRuntimeReleaseReusable,
   buildOpenXiangdaUpdateInstallPlan,
   buildResourceManifestSddTargets,