@77-zhike/app-sdk 0.2.0-d7b1.7 → 0.2.0-d7b1.9

package/src/toolchain/source-discovery.js

@@ -5,6 +5,8 @@ import { posix, relative, resolve, sep } from "node:path";
 import ts from "typescript";
 
 import { ZhikeCliError } from "../errors.js";
+import { discoverWorkflowBlock } from "./workflow-blocks/discovery.js";
+import { assertAllowedPackageImport } from "./dependency-policy.js";
 
 const KEY_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
 const RECORD_OBJECT_PATTERN = /^[a-z][a-z0-9_]{0,106}$/;
@@ -23,44 +25,6 @@ const LIFECYCLE_EVENTS = new Set([
   "connection-added",
   "connection-removed",
 ]);
-const SDK_IMPORTS = new Set([
-  "@77-zhike/app-sdk",
-  "@77-zhike/app-sdk/client",
-  "@77-zhike/app-sdk/ui",
-  "@77-zhike/app-sdk/forms",
-  "react",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "@77-zhike/app-sdk/server",
-]);
-const NODE_BUILTINS = new Set([
-  "assert",
-  "buffer",
-  "child_process",
-  "cluster",
-  "crypto",
-  "dgram",
-  "dns",
-  "events",
-  "fs",
-  "http",
-  "https",
-  "module",
-  "net",
-  "os",
-  "path",
-  "perf_hooks",
-  "process",
-  "readline",
-  "stream",
-  "tls",
-  "url",
-  "util",
-  "v8",
-  "vm",
-  "worker_threads",
-  "zlib",
-]);
 
 export async function discoverAppSources(projectDirectory) {
   const sourceRoot = resolve(projectDirectory, "src");
@@ -71,11 +35,7 @@ export async function discoverAppSources(projectDirectory) {
   }));
   rejectUnsupportedPaths(normalized);
 
