openxiangda 1.0.21 → 1.0.22

package/lib/cli.js

@@ -1952,6 +1952,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 +2159,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 +2245,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 +2324,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 +2337,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 +2360,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 +2406,7 @@ function validateWorkspaceResources(manifest) {
       validateResourceItem(spec.key, item, errors, warnings);
     }
   }
+  validateNotificationReferences(manifest.notifications || [], errors);
   return {
     valid: errors.length === 0,
     errors,
@@ -2357,6 +2439,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 +2479,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 +2592,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 +2625,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 +2645,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 +2680,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 +2767,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 +3082,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 +3670,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 +3923,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 +4037,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 +4196,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);

package/openxiangda-skills/SKILL.md

@@ -105,6 +105,7 @@ Core CLI / state:
 - `references/openxiangda-api.md` — `/openxiangda-api/v1` request and response fields.
 - `references/workspace-state.md` — `.openxiangda/state.json` shape and profile isolation rules.
 - `references/connector-resources.md` — `src/resources` manifests, connector schema, and SDK connector calls.
+- `references/notifications.md` — `src/resources/notifications`, notification templates/type bindings, and `sdk.notification` / `ctx.notification`.
 
 Form authoring:
 

package/openxiangda-skills/references/automation-v3.md

@@ -123,6 +123,8 @@ The backend runs the snapshot in the trusted Node runtime, applies the node time
 
 Runtime context includes `ctx.triggerEvent`, `ctx.formData`, `ctx.workflowData`, `ctx.operator`, `ctx.app`, `ctx.variables`, and `ctx.node`. Data/process bridge methods include `ctx.methods.queryOneData`, `queryManyData`, `updateOneData`, `updateDataByFormInstanceId`, `updateManyData`, `createOneData`, `terminateProcess`, and `getAllParentDepartments`.
 
+Notification bridge methods include `ctx.notification.sendByType`, `batchSendByType`, `findConfig`, and `previewTemplate`. For custom business messages, create `src/resources/notifications/` first and use its `notificationType`; do not call legacy `/api/notification-config/*` endpoints directly.
+
 Example `src/js-code-nodes/scheduled_reconcile/index.ts`:
 
 ```ts

package/openxiangda-skills/references/connector-resources.md

@@ -5,6 +5,7 @@ OpenXiangda engineering resources live under `src/resources/`.
 Common folders:
 
 - `connectors`
+- `notifications`
 - `roles`
 - `menus`
 - `workflows`
@@ -24,6 +25,8 @@ openxiangda resource pull --profile dev
 
 Connector manifests use stable `code` values. The platform maps connector `code` to the existing connector `methodName`, and API `code` to the existing connector API `methodName`.
 
+Notification manifests live under `src/resources/notifications/` and contain `templates` plus `typeConfigs`. See `notifications.md` before generating reminders or message templates.
+
 ```json
 {
   "code": "crm",