openxiangda 1.0.21 → 1.0.24

package/lib/cli.js

@@ -14,7 +14,7 @@ const {
 } = require('./config');
 const { requestJson } = require('./http');
 const { getSkillStatusReport, installSkills } = require('./skills');
-const { initWorkspace } = require('./workspace-init');
+const { assertCanInitializeWorkspace, initWorkspace } = require('./workspace-init');
 const {
   fail,
   openBrowser,
@@ -24,6 +24,10 @@ const {
   warn,
   writeJson,
 } = require('./utils');
+const { version: CURRENT_VERSION } = require('../package.json');
+
+const NPM_PACKAGE_NAME = 'openxiangda';
+const OFFICIAL_NPM_REGISTRY = 'https://registry.npmjs.org';
 
 async function main(argv) {
   const [command, ...rest] = argv;
@@ -33,6 +37,7 @@ async function main(argv) {
   }
 
   if (command === 'login') return login(rest);
+  if (command === 'update') return update(rest);
   if (command === 'env') return env(rest);
   if (command === 'auth') return auth(rest);
   if (command === 'platform') return platform(rest);
@@ -58,12 +63,14 @@ function printHelp() {
 
 Usage:
   openxiangda login <platform-url> [--profile name]
+  openxiangda update check|install [--json] [--registry https://registry.npmjs.org]
   openxiangda platform add <name> <platform-url>
   openxiangda platform list
   openxiangda platform use <name>
   openxiangda auth status|refresh|logout [--profile name]
   openxiangda env [--profile name]
   openxiangda workspace init [dir] [--name package-name] [--install] [--profile name --app-type APP_XXX]
+  openxiangda workspace init [dir] --profile <name> --app-name <app-name> [--install]
   openxiangda workspace bind --profile <name> --app-type <APP_XXX>
   openxiangda workspace publish --profile <name> [--prune]
   openxiangda app list [--profile name] [--json]
@@ -102,6 +109,199 @@ OpenXiangda 使用普通用户登录 token，不需要 AK/SK。
 JS_CODE V2 使用 trusted_node；AI 源码必须写在 src/js-code-nodes/<scriptCode>/index.ts，definition-json 中的 sourceFile.localPath 会在 validate/create 时先 TS 校验、再构建并上传为快照。`);
 }
 
+async function update(args) {
+  const requestedSubcommand = args[0] && !args[0].startsWith('--') ? args[0] : 'check';
+  const parsedArgs = requestedSubcommand === args[0] ? args.slice(1) : args;
+  const { flags } = parseArgs(parsedArgs);
+  const registry = normalizeNpmRegistry(flags.registry || OFFICIAL_NPM_REGISTRY);
+
+  if (requestedSubcommand === 'check') {
+    const result = checkOpenXiangdaUpdate(registry);
+    if (flags.json) return writeJson(result);
+    printUpdateCheck(result);
+    return;
+  }
+
+  if (requestedSubcommand === 'install') {
+    const result = installOpenXiangdaUpdate(registry, {
+      json: Boolean(flags.json),
+      skipSkills: Boolean(flags['no-skills']),
+    });
+    if (flags.json) return writeJson(result);
+    print('OpenXiangda 已更新。');
+    if (result.skillInstall?.attempted && result.skillInstall.status !== 0) {
+      warn(`skill install 未完成: ${result.skillInstall.error}`);
+    }
+    return;
+  }
+
+  fail('用法: openxiangda update check|install [--json] [--registry https://registry.npmjs.org] [--no-skills]');
+}
+
+function normalizeNpmRegistry(value) {
+  const registry = String(value || OFFICIAL_NPM_REGISTRY).trim();
+  return registry.replace(/\/+$/, '') || OFFICIAL_NPM_REGISTRY;
+}
+
+function checkOpenXiangdaUpdate(registry) {
+  const latestVersion = fetchLatestOpenXiangdaVersion(registry);
+  const versionComparison = compareVersions(latestVersion, CURRENT_VERSION);
+  const updateAvailable = versionComparison > 0;
+  return {
+    packageName: NPM_PACKAGE_NAME,
+    currentVersion: CURRENT_VERSION,
+    latestVersion,
+    registry,
+    updateAvailable,
+    status: updateAvailable
+      ? 'update_available'
+      : versionComparison < 0
+        ? 'local_newer_than_registry'
+        : 'latest',
+    installCommand: `npm install -g ${NPM_PACKAGE_NAME}@latest --registry=${registry}`,
+    skillInstallCommand: 'openxiangda skill install --force',
+    compatibilityCheckCommand: 'openxiangda commands --json',
+    checkedAt: new Date().toISOString(),
+    notes: [
+      'Use the official npm registry for OpenXiangda updates; domestic mirrors may lag.',
+      'After updating the package, refresh OpenXiangda skills so AI guidance matches the CLI version.',
+    ],
+  };
+}
+
+function fetchLatestOpenXiangdaVersion(registry) {
+  const result = spawnSync(
+    'npm',
+    ['view', `${NPM_PACKAGE_NAME}@latest`, 'version', `--registry=${registry}`, '--json'],
+    {
+      encoding: 'utf8',
+      env: { ...process.env, npm_config_registry: registry },
+    }
+  );
+  if (result.error) {
+    fail(`无法执行 npm: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    fail(`检查 OpenXiangda 更新失败: ${formatSpawnOutput(result)}`);
+  }
+  const raw = String(result.stdout || '').trim();
+  if (!raw) fail('检查 OpenXiangda 更新失败: npm 未返回版本号');
+  try {
+    const parsed = JSON.parse(raw);
+    return String(parsed).trim();
+  } catch (_error) {
+    return raw.replace(/^"|"$/g, '').trim();
+  }
+}
+
+function installOpenXiangdaUpdate(registry, options = {}) {
+  const npmArgs = [
+    'install',
+    '-g',
+    `${NPM_PACKAGE_NAME}@latest`,
+    `--registry=${registry}`,
+  ];
+  const quiet = Boolean(options.json);
+  if (!quiet) {
+    print(`执行: npm ${npmArgs.join(' ')}`);
+  }
+  const installResult = spawnSync('npm', npmArgs, {
+    encoding: 'utf8',
+    stdio: quiet ? 'pipe' : 'inherit',
+    env: { ...process.env, npm_config_registry: registry },
+  });
+  if (installResult.error) {
+    fail(`无法执行 npm: ${installResult.error.message}`);
+  }
+  if (installResult.status !== 0) {
+    fail(`OpenXiangda 更新失败: ${formatSpawnOutput(installResult)}`);
+  }
+
+  const result = {
+    packageName: NPM_PACKAGE_NAME,
+    registry,
+    installCommand: `npm ${npmArgs.join(' ')}`,
+    installed: true,
+    skillInstall: {
+      attempted: false,
+      status: null,
+      error: null,
+    },
+  };
+
+  if (!options.skipSkills) {
+    if (!quiet) {
+      print('刷新 OpenXiangda skills: openxiangda skill install --force');
+    }
+    const skillResult = spawnSync('openxiangda', ['skill', 'install', '--force'], {
+      encoding: 'utf8',
+      stdio: quiet ? 'pipe' : 'inherit',
+      env: process.env,
+    });
+    result.skillInstall.attempted = true;
+    result.skillInstall.status = skillResult.status;
+    if (skillResult.error || skillResult.status !== 0) {
+      result.skillInstall.error = skillResult.error?.message || formatSpawnOutput(skillResult);
+    }
+  }
+
+  return result;
+}
+
+function printUpdateCheck(result) {
+  const lines = [
+    'OpenXiangda update check',
+    `current: ${result.currentVersion}`,
+    `latest: ${result.latestVersion}`,
+    `registry: ${result.registry}`,
+  ];
+  if (result.updateAvailable) {
+    lines.push('status: update available');
+    lines.push('recommended:');
+    lines.push(`  ${result.installCommand}`);
+    lines.push(`  ${result.skillInstallCommand}`);
+  } else if (result.status === 'local_newer_than_registry') {
+    lines.push('status: local version is newer than registry');
+  } else {
+    lines.push('status: already latest');
+  }
+  lines.push(`compatibility: ${result.compatibilityCheckCommand}`);
+  print(lines.join('\n'));
+}
+
+function formatSpawnOutput(result) {
+  return (
+    String(result.stderr || '').trim() ||
+    String(result.stdout || '').trim() ||
+    `exit status ${result.status}`
+  );
+}
+
+function compareVersions(a, b) {
+  const left = parseSemver(a);
+  const right = parseSemver(b);
+  for (let index = 0; index < 3; index += 1) {
+    if (left.numbers[index] !== right.numbers[index]) {
+      return left.numbers[index] > right.numbers[index] ? 1 : -1;
+    }
+  }
+  if (left.prerelease === right.prerelease) return 0;
+  if (!left.prerelease) return 1;
+  if (!right.prerelease) return -1;
+  return left.prerelease > right.prerelease ? 1 : -1;
+}
+
+function parseSemver(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(String(value || ''));
+  if (!match) {
+    return { numbers: [0, 0, 0], prerelease: String(value || '') };
+  }
+  return {
+    numbers: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4] || '',
+  };
+}
+
 async function platform(args) {
   const [subcommand, ...rest] = args;
   const { flags, positional } = parseArgs(rest);
@@ -378,14 +578,49 @@ async function workspace(args) {
   const config = loadConfig();
 
   if (subcommand === 'init') {
+    let appType = flags['app-type'];
+    let profileName = flags.profile || null;
+    let createdApp = null;
+
+    if (flags['app-name']) {
+      if (appType) {
+        fail('workspace init 不能同时使用 --app-name 和 --app-type');
+      }
+      profileName = profileName || config.currentProfile;
+      if (!profileName) {
+        fail('workspace init --app-name 需要先选择 profile，或显式传 --profile <name>');
+      }
+      assertCanInitializeWorkspace({
+        dir: positional[0],
+        force: flags.force,
+      });
+      const data = await createPlatformApp(config, profileName, {
+        name: flags['app-name'],
+        description: flags.description || '',
+        iconfontCss: flags['iconfont-css'] || '',
+      });
+      appType = extractCreatedAppType(data);
+      if (!appType) {
+        fail('应用已创建，但平台响应缺少 appType，无法写入 workspace 绑定');
+      }
+      createdApp = {
+        name: flags['app-name'],
+        appType,
+        data,
+      };
+    }
+
     const result = initWorkspace({
       dir: positional[0],
       name: flags.name,
       install: flags.install,
       force: flags.force,
-      profile: flags.profile,
-      appType: flags['app-type'],
+      profile: profileName,
+      appType,
     });
+    if (createdApp) {
+      result.createdApp = createdApp;
+    }
     if (flags.json) return writeJson(result);
     printWorkspaceInitReport(result);
     return;
@@ -418,6 +653,7 @@ async function workspace(args) {
       },
       updatedAt: new Date().toISOString(),
     };
+    ensureResourceBuckets(state.profiles[profileName]);
     saveProjectState(state);
     print(`当前工作区已绑定 ${profileName}: ${appType}`);
     return;
@@ -463,13 +699,10 @@ async function app(args) {
   if (subcommand === 'create') {
     const name = flags.name || positional.join(' ');
     if (!name) fail('用法: openxiangda app create <name> [--profile name]');
-    const data = await requestWithAuth(config, profileName, '/openxiangda-api/v1/apps/', {
-      method: 'POST',
-      body: {
-        name,
-        description: flags.description || '',
-        iconfontCss: flags['iconfont-css'] || '',
-      },
+    const data = await createPlatformApp(config, profileName, {
+      name,
+      description: flags.description || '',
+      iconfontCss: flags['iconfont-css'] || '',
     });
     if (flags.json) return writeJson(data);
     print(JSON.stringify(data, null, 2));
@@ -490,6 +723,29 @@ async function app(args) {
   print(JSON.stringify(data, null, 2));
 }
 
+async function createPlatformApp(config, profileName, payload) {
+  return requestWithAuth(config, profileName, '/openxiangda-api/v1/apps/', {
+    method: 'POST',
+    body: {
+      name: payload.name,
+      description: payload.description || '',
+      iconfontCss: payload.iconfontCss || '',
+    },
+  });
+}
+
+function extractCreatedAppType(data) {
+  const candidates = [
+    data?.appType,
+    data?.app?.appType,
+    data?.result?.appType,
+    data?.application?.appType,
+    data?.type,
+  ];
+  const value = candidates.find(item => typeof item === 'string' && item.trim());
+  return value ? value.trim() : null;
+}
+
 async function form(args) {
   const [subcommand, ...rest] = args;
   const { flags, positional } = parseArgs(rest);
@@ -1800,10 +2056,11 @@ async function commands(args) {
     name: 'openxiangda',
     commands: [
       'login <platform-url> [--profile name]',
+      'update check|install',
       'platform add|list|use|remove',
       'auth status|refresh|logout',
       'env',
-      'workspace init|bind|publish [--prune]',
+      'workspace init|bind|publish [--app-name] [--prune]',
       'app list|create|snapshot',
       'form list|create|bind|pull|publish',
       'page list|publish|bind|releases|activate',
@@ -1828,6 +2085,9 @@ function printWorkspaceInitReport(result) {
     `已创建 OpenXiangda workspace: ${result.targetDir}`,
     `package: ${result.packageName}`,
   ];
+  if (result.createdApp) {
+    lines.push(`已创建平台应用: ${result.createdApp.name} (${result.createdApp.appType})`);
+  }
   if (result.bound) {
     lines.push(`已绑定 ${result.bound.profile}: ${result.bound.appType}`);
   }
@@ -1952,6 +2212,9 @@ function ensureResourceBuckets(bound) {
   bound.resources.menus = bound.resources.menus || {};
   bound.resources.roles = bound.resources.roles || {};
   bound.resources.connectors = bound.resources.connectors || {};
+  bound.resources.notifications = bound.resources.notifications || {};
+  bound.resources.notifications.templates = bound.resources.notifications.templates || {};
+  bound.resources.notifications.typeConfigs = bound.resources.notifications.typeConfigs || {};
   bound.resources.pagePermissionGroups = bound.resources.pagePermissionGroups || {};
   bound.resources.formPermissionGroups = bound.resources.formPermissionGroups || {};
   bound.resources.formSettings = bound.resources.formSettings || {};
@@ -2156,6 +2419,46 @@ function saveConnectorResource(target, connectorCode, connectorId, extra = {}) {
   }, ['connectorId', 'apis']);
 }
 
+function saveNotificationTemplateResource(target, templateCode, templateId, extra = {}) {
+  const nextBound = prepareStateResourceWrite(target);
+  nextBound.resources.notifications.templates[templateCode] = {
+    templateId,
+    ...pickStateFields(extra, ['level', 'formUuid']),
+    updatedAt: new Date().toISOString(),
+  };
+  saveProjectState(target.state);
+}
+
+function saveNotificationTypeConfigResource(target, configCode, configId, extra = {}) {
+  const nextBound = prepareStateResourceWrite(target);
+  nextBound.resources.notifications.typeConfigs[configCode] = {
+    configId,
+    ...pickStateFields(extra, [
+      'notificationType',
+      'level',
+      'formUuid',
+      'templateId',
+      'templateCode',
+    ]),
+    updatedAt: new Date().toISOString(),
+  };
+  saveProjectState(target.state);
+}
+
+function prepareStateResourceWrite(target) {
+  target.state.profiles = target.state.profiles || {};
+  target.state.profiles[target.profileName] = {
+    ...target.bound,
+    baseUrl: target.profile.baseUrl,
+    appType: target.appType,
+    updatedAt: new Date().toISOString(),
+  };
+  const nextBound = target.state.profiles[target.profileName];
+  ensureResourceBuckets(nextBound);
+  target.bound = nextBound;
+  return nextBound;
+}
+
 function savePagePermissionGroupResource(target, groupCode, groupId) {
   saveStateResource(target, 'pagePermissionGroups', groupCode, { groupId }, ['groupId']);
 }
@@ -2202,6 +2505,7 @@ function pickStateFields(value, keys) {
 const RESOURCE_SPECS = [
   { key: 'roles', dir: 'roles', topFiles: ['roles.json'], pluralKeys: ['roles'] },
   { key: 'connectors', dir: 'connectors', topFiles: ['connectors.json'], pluralKeys: ['connectors'] },
+  { key: 'notifications', dir: 'notifications', topFiles: ['notifications.json'], pluralKeys: ['notifications'] },
   { key: 'menus', dir: 'menus', topFiles: ['menus.json'], pluralKeys: ['menus'] },
   { key: 'workflows', dir: 'workflows', topFiles: ['workflows.json'], pluralKeys: ['workflows'] },
   { key: 'automations', dir: 'automations', topFiles: ['automations.json'], pluralKeys: ['automations'] },
@@ -2280,6 +2584,7 @@ function readResourceItemsFromFile(filePath, spec) {
       item.code ||
       item.resourceCode ||
       item.methodName ||
+      (spec.key === 'notifications' ? inferNotificationResourceCode(item) : undefined) ||
       item.formCode ||
       (values.length === 1 ? defaultCode : undefined);
     return {
@@ -2292,7 +2597,20 @@ function readResourceItemsFromFile(filePath, spec) {
   });
 }
 
+function inferNotificationResourceCode(item) {
+  const resourceType = normalizeNotificationResourceType(item);
+  if (resourceType === 'template') return item.code || item.templateCode;
+  if (resourceType !== 'typeConfig' || !item.notificationType) {
+    return item.notificationType || item.templateCode;
+  }
+  const level = item.level || (item.formCode || item.formUuid ? 'form' : 'app');
+  if (level === 'app') return item.notificationType;
+  const formKey = item.formCode || item.formUuid || 'form';
+  return `${level}:${formKey}:${item.notificationType}`;
+}
+
 function extractResourceValues(value, spec) {
+  if (spec.key === 'notifications') return extractNotificationResourceValues(value);
   if (Array.isArray(value)) return value;
   if (!value || typeof value !== 'object') return [value];
   for (const key of spec.pluralKeys || []) {
@@ -2302,6 +2620,29 @@ function extractResourceValues(value, spec) {
   return [value];
 }
 
+function extractNotificationResourceValues(value) {
+  if (Array.isArray(value)) return value;
+  if (!value || typeof value !== 'object') return [value];
+  const result = [];
+  for (const template of value.templates || []) {
+    result.push({ ...template, resourceType: 'template' });
+  }
+  for (const config of value.typeConfigs || value.notificationTypeConfigs || []) {
+    result.push({ ...config, resourceType: 'typeConfig' });
+  }
+  if (Array.isArray(value.notifications)) {
+    result.push(...value.notifications);
+  }
+  if (result.length > 0) return result;
+  if (value.template || value.typeConfig) {
+    return [
+      value.template ? { ...value.template, resourceType: 'template' } : null,
+      value.typeConfig ? { ...value.typeConfig, resourceType: 'typeConfig' } : null,
+    ].filter(Boolean);
+  }
+  return [value];
+}
+
 function listJsonFiles(dirPath) {
   if (!fs.existsSync(dirPath)) return [];
   return fs
@@ -2325,6 +2666,7 @@ function validateWorkspaceResources(manifest) {
       validateResourceItem(spec.key, item, errors, warnings);
     }
   }
+  validateNotificationReferences(manifest.notifications || [], errors);
   return {
     valid: errors.length === 0,
     errors,
@@ -2357,6 +2699,11 @@ function validateResourceItem(kind, item, errors, warnings) {
     return;
   }
 
+  if (kind === 'notifications') {
+    validateNotificationResourceItem(item, errors, warnings);
+    return;
+  }
+
   if (kind === 'roles' && !item.name) errors.push(`${label}: 缺少 name`);
   if (kind === 'menus' && !item.name) errors.push(`${label}: 缺少 name`);
   if (kind === 'workflows') {
@@ -2392,6 +2739,99 @@ function validateResourceItem(kind, item, errors, warnings) {
   }
 }
 
+const NOTIFICATION_CHANNELS = new Set([
+  'inapp',
+  'email',
+  'dingding',
+  'wechat',
+  'thirdparty_todo',
+]);
+
+function validateNotificationResourceItem(item, errors, warnings) {
+  const label = resourceLabel('notifications', item);
+  const resourceType = normalizeNotificationResourceType(item);
+  if (!resourceType) {
+    errors.push(`${label}: resourceType 必须是 template 或 typeConfig`);
+    return;
+  }
+
+  if (resourceType === 'template') {
+    if (!item.code) errors.push(`${label}: 通知模板缺少 code`);
+    if (!item.name) errors.push(`${label}: 通知模板缺少 name`);
+    if (item.level && !['app', 'form'].includes(item.level)) {
+      errors.push(`${label}: OpenXiangda 通知模板 level 只能是 app 或 form`);
+    }
+    if ((item.level === 'form' || item.formCode || item.formUuid) && !item.formCode && !item.formUuid) {
+      errors.push(`${label}: 表单级通知模板缺少 formCode 或 formUuid`);
+    }
+    if (!item.content && !item.channelsConfig) {
+      warnings.push(`${label}: 未声明 content 或 channelsConfig`);
+    }
+    validateNotificationChannels(label, item.channelsConfig, errors);
+    return;
+  }
+
+  if (!item.notificationType) errors.push(`${label}: 通知类型配置缺少 notificationType`);
+  if (!item.templateCode && !item.templateId) {
+    errors.push(`${label}: 通知类型配置缺少 templateCode 或 templateId`);
+  }
+  if (item.level && !['app', 'form'].includes(item.level)) {
+    errors.push(`${label}: OpenXiangda 通知类型配置 level 只能是 app 或 form`);
+  }
+  if ((item.level === 'form' || item.formCode || item.formUuid) && !item.formCode && !item.formUuid) {
+    errors.push(`${label}: 表单级通知类型配置缺少 formCode 或 formUuid`);
+  }
+}
+
+function normalizeNotificationResourceType(item) {
+  const value = item.resourceType || item.kind || item.type;
+  if (value === 'template' || value === 'notificationTemplate') return 'template';
+  if (value === 'typeConfig' || value === 'notificationTypeConfig') return 'typeConfig';
+  if (item.notificationType || item.templateCode || item.templateId) return 'typeConfig';
+  if (item.channelsConfig || item.content || item.variables) return 'template';
+  return undefined;
+}
+
+function validateNotificationReferences(items, errors) {
+  const templates = new Set(
+    (items || [])
+      .filter(item => normalizeNotificationResourceType(item) === 'template')
+      .map(item => item.code)
+      .filter(Boolean)
+  );
+  for (const item of items || []) {
+    if (normalizeNotificationResourceType(item) !== 'typeConfig') continue;
+    if (item.templateCode && !templates.has(item.templateCode) && !item.templateId) {
+      errors.push(
+        `${resourceLabel('notifications', item)}: templateCode ${item.templateCode} 未在 src/resources/notifications 中声明`
+      );
+    }
+  }
+}
+
+function validateNotificationChannels(label, channelsConfig, errors) {
+  if (!channelsConfig || typeof channelsConfig !== 'object' || Array.isArray(channelsConfig)) {
+    return;
+  }
+  for (const [channel, config] of Object.entries(channelsConfig)) {
+    if (!NOTIFICATION_CHANNELS.has(channel)) {
+      errors.push(`${label}: 不支持的通知渠道 ${channel}`);
+    }
+    validateNoSensitiveNotificationConfig(`${label}.channelsConfig.${channel}`, config, errors);
+  }
+}
+
+function validateNoSensitiveNotificationConfig(label, value, errors) {
+  if (!value || typeof value !== 'object') return;
+  for (const [key, item] of Object.entries(value)) {
+    if (/token|secret|password|authorization|auth|credential|headers/i.test(key)) {
+      errors.push(`${label}.${key}: 通知资源不允许配置通道密钥或鉴权字段`);
+      continue;
+    }
+    validateNoSensitiveNotificationConfig(`${label}.${key}`, item, errors);
+  }
+}
+
 function resourceLabel(kind, item) {
   return `${kind}:${item.code || item.__source || item.__index || '?'}`;
 }
@@ -2412,6 +2852,7 @@ async function buildResourcePlan(config, target, manifest) {
   addPlanActions(actions, 'role', manifest.roles, existing.roles, roleEquals);
   addPlanActions(actions, 'menu', manifest.menus, existing.menus, (item, current) => menuEquals(target.bound, item, current));
   addPlanActions(actions, 'connector', manifest.connectors, existing.connectors, connectorEquals);
+  addNotificationPlanActions(target, actions, manifest.notifications || [], existing);
   await addWorkflowPlanActions(config, target, actions, manifest.workflows, existing.workflows);
   await addAutomationPlanActions(config, target, actions, manifest.automations, existing.automations);
   addPlanActions(actions, 'pagePermissionGroup', manifest.pagePermissionGroups, existing.pagePermissionGroups, (item, current) => pagePermissionGroupEquals(target.bound, item, current));
@@ -2444,6 +2885,7 @@ async function publishResourceManifest(config, target, manifest, options = {}) {
   await publishFormSettingsResources(config, target, manifest.formSettings || [], result);
   await publishMenuResources(config, target, manifest.menus || [], result);
   await publishConnectorResources(config, target, manifest.connectors || [], result);
+  await publishNotificationResources(config, target, manifest.notifications || [], result);
   await publishWorkflowResources(config, target, manifest.workflows || [], result);
   await publishAutomationResources(config, target, manifest.automations || [], result);
   await publishPagePermissionGroupResources(config, target, manifest.pagePermissionGroups || [], result);
@@ -2463,6 +2905,8 @@ async function fetchExistingResourceMaps(config, target, manifest) {
     roles: new Map(),
     menus: new Map(),
     connectors: new Map(),
+    notificationTemplates: new Map(),
+    notificationTypeConfigs: new Map(),
     workflows: new Map(),
     automations: new Map(),
     pagePermissionGroups: new Map(),
@@ -2496,6 +2940,31 @@ async function fetchExistingResourceMaps(config, target, manifest) {
     );
     indexByCode(maps.connectors, normalizeItems(data), item => item.code || item.methodName);
   }
+  if ((manifest.notifications || []).length > 0) {
+    const templates = await requestWithAuth(
+      config,
+      target.profileName,
+      apiPathWithQuery(`/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/notifications/templates`, {
+        page: 1,
+        limit: 1000,
+      })
+    );
+    indexByCode(maps.notificationTemplates, normalizeItems(templates), item => item.code);
+
+    const typeConfigs = await requestWithAuth(
+      config,
+      target.profileName,
+      apiPathWithQuery(`/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/notifications/type-configs`, {
+        page: 1,
+        limit: 1000,
+      })
+    );
+    indexByCode(
+      maps.notificationTypeConfigs,
+      normalizeItems(typeConfigs),
+      item => notificationTypeConfigExistingKey(item)
+    );
+  }
   if ((manifest.workflows || []).length > 0) {
     const data = await requestWithAuth(
       config,
@@ -2558,6 +3027,37 @@ function addPlanActions(actions, kind, desiredItems = [], existingMap, equals) {
   }
 }
 
+function addNotificationPlanActions(target, actions, notificationItems = [], existing) {
+  const { templates, typeConfigs } = splitNotificationResources(notificationItems);
+  for (const template of templates) {
+    const existingTemplate = existing.notificationTemplates.get(template.code);
+    actions.push({
+      kind: 'notificationTemplate',
+      code: template.code,
+      action: existingTemplate
+        ? notificationTemplateEquals(target.bound, template, existingTemplate)
+          ? 'noop'
+          : 'update'
+        : 'create',
+      platformId: existingTemplate?.id,
+    });
+  }
+  for (const config of typeConfigs) {
+    const key = notificationTypeConfigDesiredKey(target.bound, config);
+    const existingConfig = existing.notificationTypeConfigs.get(key);
+    actions.push({
+      kind: 'notificationTypeConfig',
+      code: config.code || config.notificationType,
+      action: existingConfig
+        ? notificationTypeConfigEquals(target.bound, config, existingConfig)
+          ? 'noop'
+          : 'update'
+        : 'create',
+      platformId: existingConfig?.id,
+    });
+  }
+}
+
 async function addWorkflowPlanActions(config, target, actions, desiredItems = [], existingMap) {
   for (const item of desiredItems) {
     const code = item.code || item.resourceCode;
@@ -2842,6 +3342,57 @@ async function publishConnectorResources(config, target, connectors, result) {
   }
 }
 
+async function publishNotificationResources(config, target, notifications, result) {
+  const { templates, typeConfigs } = splitNotificationResources(notifications);
+  for (const template of templates) {
+    const body = normalizeNotificationTemplateManifest(target.bound, template);
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/notifications/templates/${encodeURIComponent(template.code)}`,
+      { method: 'PUT', body }
+    );
+    if (data?.id) {
+      saveNotificationTemplateResource(target, template.code, data.id, {
+        level: data.level || body.level,
+        formUuid: data.formUuid || body.formUuid,
+      });
+    }
+    result.published.push({
+      kind: 'notificationTemplate',
+      code: template.code,
+      action: data?.created ? 'create' : 'update',
+      id: data?.id,
+    });
+  }
+
+  for (const configItem of typeConfigs) {
+    const body = normalizeNotificationTypeConfigManifest(target.bound, configItem);
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/notifications/type-configs/${encodeURIComponent(configItem.notificationType)}`,
+      { method: 'PUT', body }
+    );
+    const stateCode = configItem.code || notificationTypeConfigDesiredKey(target.bound, configItem);
+    if (data?.id) {
+      saveNotificationTypeConfigResource(target, stateCode, data.id, {
+        notificationType: data.notificationType || configItem.notificationType,
+        level: data.level || body.level,
+        formUuid: data.formUuid || body.formUuid,
+        templateId: data.templateId,
+        templateCode: data.template?.code || configItem.templateCode,
+      });
+    }
+    result.published.push({
+      kind: 'notificationTypeConfig',
+      code: configItem.code || configItem.notificationType,
+      action: data?.created ? 'create' : 'update',
+      id: data?.id,
+    });
+  }
+}
+
 async function publishWorkflowResources(config, target, workflows, result) {
   for (const workflowItem of workflows) {
     const existing = await findExistingWorkflow(config, target, workflowItem.code);
@@ -3379,6 +3930,40 @@ async function pullResources(config, target) {
     written.push(path.relative(process.cwd(), filePath));
   }
 
+  const notificationTemplates = await requestWithAuth(
+    config,
+    target.profileName,
+    apiPathWithQuery(`/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/notifications/templates`, {
+      page: 1,
+      limit: 1000,
+    })
+  );
+  for (const template of normalizeItems(notificationTemplates)) {
+    const code = template.code || template.id;
+    const filePath = path.join(baseDir, 'notifications', 'templates', `${code}.json`);
+    writeResourceJsonFile(filePath, {
+      templates: [toPulledNotificationTemplate(template, pullLookups)],
+    });
+    written.push(path.relative(process.cwd(), filePath));
+  }
+
+  const notificationTypeConfigs = await requestWithAuth(
+    config,
+    target.profileName,
+    apiPathWithQuery(`/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/notifications/type-configs`, {
+      page: 1,
+      limit: 1000,
+    })
+  );
+  for (const configItem of normalizeItems(notificationTypeConfigs)) {
+    const code = notificationTypeConfigExistingKey(configItem).replace(/[^a-zA-Z0-9_.-]+/g, '_');
+    const filePath = path.join(baseDir, 'notifications', 'type-configs', `${code}.json`);
+    writeResourceJsonFile(filePath, {
+      typeConfigs: [toPulledNotificationTypeConfig(configItem, pullLookups)],
+    });
+    written.push(path.relative(process.cwd(), filePath));
+  }
+
   const menus = await requestWithAuth(
     config,
     target.profileName,
@@ -3598,6 +4183,47 @@ function splitPagePermissionTargetsForManifest(values = [], lookups) {
   };
 }
 
+function toPulledNotificationTemplate(template, lookups) {
+  const formCode = lookups.formCodeByUuid.get(template.formUuid);
+  return stripUndefinedValues({
+    code: template.code,
+    name: template.name,
+    content: template.content || '',
+    description: template.description || '',
+    level: template.level === 'form' ? 'form' : 'app',
+    ...(formCode ? { formCode } : template.formUuid ? { formUuid: template.formUuid } : {}),
+    priority: template.priority,
+    enabled: template.enabled,
+    variables: template.variables || undefined,
+    channelsConfig: stripNotificationSecrets(template.channelsConfig),
+  });
+}
+
+function toPulledNotificationTypeConfig(configItem, lookups) {
+  const formCode = lookups.formCodeByUuid.get(configItem.formUuid);
+  return stripUndefinedValues({
+    code: notificationTypeConfigExistingKey(configItem),
+    notificationType: configItem.notificationType,
+    level: configItem.level === 'form' ? 'form' : 'app',
+    ...(formCode ? { formCode } : configItem.formUuid ? { formUuid: configItem.formUuid } : {}),
+    templateCode: configItem.template?.code,
+    enabled: configItem.enabled,
+    priority: configItem.priority,
+    description: configItem.description || '',
+  });
+}
+
+function stripNotificationSecrets(value) {
+  if (!value || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map(stripNotificationSecrets);
+  const next = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (/token|secret|password|authorization|auth|credential|headers/i.test(key)) continue;
+    next[key] = stripNotificationSecrets(item);
+  }
+  return next;
+}
+
 function writeResourceJsonFile(filePath, value) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
@@ -3671,6 +4297,58 @@ function parseConnectorUrl(connector) {
   }
 }
 
+function splitNotificationResources(items = []) {
+  const templates = [];
+  const typeConfigs = [];
+  for (const item of items || []) {
+    const resourceType = normalizeNotificationResourceType(item);
+    if (resourceType === 'template') templates.push(item);
+    if (resourceType === 'typeConfig') typeConfigs.push(item);
+  }
+  return { templates, typeConfigs };
+}
+
+function normalizeNotificationTemplateManifest(bound, template) {
+  const level = template.level || (template.formCode || template.formUuid ? 'form' : 'app');
+  const formUuid = level === 'form' ? resolveManifestFormUuid(bound, template) : undefined;
+  return stripUndefinedValues({
+    name: template.name || template.code,
+    content: template.content || '',
+    description: template.description || '',
+    channelsConfig: template.channelsConfig,
+    level,
+    formUuid,
+    priority: template.priority,
+    enabled: template.enabled,
+    variables: template.variables,
+  });
+}
+
+function normalizeNotificationTypeConfigManifest(bound, config) {
+  const level = config.level || (config.formCode || config.formUuid ? 'form' : 'app');
+  const formUuid = level === 'form' ? resolveManifestFormUuid(bound, config) : undefined;
+  return stripUndefinedValues({
+    level,
+    formUuid,
+    templateId: config.templateId,
+    templateCode: config.templateCode,
+    enabled: config.enabled,
+    priority: config.priority,
+    description: config.description || '',
+  });
+}
+
+function notificationTypeConfigDesiredKey(bound, config) {
+  const level = config.level || (config.formCode || config.formUuid ? 'form' : 'app');
+  const formUuid = level === 'form' ? resolveManifestFormUuid(bound, config) : '';
+  return `${level}:${formUuid || ''}:${config.notificationType}`;
+}
+
+function notificationTypeConfigExistingKey(config) {
+  const level = config.level || 'app';
+  return `${level}:${config.formUuid || ''}:${config.notificationType}`;
+}
+
 async function resolveManifestJson(config, profileName, item, objectKey, fileKey, optional = false) {
   let value = item[objectKey];
   if (value === undefined && item[fileKey]) {
@@ -3778,6 +4456,40 @@ function connectorEquals(desired, existing) {
   return JSON.stringify(normalizedExisting) === JSON.stringify(normalizedDesired);
 }
 
+function notificationTemplateEquals(bound, desired, existing) {
+  if (!existing) return false;
+  const expected = normalizeNotificationTemplateManifest(bound, desired);
+  return (
+    String(existing.code || '') === String(desired.code || '') &&
+    String(existing.name || '') === String(expected.name || '') &&
+    String(existing.content || '') === String(expected.content || '') &&
+    String(existing.description || '') === String(expected.description || '') &&
+    String(existing.level || 'app') === String(expected.level || 'app') &&
+    String(existing.formUuid || '') === String(expected.formUuid || '') &&
+    optionalScalarEquals(existing.priority, expected.priority, expected.priority !== undefined) &&
+    optionalScalarEquals(Boolean(existing.enabled), Boolean(expected.enabled), expected.enabled !== undefined) &&
+    jsonEqualsForPlan(existing.variables || [], expected.variables || [], desired.__dir) &&
+    jsonEqualsForPlan(existing.channelsConfig || {}, expected.channelsConfig || {}, desired.__dir)
+  );
+}
+
+function notificationTypeConfigEquals(bound, desired, existing) {
+  if (!existing) return false;
+  const expected = normalizeNotificationTypeConfigManifest(bound, desired);
+  const existingTemplateCode = existing.template?.code;
+  return (
+    String(existing.notificationType || '') === String(desired.notificationType || '') &&
+    String(existing.level || 'app') === String(expected.level || 'app') &&
+    String(existing.formUuid || '') === String(expected.formUuid || '') &&
+    (expected.templateId
+      ? String(existing.templateId || '') === String(expected.templateId)
+      : String(existingTemplateCode || '') === String(expected.templateCode || '')) &&
+    optionalScalarEquals(Boolean(existing.enabled), Boolean(expected.enabled), expected.enabled !== undefined) &&
+    optionalScalarEquals(existing.priority, expected.priority, expected.priority !== undefined) &&
+    String(existing.description || '') === String(expected.description || '')
+  );
+}
+
 function pagePermissionGroupEquals(bound, desired, existing) {
   if (!existing) return false;
   const desiredTargets = resolvePagePermissionGroupTargets(bound, desired);