linkque-cli-v2 1.1.4-beta.1 → 1.1.5

package/linkquejs.js

@@ -27426,9 +27426,6 @@ function createA2UICardDraftStructureChecksum(draft) {
   delete cloned.manifest.bindings;
   return sha256Hex(stableJsonStringify(cloned));
 }
-function createA2UICardMcpConfigChecksum(resources) {
-  return sha256Hex(stableJsonStringify(resources));
-}
 function createA2UICardRevision(draftChecksum2, bindings) {
   const digest = sha256Hex(`${draftChecksum2}
 ${stableJsonStringify(bindings)}`);
@@ -27507,6 +27504,393 @@ var SHA256_CONSTANTS = [
   3329325298
 ];
 
+// ../agent-a2ui-card-contract/dist/esm/authoring-model.js
+var INTERNAL_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "id",
+  "component",
+  "surfaceId",
+  "version",
+  "child",
+  "children"
+]);
+var MERCHANT_CONTENT_KEYS = /* @__PURE__ */ new Set([
+  "caption",
+  "description",
+  "label",
+  "placeholder",
+  "subtitle",
+  "text",
+  "title"
+]);
+var DEFAULT_AUTHORING_PROJECTION = {
+  directTargets: "content"
+};
+var COMPONENT_AUTHORING_PROJECTIONS = {
+  Image: {
+    directTargets: "image-source",
+    fieldProperties: ["src"],
+    groupLabel: "\u56FE\u7247"
+  }
+};
+function extractA2UICardAuthoringModel(bundle, options = {}) {
+  const analysis = analyzeA2UIBindings(bundle.card);
+  const bindingByField = new Map((bundle.manifest.bindings ?? []).map((binding) => [
+    binding.fieldId,
+    binding
+  ]));
+  const fields = bundle.manifest.fields.filter((field) => field.source === "business");
+  const registered = options.registeredComponents ? new Set(options.registeredComponents) : void 0;
+  const occurrencesByComponent = groupBindingOccurrences(analysis.occurrences);
+  const allFieldOccurrenceTargets = [];
+  const groups = [];
+  let order = 0;
+  for (const { surfaceId, component } of orderedComponents(bundle)) {
+    const occurrenceId = createA2UICardAuthoringOccurrenceId(surfaceId, component.id);
+    const targets = [];
+    if (!registered || registered.has(component.component)) {
+      const projection = componentAuthoringProjection(component);
+      const componentOccurrences = occurrencesByComponent.get(componentKey(surfaceId, component.id)) ?? [];
+      discoverComponentTargets(component, occurrenceId, projection, targets);
+      allFieldOccurrenceTargets.push(...fieldTargets(component, occurrenceId, fields, componentOccurrences, false));
+      targets.push(...fieldTargets(component, occurrenceId, fields, componentOccurrences, true));
+      targets.push(...actionTargets(component, occurrenceId));
+    }
+    if (targets.length === 0) {
+      targets.push({
+        kind: "agent-only",
+        targetId: createA2UICardAuthoringTargetId(occurrenceId, "agent-only"),
+        occurrenceId,
+        label: "\u901A\u8FC7 Coding Agent \u4FEE\u6539",
+        reason: registered && !registered.has(component.component) ? "\u7EC4\u4EF6\u672A\u5728\u5F53\u524D Catalog \u6CE8\u518C" : "\u6CA1\u6709\u53EF\u5B89\u5168\u76F4\u63A5\u7F16\u8F91\u7684\u4E1A\u52A1\u5B57\u6BB5"
+      });
+    }
+    groups.push({
+      occurrenceId,
+      surfaceId,
+      componentId: component.id,
+      componentName: component.component,
+      order: order++,
+      label: componentAuthoringProjection(component).groupLabel ?? componentLabel(component),
+      targets: deduplicateTargets(targets),
+      agentOnly: targets.every((target) => target.kind === "agent-only")
+    });
+  }
+  const fieldStates = fields.map((field) => {
+    const occurrences = allFieldOccurrenceTargets.filter((target) => target.fieldId === field.fieldId);
+    const binding = bindingByField.get(field.fieldId);
+    return {
+      field,
+      ...binding ? { binding: cloneBinding(binding) } : {},
+      occurrences,
+      usageCount: new Set(occurrences.map((target) => `${target.occurrenceId}\0${target.propertyPath}`)).size,
+      status: occurrences.length === 0 ? "unused" : binding ? "bound" : field.required ? "unbound-required" : "unbound-optional"
+    };
+  });
+  const diagnostics = getA2UICardAuthoringDiagnostics(bundle, {
+    groups,
+    fields: fieldStates
+  });
+  return {
+    draftId: bundle.manifest.draftId,
+    resourceId: bundle.manifest.resourceId,
+    groups,
+    fields: fieldStates,
+    diagnostics
+  };
+}
+function componentAuthoringProjection(component) {
+  return COMPONENT_AUTHORING_PROJECTIONS[component.component] ?? DEFAULT_AUTHORING_PROJECTION;
+}
+function discoverComponentTargets(component, occurrenceId, projection, targets) {
+  if (projection.directTargets === "content") {
+    discoverTargets(component, occurrenceId, "", targets);
+    return;
+  }
+  if (typeof component.src !== "string")
+    return;
+  targets.push({
+    kind: "image",
+    targetId: createA2UICardAuthoringTargetId(occurrenceId, "src"),
+    occurrenceId,
+    propertyPath: "src",
+    label: "\u56FE\u7247\u5730\u5740",
+    value: component.src,
+    role: "src"
+  });
+}
+function getA2UICardAuthoringDiagnostics(bundle, partial) {
+  const diagnostics = getA2UICardDraftBundleIssues(bundle).map((entry) => ({
+    ...entry,
+    severity: "hard-error"
+  }));
+  const model = partial ?? extractA2UICardAuthoringModel(bundle);
+  for (const field of model.fields) {
+    if (field.status === "unbound-required") {
+      diagnostics.push({
+        code: "REQUIRED_BINDING_MISSING",
+        path: `manifest.fields.${field.field.fieldId}`,
+        message: `\u5FC5\u586B\u5B57\u6BB5\u201C${field.field.label}\u201D\u5C1A\u672A\u7ED1\u5B9A`,
+        severity: "hard-error",
+        fieldId: field.field.fieldId
+      });
+    }
+  }
+  for (const group of model.groups) {
+    const component = findComponent(bundle, group.surfaceId, group.componentId);
+    const action = isPlainRecord(component?.action) ? component.action : void 0;
+    const client = action && isPlainRecord(action.client) ? action.client : void 0;
+    if (client?.name === "ui.page.open") {
+      const context = isPlainRecord(client.context) ? client.context : void 0;
+      if (typeof context?.url === "string" && !isSafePageUrl(context.url)) {
+        diagnostics.push({
+          code: "UNSAFE_PAGE_URL",
+          path: `${group.occurrenceId}.action.client.context.url`,
+          message: "\u9875\u9762\u5730\u5740\u5FC5\u987B\u662F\u5B89\u5168\u7684 http(s) \u5730\u5740\u6216\u7AD9\u5185\u7EDD\u5BF9\u8DEF\u5F84",
+          severity: "hard-error",
+          occurrenceId: group.occurrenceId
+        });
+      }
+    } else if (client && typeof client.name === "string" && !["ui.overlay.close", "ui.surface.open"].includes(client.name)) {
+      diagnostics.push({
+        code: "UNREGISTERED_CLIENT_ACTION",
+        path: `${group.occurrenceId}.action.client.name`,
+        message: `\u672A\u6CE8\u518C\u7684 Client Action\uFF1A${client.name}`,
+        severity: "hard-error",
+        occurrenceId: group.occurrenceId
+      });
+    }
+  }
+  return deduplicateDiagnostics(diagnostics);
+}
+function validateA2UICardForPublish(bundle) {
+  return getA2UICardAuthoringDiagnostics(bundle).filter((diagnostic) => diagnostic.severity === "hard-error");
+}
+function createA2UICardAuthoringOccurrenceId(surfaceId, componentId) {
+  return `${encodeURIComponent(surfaceId)}:${encodeURIComponent(componentId)}`;
+}
+function createA2UICardAuthoringTargetId(occurrenceId, propertyPath) {
+  return `${occurrenceId}:${encodeURIComponent(propertyPath)}`;
+}
+function isSafePageUrl(url) {
+  const trimmed = url.trim();
+  if (trimmed.length === 0 || trimmed.length > 2e3)
+    return false;
+  const token = /\{\{([^{}]+)\}\}/gu;
+  let tokenCount = 0;
+  for (const match of trimmed.matchAll(token)) {
+    tokenCount++;
+    if (tokenCount > 32)
+      return false;
+    const path22 = match[1]?.trim() ?? "";
+    if (!(path22 === "/" || path22.startsWith("/") || path22.startsWith("./")) || path22.split("/").some((part) => ["..", "__proto__", "constructor", "prototype"].includes(part))) {
+      return false;
+    }
+  }
+  const candidate = trimmed.replace(token, "value");
+  if (candidate.includes("{{") || candidate.includes("}}"))
+    return false;
+  try {
+    return ["https:", "alipays:"].includes(new URL(candidate).protocol);
+  } catch {
+    return false;
+  }
+}
+function orderedComponents(bundle) {
+  const result = [];
+  for (const message of bundle.card) {
+    for (const instruction of message.datas) {
+      if (!("updateComponents" in instruction))
+        continue;
+      for (const component of instruction.updateComponents.components) {
+        result.push({
+          surfaceId: instruction.updateComponents.surfaceId,
+          component
+        });
+      }
+    }
+  }
+  return result;
+}
+function discoverTargets(value, occurrenceId, propertyPath, targets) {
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => discoverTargets(entry, occurrenceId, appendPath(propertyPath, String(index)), targets));
+    return;
+  }
+  if (!isPlainRecord(value))
+    return;
+  if (typeof value.path === "string")
+    return;
+  for (const [key, entry] of Object.entries(value)) {
+    const nextPath = appendPath(propertyPath, key);
+    if (INTERNAL_KEYS.has(key) || key === "action")
+      continue;
+    if (Array.isArray(entry) || isPlainRecord(entry)) {
+      discoverTargets(entry, occurrenceId, nextPath, targets);
+      continue;
+    }
+    if (!isJsonValue(entry))
+      continue;
+    if (typeof entry !== "string" || !MERCHANT_CONTENT_KEYS.has(key))
+      continue;
+    targets.push({
+      kind: "literal",
+      targetId: createA2UICardAuthoringTargetId(occurrenceId, nextPath),
+      occurrenceId,
+      propertyPath: nextPath,
+      label: propertyLabel(nextPath),
+      value: entry
+    });
+  }
+}
+function actionTargets(component, occurrenceId) {
+  if (!isPlainRecord(component.action))
+    return [];
+  const action = component.action;
+  const event = isPlainRecord(action.event) ? action.event : void 0;
+  if (event) {
+    const message = event["x2-user-message"];
+    if (typeof message === "string" && typeof event.name === "string") {
+      return [
+        {
+          kind: "agent-event",
+          targetId: createA2UICardAuthoringTargetId(occurrenceId, "action"),
+          occurrenceId,
+          propertyPath: "action",
+          label: "\u70B9\u51FB\u540E",
+          message,
+          eventName: event.name,
+          hasContext: isPlainRecord(event.context)
+        }
+      ];
+    }
+    return [agentOnlyAction(occurrenceId, "\u52A8\u6001\u6216\u590D\u6742\u4E8B\u4EF6\u901A\u8FC7\u667A\u80FD\u4F53\u4FEE\u6539")];
+  }
+  const client = isPlainRecord(action.client) ? action.client : void 0;
+  if (client?.name === "ui.page.open") {
+    const context = isPlainRecord(client.context) ? client.context : void 0;
+    const url = context?.url;
+    return [
+      {
+        kind: "page-open",
+        targetId: createA2UICardAuthoringTargetId(occurrenceId, "action"),
+        occurrenceId,
+        propertyPath: "action",
+        label: "\u6253\u5F00\u9875\u9762",
+        ...typeof url === "string" ? { url } : {},
+        dynamic: isPlainRecord(url) && typeof url.path === "string"
+      }
+    ];
+  }
+  return [agentOnlyAction(occurrenceId, "\u8BE5\u884C\u4E3A\u53EA\u80FD\u901A\u8FC7 Coding Agent \u4FEE\u6539")];
+}
+function fieldTargets(component, occurrenceId, fields, occurrences, projectedOnly) {
+  const projection = componentAuthoringProjection(component);
+  const ordered = [...fields].sort((left, right) => right.path.length - left.path.length);
+  return occurrences.flatMap((occurrence) => {
+    if (projectedOnly && !isProjectedFieldOccurrence(occurrence.propertyPath, projection)) {
+      return [];
+    }
+    const field = ordered.find((candidate) => occurrence.canonicalPath === candidate.path || occurrence.canonicalPath.startsWith(`${candidate.path}/*/`) || occurrence.canonicalPath.startsWith(`${candidate.path}/`));
+    if (!field)
+      return [];
+    const suffix = occurrence.canonicalPath.slice(field.path.length).replace(/^\/\*/u, "");
+    const targetPath = suffix ? suffix.startsWith("/") ? suffix : `/${suffix}` : void 0;
+    return [
+      {
+        kind: "field-occurrence",
+        targetId: createA2UICardAuthoringTargetId(occurrenceId, occurrence.propertyPath),
+        occurrenceId,
+        propertyPath: occurrence.propertyPath,
+        label: fieldOccurrenceLabel(targetPath, occurrence.propertyPath),
+        fieldId: field.fieldId,
+        ...targetPath ? { targetPath } : {}
+      }
+    ];
+  });
+}
+function isProjectedFieldOccurrence(propertyPath, projection) {
+  if (propertyPath === "action" || propertyPath.startsWith("action.")) {
+    return false;
+  }
+  return projection.fieldProperties === void 0 || projection.fieldProperties.includes(propertyPath);
+}
+function fieldOccurrenceLabel(targetPath, propertyPath) {
+  if (!targetPath)
+    return propertyLabel(propertyPath);
+  const segment = targetPath.split("/").filter(Boolean).at(-1);
+  return segment ? decodeJsonPointerSegment(segment) : propertyLabel(propertyPath);
+}
+function decodeJsonPointerSegment(segment) {
+  return segment.replace(/~1/gu, "/").replace(/~0/gu, "~");
+}
+function groupBindingOccurrences(occurrences) {
+  const result = /* @__PURE__ */ new Map();
+  for (const occurrence of occurrences) {
+    if (!occurrence.surfaceId)
+      continue;
+    const key = componentKey(occurrence.surfaceId, occurrence.componentId);
+    const entries = result.get(key) ?? [];
+    entries.push(occurrence);
+    result.set(key, entries);
+  }
+  return result;
+}
+function findComponent(bundle, surfaceId, componentId) {
+  return orderedComponents(bundle).find((entry) => entry.surfaceId === surfaceId && entry.component.id === componentId)?.component;
+}
+function agentOnlyAction(occurrenceId, reason) {
+  return {
+    kind: "agent-only",
+    targetId: createA2UICardAuthoringTargetId(occurrenceId, "action"),
+    occurrenceId,
+    propertyPath: "action",
+    label: "\u901A\u8FC7 Coding Agent \u4FEE\u6539\u884C\u4E3A",
+    reason
+  };
+}
+function componentLabel(component) {
+  const candidate = component.label ?? component.title ?? component.text;
+  return typeof candidate === "string" && candidate.trim() ? candidate : component.component;
+}
+function propertyLabel(propertyPath) {
+  const key = propertyPath.split(".").at(-1) ?? propertyPath;
+  const labels = {
+    text: "\u6587\u6848",
+    title: "\u6807\u9898",
+    subtitle: "\u526F\u6807\u9898",
+    label: "\u6807\u7B7E",
+    description: "\u8BF4\u660E",
+    value: "\u5185\u5BB9",
+    alt: "\u56FE\u7247\u8BF4\u660E"
+  };
+  return labels[key] ?? key;
+}
+function appendPath(base, segment) {
+  return base ? `${base}.${segment}` : segment;
+}
+function componentKey(surfaceId, componentId) {
+  return `${surfaceId}\0${componentId}`;
+}
+function deduplicateTargets(targets) {
+  return [
+    ...new Map(targets.map((target) => [target.targetId, target])).values()
+  ];
+}
+function deduplicateDiagnostics(diagnostics) {
+  return [
+    ...new Map(diagnostics.map((entry) => [
+      `${entry.code}\0${entry.path}\0${entry.fieldId ?? ""}`,
+      entry
+    ])).values()
+  ];
+}
+function cloneBinding(binding) {
+  return JSON.parse(JSON.stringify(binding));
+}
+
 // src/commands/card/index.ts
 var DRAFT_ROOT = ".card-drafts";
 var AGENT_CONFIG_PATH = "agent_config.json";