-  const frontendExtensions = [];
-  const lifecycleEvents = [];
-  const serverFunctions = [];
-  const webhookHandlers = [];
-  const globalKeys = new Map();
+  const parsedFiles = [];
   for (const file of normalized) {
     const sourceText = await readFile(file.absolutePath, "utf8");
     const sourceFile = ts.createSourceFile(
@@ -86,6 +46,19 @@ export async function discoverAppSources(projectDirectory) {
       file.relativePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
     );
     assertSyntacticallyValid(sourceFile);
+    parsedFiles.push({ ...file, sourceFile });
+  }
+  const sourceFilesByPath = new Map(parsedFiles.map(file => [file.relativePath, file.sourceFile]));
+
+  const frontendExtensions = [];
+  const lifecycleEvents = [];
+  const serverFunctions = [];
+  const webhookHandlers = [];
+  const workflowSteps = [];
+  const workflowTriggers = [];
+  const globalKeys = new Map();
+  for (const file of parsedFiles) {
+    const { sourceFile } = file;
     validateImports(sourceFile, file.relativePath);
 
     const extensionMatch = file.relativePath.match(
@@ -103,6 +76,9 @@ export async function discoverAppSources(projectDirectory) {
     const serverMatch = file.relativePath.match(
       /^(server\/functions\/[a-z0-9][a-z0-9/-]*)\.server\.ts$/,
     );
+    const workflowBlockMatch = file.relativePath.match(
+      /^app\/blocks\/([a-z][a-z0-9-]{0,63})\/block\.ts$/,
+    );
     if (lifecycleMatch) {
       const definition = parseLifecycleEvent(
         sourceFile,
@@ -143,17 +119,30 @@ export async function discoverAppSources(projectDirectory) {
       );
       registerUniqueKey(globalKeys, definition.key, file.relativePath);
       serverFunctions.push(definition);
+    } else if (workflowBlockMatch) {
+      const definition = discoverWorkflowBlock(
+        sourceFile, file.relativePath, workflowBlockMatch[1], sourceFilesByPath,
+      );
+      if (definition.type === "step") {
+        registerUniqueKey(globalKeys, definition.entry, file.relativePath);
+        workflowSteps.push(definition);
+      } else {
+        for (const entry of Object.values(definition.entries)) registerUniqueKey(globalKeys, entry, file.relativePath);
+        workflowTriggers.push(definition);
+      }
     }
   }
   if (
     frontendExtensions.length === 0 &&
     lifecycleEvents.length === 0 &&
     serverFunctions.length === 0 &&
-    webhookHandlers.length === 0
+    webhookHandlers.length === 0 &&
+    workflowSteps.length === 0 &&
+    workflowTriggers.length === 0
   ) {
     throw toolchainError(
       "zhike_source_entry_missing",
-      "未发现一期 Lifecycle Event、Frontend Extension、Server Function 或 Webhook Handler",
+      "未发现 Lifecycle Event、Frontend Extension、Server Function、Webhook Handler 或 Workflow Block",
     );
   }
   if (frontendExtensions.filter(item => item.type === "settings").length > 1) {
@@ -163,8 +152,10 @@ export async function discoverAppSources(projectDirectory) {
     frontendExtensions: Object.freeze(sortByKey(frontendExtensions)),
     lifecycleEvents: Object.freeze(sortByKey(lifecycleEvents)),
     serverFunctions: Object.freeze(sortByKey(serverFunctions)),
-    sourceFiles: Object.freeze(normalized.map((file) => file.relativePath).sort()),
+    sourceFiles: Object.freeze(parsedFiles.map((file) => file.relativePath).sort()),
     webhookHandlers: Object.freeze(sortByKey(webhookHandlers)),
+    workflowSteps: Object.freeze(sortByKey(workflowSteps)),
+    workflowTriggers: Object.freeze(sortByKey(workflowTriggers)),
   });
 }
 
@@ -567,12 +558,22 @@ function hasNamedImport(statement, specifier, importedName) {
     );
 }
 
-function validateImports(sourceFile, relativePath) {
+export function validateImports(sourceFile, relativePath, options = {}) {
   const allowsStandardFetch =
-    relativePath.startsWith("server/") ||
-    /^app\/events\/.+\.event\.ts$/.test(relativePath) ||
-    /^app\/webhooks\/.+\.webhook\.ts$/.test(relativePath);
+    options.target === "server" || (!options.target && (
+      relativePath.startsWith("server/") ||
+      relativePath.startsWith("app/blocks/") ||
+      /^app\/events\/.+\.event\.ts$/.test(relativePath) ||
+      /^app\/webhooks\/.+\.webhook\.ts$/.test(relativePath)));
+  const target = allowsStandardFetch ? "server" : "client";
   const visit = (node) => {
+    if (ts.isImportEqualsDeclaration(node) ||
+      (ts.isExportAssignment(node) && node.isExportEquals) ||
+      (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require") ||
+      ((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
+        ts.isIdentifier(node.expression) && ["require", "module", "exports"].includes(node.expression.text))) {
+      throw toolchainError("zhike_commonjs_forbidden", relativePath + ": 只支持静态 ESM import/export，不支持 CommonJS");
+    }
     if (
       ts.isCallExpression(node) &&
       node.expression.kind === ts.SyntaxKind.ImportKeyword
@@ -626,27 +627,20 @@ function validateImports(sourceFile, relativePath) {
         `${relativePath}: App 源码不得直接读取 Host SDK global`,
       );
     }
-    if (ts.isImportDeclaration(node)) {
-      const specifier = node.moduleSpecifier.text;
+    const moduleSpecifier = (ts.isImportDeclaration(node) || ts.isExportDeclaration(node))
+      ? node.moduleSpecifier
+      : ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)
+        ? node.argument.literal : null;
+    if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+      const specifier = moduleSpecifier.text;
       if (specifier === "@77-zhike/app-sdk/server" && !allowsStandardFetch) {
         throw toolchainError(
           "zhike_server_sdk_client_forbidden",
           `${relativePath}: 前端代码不得导入服务端 SDK`,
         );
       }
-      if (specifier.startsWith("node:") || NODE_BUILTINS.has(specifier)) {
-        throw toolchainError(
-          "zhike_node_builtin_forbidden",
-          `${relativePath}: 一期禁止 Node builtin ${specifier}`,
-        );
-      }
-      if (!specifier.startsWith(".") && !SDK_IMPORTS.has(specifier)) {
-        throw toolchainError(
-          "zhike_external_dependency_forbidden",
-          `${relativePath}: 一期禁止第三方或内部依赖 ${specifier}`,
-        );
-      }
-      if (specifier.startsWith(".")) {
+      if (!specifier.startsWith(".")) assertAllowedPackageImport(specifier, target, relativePath);
+      if (specifier.startsWith(".") && !options.dependency) {
         const resolvedSourcePath = posix.normalize(
           posix.join(posix.dirname(relativePath), specifier),
         );
@@ -694,6 +688,23 @@ function rejectUnsupportedPaths(files) {
         `${path}: 一期不支持 Workflow/Event/Connection/Settings`,
       );
     }
+    if (path.startsWith("server/steps/") || path.startsWith("server/triggers/")) {
+      throw toolchainError(
+        "zhike_workflow_block_location_invalid",
+        `${path}: Workflow Block 必须位于 src/app/blocks/<block-key>/`,
+      );
+    }
+    if (path.startsWith("app/blocks/") && /\.(?:ts|tsx)$/.test(path)) {
+      const validBlockFile = /^app\/blocks\/[a-z][a-z0-9-]{0,63}\/(?:block|execute|activate|trigger|deactivate)\.ts$/.test(path);
+      const helperFile = /^app\/blocks\/[a-z][a-z0-9-]{0,63}\/[-a-zA-Z0-9._]+\.ts$/.test(path) &&
+        !/\/(?:block|execute|activate|trigger|deactivate)\./.test(path);
+      if (!validBlockFile && !helperFile) {
+        throw toolchainError(
+          "zhike_workflow_block_location_invalid",
+          `${path}: Block 必须位于 src/app/blocks/<block-key>/，固定入口只允许 .ts`,
+        );
+      }
+    }
     if (path.endsWith(".server.tsx")) {
       throw toolchainError(
         "zhike_server_function_extension_invalid",

package/src/toolchain/workflow-blocks/discovery.js

@@ -0,0 +1,133 @@
+import ts from "typescript";
+
+import { ZhikeCliError } from "../../errors.js";
+import { validateWorkflowStepDefinition } from "../workflow-steps/manifest.js";
+import { validateWorkflowTriggerDefinition } from "../workflow-triggers/manifest.js";
+
+const HANDLERS = Object.freeze({
+  step: Object.freeze({ execute: "defineWorkflowBlockExecute" }),
+  trigger: Object.freeze({
+    activate: "defineWorkflowBlockActivate",
+    trigger: "defineWorkflowBlockTrigger",
+    deactivate: "defineWorkflowBlockDeactivate",
+  }),
+});
+
+function invalid(path, detail) {
+  throw new ZhikeCliError("zhike_workflow_block_invalid", `${path}: ${detail}`);
+}
+
+function literal(node, path) {
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  if (ts.isNumericLiteral(node)) return Number(node.text);
+  if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+  if (ts.isArrayLiteralExpression(node)) return node.elements.map(item => literal(item, path));
+  if (ts.isObjectLiteralExpression(node)) {
+    const result = {};
+    for (const property of node.properties) {
+      if (!ts.isPropertyAssignment(property) ||
+        !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))) {
+        invalid(path, "声明只能包含静态 JSON 属性");
+      }
+      const key = property.name.text;
+      if (Object.hasOwn(result, key)) invalid(path, `重复字段 ${key}`);
+      result[key] = literal(property.initializer, `${path}.${key}`);
+    }
+    return result;
+  }
+  invalid(path, "声明必须是 JSON 字面量，不能读取变量或运行时代码");
+}
+
+function namedImports(sourceFile, moduleName = "@77-zhike/app-sdk/server") {
+  return new Set(sourceFile.statements.flatMap(statement =>
+    ts.isImportDeclaration(statement) && statement.moduleSpecifier.text === moduleName &&
+    statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings)
+      ? statement.importClause.namedBindings.elements
+        .filter(item => !item.propertyName).map(item => item.name.text)
+      : []));
+}
+
+function parseDefinition(sourceFile, relativePath) {
+  if (!namedImports(sourceFile).has("defineWorkflowBlock")) {
+    invalid(relativePath, "block.ts 必须直接导入 defineWorkflowBlock");
+  }
+  const exports = sourceFile.statements.filter(statement =>
+    ts.isExportAssignment(statement) && !statement.isExportEquals);
+  if (exports.length !== 1 || !ts.isCallExpression(exports[0].expression)) {
+    invalid(relativePath, "block.ts 必须直接默认导出唯一的 defineWorkflowBlock({...})");
+  }
+  const call = exports[0].expression;
+  if (!ts.isIdentifier(call.expression) || call.expression.text !== "defineWorkflowBlock" ||
+    call.arguments.length !== 1) {
+    invalid(relativePath, "block.ts 必须直接默认导出 defineWorkflowBlock({...})");
+  }
+  return literal(call.arguments[0], relativePath);
+}
+
+function defaultBlockImport(sourceFile, relativePath) {
+  const imports = sourceFile.statements.filter(statement =>
+    ts.isImportDeclaration(statement) && ["./block", "./block.js"].includes(statement.moduleSpecifier.text) &&
+    statement.importClause?.name);
+  if (imports.length !== 1) invalid(relativePath, "处理器必须从 ./block.js 默认导入当前 Block");
+  return imports[0].importClause.name.text;
+}
+
+function validateHandler(sourceFile, relativePath, api) {
+  if (!namedImports(sourceFile).has(api)) {
+    invalid(relativePath, `必须直接导入 ${api}`);
+  }
+  const blockName = defaultBlockImport(sourceFile, relativePath);
+  const exports = sourceFile.statements.filter(statement =>
+    ts.isExportAssignment(statement) && !statement.isExportEquals);
+  if (exports.length !== 1 || !ts.isCallExpression(exports[0].expression)) {
+    invalid(relativePath, `必须直接默认导出 ${api}(block, async (...) => ...)`);
+  }
+  const call = exports[0].expression;
+  if (!ts.isIdentifier(call.expression) || call.expression.text !== api || call.arguments.length !== 2 ||
+    !ts.isIdentifier(call.arguments[0]) || call.arguments[0].text !== blockName ||
+    !(ts.isArrowFunction(call.arguments[1]) || ts.isFunctionExpression(call.arguments[1])) ||
+    !call.arguments[1].modifiers?.some(item => item.kind === ts.SyntaxKind.AsyncKeyword)) {
+    invalid(relativePath, `必须直接默认导出 ${api}(block, async (...) => ...)`);
+  }
+}
+
+export function discoverWorkflowBlock(sourceFile, relativePath, directoryKey, sourceFilesByPath) {
+  const value = parseDefinition(sourceFile, relativePath);
+  if (!["step", "trigger"].includes(value.type)) {
+    invalid(relativePath, 'type 必须是 "step" 或 "trigger"');
+  }
+  const handlers = HANDLERS[value.type];
+  const handlerPaths = {};
+  for (const [name, api] of Object.entries(handlers)) {
+    const handlerPath = `app/blocks/${directoryKey}/${name}.ts`;
+    const handlerSource = sourceFilesByPath.get(handlerPath);
+    if (!handlerSource) invalid(relativePath, `${value.type} Block 缺少 ${name}.ts`);
+    validateHandler(handlerSource, handlerPath, api);
+    handlerPaths[name] = handlerPath;
+  }
+  const unexpected = value.type === "step"
+    ? ["activate", "trigger", "deactivate"].filter(name => sourceFilesByPath.has(`app/blocks/${directoryKey}/${name}.ts`))
+    : ["execute"].filter(name => sourceFilesByPath.has(`app/blocks/${directoryKey}/${name}.ts`));
+  if (unexpected.length > 0) invalid(relativePath, `${value.type} Block 不应包含 ${unexpected.join(", ")}.ts`);
+
+  const { type, ...definition } = value;
+  try {
+    if (type === "step") {
+      const step = validateWorkflowStepDefinition(definition, relativePath, directoryKey);
+      return Object.freeze({ ...step, type, handlerPaths: Object.freeze(handlerPaths) });
+    }
+    const trigger = validateWorkflowTriggerDefinition(definition, relativePath, directoryKey);
+    return Object.freeze({ ...trigger, type, handlerPaths: Object.freeze({
+      activate: handlerPaths.activate,
+      onEvent: handlerPaths.trigger,
+      deactivate: handlerPaths.deactivate,
+    }) });
+  } catch (error) {
+    if (error?.code === "zhike_workflow_step_invalid" || error?.code === "zhike_workflow_trigger_invalid") {
+      invalid(relativePath, error.message);
+    }
+    throw error;
+  }
+}

package/src/toolchain/workflow-steps/manifest.js

@@ -0,0 +1,99 @@
+import { ZhikeCliError } from "../../errors.js";
+
+const ID = /^[a-z][a-z0-9_-]{0,63}$/;
+const FIELD = /^[a-z][a-zA-Z0-9_]{0,63}$/;
+const DISPLAY = new Set(["title", "description", "examples"]);
+
+function invalid(path, detail) {
+  throw new ZhikeCliError("zhike_workflow_step_invalid", `${path}: ${detail}`);
+}
+
+function object(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid(path, "必须是对象");
+  return value;
+}
+
+function exactKeys(value, allowed, path) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) invalid(path, `不支持字段 ${key}`);
+  }
+}
+
+function display(value, path) {
+  for (const key of ["title", "description"]) {
+    if (value[key] !== undefined && (typeof value[key] !== "string" || value[key].length > 300)) {
+      invalid(path, `${key} 无效`);
+    }
+  }
+  if (value.examples !== undefined && (
+    !Array.isArray(value.examples) || value.examples.length > 3 ||
+    value.examples.some(item => !["string", "number", "boolean"].includes(typeof item))
+  )) invalid(path, "examples 无效");
+}
+
+function schema(value, path) {
+  object(value, path);
+  exactKeys(value, new Set(["type", "properties", "required", "additionalProperties", ...DISPLAY]), path);
+  if (value.type !== "object" || value.additionalProperties !== false) invalid(path, "只支持封闭 object schema");
+  object(value.properties, `${path}.properties`);
+  const fields = Object.entries(value.properties);
+  if (fields.length > 32) invalid(path, "字段超过 32 个");
+  const required = value.required ?? [];
+  if (!Array.isArray(required) || new Set(required).size !== required.length ||
+    required.some(key => typeof key !== "string" || !Object.hasOwn(value.properties, key))) {
+    invalid(path, "required 必须引用唯一的已声明字段");
+  }
+  for (const [key, field] of fields) {
+    if (!FIELD.test(key)) invalid(path, `字段名 ${key} 无效`);
+    object(field, `${path}.${key}`);
+    const fieldPath = `${path}.properties.${key}`;
+    const allowed = field.type === "string"
+      ? new Set(["type", "minLength", "enum", ...DISPLAY])
+      : new Set(["type", ...DISPLAY]);
+    exactKeys(field, allowed, fieldPath);
+    if (!["string", "number", "boolean"].includes(field.type)) invalid(fieldPath, "只支持 string/number/boolean");
+    if (field.minLength !== undefined && (!Number.isInteger(field.minLength) || field.minLength < 0 || field.minLength > 1024)) {
+      invalid(fieldPath, "minLength 无效");
+    }
+    if (field.enum !== undefined && (
+      !Array.isArray(field.enum) || field.enum.length < 1 || field.enum.length > 32 ||
+      field.enum.some(item => typeof item !== "string" || item.length > 300) ||
+      new Set(field.enum).size !== field.enum.length
+    )) invalid(fieldPath, "enum 无效");
+    display(field, fieldPath);
+  }
+  display(value, path);
+  if (Buffer.byteLength(JSON.stringify(value), "utf8") > 16 * 1024) invalid(path, "schema 超过 16 KiB");
+  return value;
+}
+
+export function validateWorkflowStepDefinition(value, relativePath, fileKey) {
+  object(value, relativePath);
+  exactKeys(value, new Set(["key", "title", "description", "connection", "configSchema", "outcomes"]), relativePath);
+  if (!ID.test(value.key) || value.key !== fileKey) invalid(relativePath, "Step key 必须与文件名一致");
+  if (typeof value.title !== "string" || value.title.length < 1 || value.title.length > 80) invalid(relativePath, "title 无效");
+  if (value.description !== undefined && (typeof value.description !== "string" || value.description.length > 300)) invalid(relativePath, "description 无效");
+  if (!["workspace", "none"].includes(value.connection)) invalid(relativePath, "connection 无效");
+  schema(value.configSchema, `${relativePath}.configSchema`);
+  if (!Array.isArray(value.outcomes) || value.outcomes.length < 1 || value.outcomes.length > 8) {
+    invalid(relativePath, "outcomes 必须包含 1–8 个静态出口");
+  }
+  const ids = new Set();
+  for (const [index, outcome] of value.outcomes.entries()) {
+    const path = `${relativePath}.outcomes[${index}]`;
+    object(outcome, path);
+    exactKeys(outcome, new Set(["id", "label", "dataSchema"]), path);
+    if (!ID.test(outcome.id) || ["in", "error"].includes(outcome.id) || ids.has(outcome.id)) {
+      invalid(path, "出口 ID 重复、保留或不合法");
+    }
+    ids.add(outcome.id);
+    if (typeof outcome.label !== "string" || outcome.label.length < 1 || outcome.label.length > 80) invalid(path, "label 无效");
+    if (outcome.dataSchema !== null) schema(outcome.dataSchema, `${path}.dataSchema`);
+  }
+  return Object.freeze({
+    ...value,
+    artifact: "server",
+    entry: `steps/${value.key}`,
+    relativePath,
+  });
+}

package/src/toolchain/workflow-triggers/manifest.js

@@ -0,0 +1,47 @@
+import { ZhikeCliError } from "../../errors.js";
+import { validateWorkflowStepDefinition } from "../workflow-steps/manifest.js";
+
+const HEADER = /^[a-z][a-z0-9-]{0,63}$/;
+const BLOCKED_HEADERS = new Set(["authorization", "cookie", "set-cookie", "host", "content-length"]);
+
+function invalid(path, detail) {
+  throw new ZhikeCliError("zhike_workflow_trigger_invalid", `${path}: ${detail}`);
+}
+
+export function validateWorkflowTriggerDefinition(value, relativePath, fileKey) {
+  if (!value || typeof value !== "object" || Array.isArray(value) ||
+    Object.keys(value).some(key => !["key", "title", "description", "connection", "requestHeaders", "configSchema", "outcomes"].includes(key))) {
+    invalid(relativePath, "Trigger 声明字段无效");
+  }
+  let common;
+  try {
+    const { requestHeaders, ...stepShape } = value;
+    common = validateWorkflowStepDefinition(stepShape, relativePath, fileKey);
+  } catch (error) {
+    invalid(relativePath, error.message || "schema 无效");
+  }
+  if (value.outcomes.some(outcome => outcome.dataSchema === null)) {
+    invalid(relativePath, "Trigger 的每个出口必须声明数据 schema");
+  }
+  const requestHeaders = value.requestHeaders ?? [];
+  if (!Array.isArray(requestHeaders) || requestHeaders.length > 16 ||
+    requestHeaders.some(name => typeof name !== "string" || !HEADER.test(name) ||
+      BLOCKED_HEADERS.has(name) || name.startsWith("x-forwarded-") || name.startsWith("proxy-")) ||
+    new Set(requestHeaders).size !== requestHeaders.length) {
+    invalid(relativePath, "requestHeaders 必须是至多 16 个唯一的安全小写名称");
+  }
+  return Object.freeze({
+    key: common.key, title: common.title,
+    ...(common.description === undefined ? {} : { description: common.description }),
+    connection: common.connection,
+    configSchema: common.configSchema,
+    outcomes: common.outcomes,
+    requestHeaders: Object.freeze([...requestHeaders]),
+    entries: Object.freeze({
+      activate: `triggers/${common.key}/activate`,
+      onEvent: `triggers/${common.key}/onEvent`,
+      deactivate: `triggers/${common.key}/deactivate`,
+    }),
+    relativePath,
+  });
+}

package/src/ui/components.generated.js

@@ -1,4 +1,5 @@
 // 此文件由 scripts/generate-components.mjs 生成，请修改产品能力声明。
-export const componentTypes = Object.freeze(["Icon","Stack","SplitLayout","SplitLayoutMain","SplitLayoutAside","SplitLayoutActions","Section","Banner","Badge","LoadingState","Card","Grid","EmptyState","Link","Button","Switch","LookupCell","Tabs","TabsList","TabsTrigger","TabsContent","Table","TableHeader","TableBody","TableRow","TableCell","Avatar","DescriptionList","DescriptionListItem","DescriptionListMenu","DescriptionListMenuItem","Divider","Json","ExternalLink","StatusBadge","TextBlock","TypographyTitle","TypographyBody","TypographyCaption","TableHeaderCell","WidgetTextWidget","WidgetTitle","WidgetTextPrimary","WidgetTextSecondary","WidgetLoading","WidgetDecoration"]);
-export const legacyComponentTypes = Object.freeze(["Text","Icon","Stack","SplitLayout","SplitLayoutMain","SplitLayoutAside","SplitLayoutActions","Section","Banner","Badge","LoadingState","Card","Grid","EmptyState","Link","Button","Switch","LookupCell","Tabs","TabsList","TabsTrigger","TabsContent","Table","TableHeader","TableBody","TableRow","TableCell","Avatar","DescriptionList","DescriptionListItem","DescriptionListMenu","DescriptionListMenuItem","Divider","Json","ExternalLink","StatusBadge","TextBlock","TypographyTitle","TypographyBody","TypographyCaption","TableHeaderCell","WidgetTextWidget","WidgetTitle","WidgetTextPrimary","WidgetTextSecondary","WidgetLoading","WidgetDecoration"]);
+export const componentTypes = Object.freeze(["Icon","Stack","SplitLayout","SplitLayoutMain","SplitLayoutAside","SplitLayoutActions","Section","Banner","Badge","LoadingState","Card","Grid","EmptyState","ZhikeLink","Button","Switch","LookupCell","Tabs","TabsList","TabsTrigger","TabsContent","Table","TableHeader","TableBody","TableRow","TableCell","Avatar","DescriptionList","DescriptionListItem","DescriptionListMenu","DescriptionListMenuItem","Divider","Json","Link","StatusBadge","TextBlock","TypographyTitle","TypographyBody","TypographyCaption","TableHeaderCell","WidgetTextWidget","WidgetTitle","WidgetTextPrimary","WidgetTextSecondary","WidgetLoading","WidgetDecoration"]);
+export const publicComponentNames = Object.freeze(["Icon","Stack","SplitLayout","SplitLayoutMain","SplitLayoutAside","SplitLayoutActions","Section","Banner","Badge","LoadingState","Card","Grid","EmptyState","ZhikeLink","Button","Switch","LookupCell","Tabs","TabsList","TabsTrigger","TabsContent","Table","TableHeader","TableBody","TableRow","TableCell","Avatar","DescriptionList","DescriptionListItem","DescriptionListMenu","DescriptionListMenuItem","Divider","Json","Link","StatusBadge","TextBlock","TypographyTitle","TypographyBody","TypographyCaption","TableHeaderCell","WidgetTextWidget","WidgetTitle","WidgetTextPrimary","WidgetTextSecondary","WidgetLoading","WidgetDecoration"]);
+export const legacyComponentTypes = Object.freeze(["Text","Icon","Stack","SplitLayout","SplitLayoutMain","SplitLayoutAside","SplitLayoutActions","Section","Banner","Badge","LoadingState","Card","Grid","EmptyState","ZhikeLink","Button","Switch","LookupCell","Tabs","TabsList","TabsTrigger","TabsContent","Table","TableHeader","TableBody","TableRow","TableCell","Avatar","DescriptionList","DescriptionListItem","DescriptionListMenu","DescriptionListMenuItem","Divider","Json","Link","StatusBadge","TextBlock","TypographyTitle","TypographyBody","TypographyCaption","TableHeaderCell","WidgetTextWidget","WidgetTitle","WidgetTextPrimary","WidgetTextSecondary","WidgetLoading","WidgetDecoration"]);
 export const badgeColors = Object.freeze(["amber","blue","cyan","green","grey","lavender","lime","orange","pink","purple","red","yellow"]);

package/src/ui/factory.js

@@ -30,7 +30,7 @@ export function createUiComponents(React, { legacy = false, useOwner = () => nul
         return handlers[index]();
       } });
     }
-    if (type === 'ExternalLink') {
+    if (type === 'Link') {
       const owner = useOwner();
       const { href: input, onOpen, ...rest } = props;
       if (onOpen !== undefined) throw new Error('runtime_ui_contract_invalid');