@@ -27636,36 +28020,20 @@ async function validateCardBindingsFromDisk(cwd, draftId, fieldId) {
   const directory = draftDirectory(cwd, draftId);
   const [bundle, contextValue, configValue] = await Promise.all([
     readBundle(directory, draftId),
-    readRequiredJson(import_path22.default.join(directory, "binding-context.json")),
+    readOptionalJson(import_path22.default.join(directory, "binding-context.json")),
     readRequiredJson(import_path22.default.join(cwd, AGENT_CONFIG_PATH))
   ]);
-  const contextResult = parseA2UICardBindingContext(contextValue);
-  if (!contextResult.success) {
-    throw new LinkqueCliError(
-      "CARD_BINDING_CONTEXT_INVALID",
-      contextResult.issues.map((entry) => entry.message).join("; ")
-    );
-  }
-  const context = contextResult.data;
+  const context = parseOptionalBindingContext(contextValue);
   const draftStructureChecksum = createA2UICardDraftStructureChecksum(bundle);
   const config2 = parseAgentConfig(configValue);
   const mcpResources = normalizedMcpResources(config2);
-  if (context.mcpConfigChecksum !== createA2UICardMcpConfigChecksum(mcpResources)) {
-    throw new LinkqueCliError(
-      "CARD_BINDING_CONTEXT_STALE",
-      "MCP \u914D\u7F6E\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77 AI \u8F85\u52A9\u7ED1\u5B9A"
-    );
-  }
-  const issues = validateA2UICardBindings(
-    {
-      draft: bundle,
-      context,
-      mountedMcpResourceIds: new Set(
-        mcpResources.map((resource) => String(resource.resourceId))
-      )
-    },
-    fieldId ? { fieldIds: /* @__PURE__ */ new Set([fieldId]) } : void 0
+  const mountedMcpResourceIds = new Set(
+    mcpResources.map((resource) => String(resource.resourceId))
   );
+  const issues = context ? validateA2UICardBindings(
+    { draft: bundle, context, mountedMcpResourceIds },
+    fieldId ? { fieldIds: /* @__PURE__ */ new Set([fieldId]) } : void 0
+  ) : validateBindingsWithoutContext(bundle, mountedMcpResourceIds, fieldId);
   if (issues.length > 0) {
     throw new LinkqueCliError(
       "CARD_BINDING_VALIDATION_FAILED",
@@ -27696,15 +28064,9 @@ async function finalizeCardWhileLocked(cwd, draftId, expectedDraftChecksum) {
   }
   const directory = draftDirectory(cwd, draftId);
   const bundle = await readBundle(directory, draftId);
-  const contextResult = parseA2UICardBindingContext(
-    await readRequiredJson(import_path22.default.join(directory, "binding-context.json"))
+  const context = parseOptionalBindingContext(
+    await readOptionalJson(import_path22.default.join(directory, "binding-context.json"))
   );
-  if (!contextResult.success) {
-    throw new LinkqueCliError(
-      "CARD_BINDING_CONTEXT_INVALID",
-      contextResult.issues.map((entry) => entry.message).join("; ")
-    );
-  }
   const configPath = import_path22.default.join(cwd, AGENT_CONFIG_PATH);
   const oldConfigBytes = await (0, import_promises16.readFile)(configPath);
   const config2 = parseAgentConfig(
@@ -27738,7 +28100,7 @@ async function finalizeCardWhileLocked(cwd, draftId, expectedDraftChecksum) {
     // V3，让 Agent 直接按真实 MCP inputSchema 决定参数；不再把 presentation input
     // 或 inputBindings 固化进 CARD。
     ...bindings.length > 0 ? { targetSchemaVersion: "3" } : {},
-    tools: contextResult.data.candidates.flatMap(
+    tools: (context?.candidates ?? []).flatMap(
       (candidate) => candidate.status === "ready" ? [candidate.tool] : []
     )
   });
@@ -28065,6 +28427,47 @@ function normalizedMcpResources(config2) {
     (left, right) => stableJsonStringify(left).localeCompare(stableJsonStringify(right))
   );
 }
+function parseOptionalBindingContext(value) {
+  if (value === void 0) return void 0;
+  const result = parseA2UICardBindingContext(value);
+  if (!result.success) {
+    throw new LinkqueCliError(
+      "CARD_BINDING_CONTEXT_INVALID",
+      result.issues.map((entry) => entry.message).join("; ")
+    );
+  }
+  return result.data;
+}
+function validateBindingsWithoutContext(bundle, mountedMcpResourceIds, fieldId) {
+  const selectedFields = fieldId ? /* @__PURE__ */ new Set([fieldId]) : void 0;
+  const bindings = (bundle.manifest.bindings ?? []).filter(
+    (binding) => !selectedFields || selectedFields.has(binding.fieldId)
+  );
+  const issues = getA2UICardBindingSelectionIssues(
+    bindings,
+    "draft.manifest.bindings",
+    bundle.manifest.fields
+  );
+  for (const binding of bindings) {
+    if (!mountedMcpResourceIds.has(binding.mcpResourceId)) {
+      issues.push({
+        code: "MCP_TOOL_UNAVAILABLE",
+        message: `MCP resource ${binding.mcpResourceId} is not mounted`,
+        path: `draft.manifest.bindings.${binding.fieldId}`
+      });
+    }
+  }
+  if (!selectedFields) {
+    issues.push(
+      ...validateA2UICardForPublish(bundle).map((diagnostic) => ({
+        code: diagnostic.code,
+        message: diagnostic.message,
+        path: diagnostic.path
+      }))
+    );
+  }
+  return issues;
+}
 function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkque-cli-v2",
-  "version": "1.1.4-beta.1",
+  "version": "1.1.5",
   "description": "Public Linkque CLI bundle for sandbox debugging",
   "bin": {
     "linkquejs": "linkquejs.js"