@salesforce/afv-skills 1.34.0 → 1.36.0

package/skills/experience-ui-bundle-localize/scripts/check-i18n-wired.sh

@@ -0,0 +1,195 @@
+#!/usr/bin/env bash
+set -euo pipefail  # exit on error (-e), undefined vars (-u), and propagate pipeline failures (-o pipefail)
+#
+# check-i18n-wired.sh — Confirm the i18n init exists and is called at boot.
+#
+# Whether the app already has i18n wiring is a file-existence plus call-site
+# check, so run this rather than reading for it by hand. It looks for an init
+# file that defines initI18n() and for a boot-time initI18n() call in an entry
+# file.
+#
+# Usage (run from the UI bundle dir, or pass its src path):
+#   bash <skill-dir>/scripts/check-i18n-wired.sh [src-dir]
+#
+# src-dir defaults to "src".
+#
+# When wiring exists, it also reports whether the label manifest is imported AND
+# actually passed into the SalesforceBackend's backendOptions (not merely
+# imported and left unused), so the reconcile decision is a script result rather
+# than a by-hand read.
+#
+# Exit codes (each actionable state has its own code so the workflow branches on
+# the code, not on the message text):
+#   0  fully wired — initI18n() defined, called at boot, AND the manifest is
+#      passed into the SalesforceBackend's backendOptions. Just add new keys.
+#   1  no i18n init found — no initI18n() definition. Scaffold the whole setup
+#      (see references/i18n-setup.md).
+#   2  init defined but not called at boot — add only the boot-time initI18n()
+#      call in the entry file; do NOT re-scaffold or overwrite the init.
+#   3  wired at boot but the manifest could not be confirmed as passed into the
+#      backend (not imported, no backendOptions/SalesforceBackend config, or
+#      imported but not seen inside a backendOptions array). This is a textual
+#      heuristic: the manifest may be wired via a variable/spread this check
+#      cannot see. VERIFY by hand; reconcile only if it genuinely dangles, and
+#      never clobber the existing init.
+#  64  usage error — the source dir does not exist (bad argument or wrong cwd).
+#      This is NOT a "no init found" result; do not scaffold. Fix the path and
+#      re-run. (64 = EX_USAGE, kept out of the 0-3 semantic range so exit 1
+#      uniquely means "no init found".)
+# The message still names the specific file/symbol/gap for the report, but the
+# decision is the exit code.
+
+SRC_DIR="${1:-src}"
+if [ ! -d "$SRC_DIR" ]; then
+  echo "ERROR: source dir not found: $SRC_DIR (run from the UI bundle dir, or pass its src path)" >&2
+  exit 64
+fi
+
+# An init file that DEFINES initI18n (function/const declaration, not just a call).
+# Use POSIX character classes, not \s / \b: BSD/macOS grep -E does not honor those.
+# A trailing [^A-Za-z0-9_] (or end of line) stands in for the word boundary so
+# initI18nFoo does not match.
+DEFINES=$(grep -rlE '(function|const)[[:space:]]+initI18n([^A-Za-z0-9_]|$)|initI18n[[:space:]]*=' "$SRC_DIR" \
+            --include='*.ts' --include='*.tsx' 2>/dev/null | head -1 || true)
+
+# A boot-time call to initI18n() somewhere other than its own definition file.
+CALLS=$(grep -rlE '(^|[^A-Za-z0-9_])initI18n[[:space:]]*\(' "$SRC_DIR" \
+          --include='*.ts' --include='*.tsx' 2>/dev/null \
+        | grep -vF "${DEFINES:-/dev/null}" | head -1 || true)
+
+if [ -n "$DEFINES" ] && [ -n "$CALLS" ]; then
+  # Wiring exists. Determine whether the manifest is already reconciled into the
+  # backend. Importing the manifest is not enough: an init can `import
+  # { labelManifest }` and still omit it from backendOptions, in which case the
+  # SalesforceBackend fetches nothing and every key renders as its own literal
+  # name. So confirm three things, not just token presence:
+  #   1. the manifest is imported (capture the symbol it binds),
+  #   2. a backendOptions construction exists (where the SDK backend is fed),
+  #   3. that symbol appears INSIDE the backendOptions array, not merely
+  #      somewhere in the source.
+  # (3) is what separates "imported and wired" from "imported but dropped". A
+  # bare reference elsewhere (e.g. console.log(labelManifest)) must not count:
+  # the backend only receives the manifest if it sits in backendOptions.
+  # Search the WHOLE src tree, not just the init file: a valid app may define
+  # initI18n() in one file and build the SalesforceBackend (with the manifest)
+  # in a separate backend module or the entry file. Scanning only $DEFINES
+  # falsely reports "not reconciled" for that layout. Find the manifest import
+  # wherever it lives, and the file that actually constructs backendOptions.
+  # Is the manifest imported anywhere at all? (Used only for the "manifest
+  # import missing" message; the wired/dangling decision is made per-file below.)
+  MANIFEST_IMPORT_LINE=$(grep -rhnE '^[[:space:]]*import[^A-Za-z0-9_].*(label-manifest|labelManifest)' "$SRC_DIR" \
+                          --include='*.ts' --include='*.tsx' 2>/dev/null | head -1 || true)
+  # EVERY file that constructs backendOptions, not just the first: a decoy (a
+  # comment, a types file, an unused second backend) can sort earlier in the
+  # tree walk, so we check whether the manifest lands in ANY file's backendOptions.
+  BACKEND_FILES=$(grep -rlE 'backendOptions' "$SRC_DIR" \
+                   --include='*.ts' --include='*.tsx' 2>/dev/null || true)
+  # Any backend config token at all, for the "no backend config" message.
+  BACKEND_OPTS=$(grep -rlE 'backendOptions|SalesforceBackend' "$SRC_DIR" \
+                   --include='*.ts' --include='*.tsx' 2>/dev/null | head -1 || true)
+
+  # sed program that resolves the manifest's LOCAL name from an import line.
+  # Two forms bind a local name, plus the default import:
+  #   named:   import { ..., labelManifest, ... }    -> labelManifest
+  #   aliased: import { ..., labelManifest as foo }  -> foo
+  #   default: import labelManifest from ...         -> labelManifest
+  # Avoid \b: BSD/macOS sed does not support it.
+  RESOLVE_SYMBOL='s/.*[{,][[:space:]]*labelManifest[[:space:]]+as[[:space:]]+([A-Za-z0-9_]+).*/\1/; t
+                  s/.*[{,][[:space:]]*labelManifest[[:space:]]*[,}].*/labelManifest/; t
+                  s/.*import[[:space:]]+labelManifest[[:space:]]+from.*/labelManifest/; t
+                  s/.*/labelManifest/'
+
+  # Determine whether the manifest is actually passed into a backendOptions
+  # array (not merely imported and left unused). Importing is not enough: an
+  # init can `import { labelManifest }` and still omit it from backendOptions,
+  # in which case the backend fetches nothing and every key renders as its own
+  # literal name. Resolve the symbol PER FILE from that file's own import: an
+  # imported binding can only be used in the file that imports it, so the name
+  # passed into a file's backendOptions is whatever that same file bound (named,
+  # aliased, or default). Resolving per file avoids a cross-file alias mismatch
+  # (file A imports `labelManifest`, file B imports it `as m` and uses `m`).
+  # The awk emits every backendOptions array block in the file (bracket-balanced
+  # from each "[" after a "backendOptions" token); we grep those blocks for the
+  # file's own symbol. A bare reference elsewhere (console.log(labelManifest))
+  # is outside every block, so it does not count.
+  MANIFEST_USED=""
+  MANIFEST_SYMBOL="labelManifest"  # fallback for the message if no hit is found
+  if [ -n "$BACKEND_FILES" ]; then
+    while IFS= read -r BACKEND_FILE; do
+      [ -z "$BACKEND_FILE" ] && continue
+      FILE_IMPORT=$(grep -nE '^[[:space:]]*import[^A-Za-z0-9_].*(label-manifest|labelManifest)' \
+                      "$BACKEND_FILE" 2>/dev/null | head -1 || true)
+      [ -z "$FILE_IMPORT" ] && continue   # this file cannot use a binding it never imported
+      SYM=$(printf '%s\n' "$FILE_IMPORT" | sed -E "$RESOLVE_SYMBOL")
+      [ -z "$SYM" ] && continue
+      # Emit every backendOptions array block. State (started/seeking/capturing/
+      # depth/out) is awk-global and persists across lines so a multi-line array
+      # is captured whole. After a "backendOptions" token we SEEK its opening
+      # "[": only whitespace and ":" may sit between token and bracket. If any
+      # other non-space char comes first, the token is not followed by an array
+      # literal (e.g. `backendOptions: buildOpts()`), so abandon it and re-scan —
+      # without this, `started` would leak forward and capture an unrelated later
+      # array as if it were the options array (a false "wired" result).
+      # Known limit: a "]" inside a string literal in the array (e.g.
+      # `["a]b", labelManifest]`) closes the block early and can miss the symbol.
+      # That only ever pushes toward exit 3 (verify by hand), never a false exit
+      # 0, so it is safe under the heuristic framing; not worth a string parser.
+      BLOCKS=$(sed -E 's://.*$::' "$BACKEND_FILE" | awk '
+        {
+          line = $0; pos = 1; n = length(line)
+          while (pos <= n) {
+            if (!seeking && !capturing) {
+              idx = index(substr(line, pos), "backendOptions")
+              if (idx == 0) break
+              seeking = 1
+              pos = pos + idx - 1 + 14   # 14 = length("backendOptions")
+              continue
+            }
+            c = substr(line, pos, 1)
+            if (seeking) {
+              if (c == "[") { seeking = 0; capturing = 1; depth = 1; out = c; pos++; continue }
+              if (c == " " || c == "\t" || c == ":") { pos++; continue }
+              seeking = 0; continue   # not an array literal -> re-scan for next token
+            }
+            # capturing
+            out = out c
+            if (c == "[") depth++
+            if (c == "]") { depth--; if (depth <= 0) { print out; out=""; capturing=0 } }
+            pos++
+          }
+          if (capturing) out = out "\n"
+        }
+      ')
+      if printf '%s' "$BLOCKS" \
+           | grep -qE "(^|[^A-Za-z0-9_])${SYM}([^A-Za-z0-9_]|$)" 2>/dev/null; then
+        MANIFEST_USED="yes"; MANIFEST_SYMBOL="$SYM"; break
+      fi
+    done <<EOF
+$BACKEND_FILES
+EOF
+  fi
+
+  if [ -n "$MANIFEST_USED" ]; then
+    echo "i18n wired: initI18n() defined in $DEFINES, called at boot in $CALLS; the manifest ($MANIFEST_SYMBOL) is imported and passed into the backend config -> add new keys to the manifest, do not clobber the init"
+    exit 0
+  fi
+  # Could not confirm the manifest is passed into a backendOptions array. This
+  # is a heuristic textual check, so treat exit 3 as "verify, do not clobber":
+  # the manifest may be wired through a form this script cannot see (passed via
+  # a variable, spread, or helper). Report the specific gap for the human/agent
+  # to confirm before editing; only reconcile if it genuinely dangles.
+  MISSING=""
+  [ -z "$MANIFEST_IMPORT_LINE" ] && MISSING="manifest import"
+  [ -z "$BACKEND_OPTS" ] && MISSING="${MISSING:+$MISSING and }backendOptions/SalesforceBackend config"
+  [ -n "$MANIFEST_IMPORT_LINE" ] && [ -n "$BACKEND_OPTS" ] \
+    && MISSING="${MISSING:+$MISSING and }could not confirm the manifest is passed into backendOptions (it may dangle unused, or be wired via a variable this check cannot see)"
+  echo "i18n wired: initI18n() defined in $DEFINES, called at boot in $CALLS; but $MISSING -> verify by hand; if it genuinely dangles, reconcile (import the manifest AND pass it into the SalesforceBackend's backendOptions) without clobbering"
+  exit 3
+fi
+
+if [ -z "$DEFINES" ]; then
+  echo "no i18n init found (no initI18n() definition under $SRC_DIR) -> scaffold it"
+  exit 1
+fi
+echo "initI18n() defined in $DEFINES but not called at boot -> add the boot-time call"
+exit 2

package/skills/experience-ui-bundle-localize/scripts/check-manifest-registered.sh

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+set -euo pipefail  # exit on error (-e), undefined vars (-u), and propagate pipeline failures (-o pipefail)
+#
+# check-manifest-registered.sh — Confirm every t("Key") call site is registered
+# in label-manifest.ts.
+#
+# An unregistered key renders as its own literal name at runtime with no error —
+# the central silent-failure trap this skill exists to prevent. That check is a
+# pure set comparison (call-site keys vs manifest keys), so run this rather than
+# counting entries by hand.
+#
+# Keys are compared on their trailing segment: a manifest entry "c:Welcome_Text"
+# matches a call site t("Welcome_Text") or t("c:Welcome_Text") either way. The
+# manifest's boilerplate example comment is stripped first so a commented-out
+# sample key does not mask a genuinely missing one.
+#
+# Usage (run from the UI bundle dir, or pass its src path):
+#   bash <skill-dir>/scripts/check-manifest-registered.sh [src-dir]
+#
+# src-dir defaults to "src". label-manifest.ts is found anywhere under it.
+#
+# Exit codes (kept aligned with check-i18n-wired.sh so the workflow branches on
+# the code, not the message text):
+#   0  every t() key is registered (or there are no t() calls / no manifest to
+#      cross-check — nothing to gate)
+#   1  one or more t() keys are missing from the manifest — stop and register them
+#  64  usage error — the source dir does not exist (bad argument or wrong cwd).
+#      This is NOT a "keys missing" result; do not scaffold or register. Fix the
+#      path and re-run. (64 = EX_USAGE, kept out of the 0/1 semantic range so
+#      exit 1 uniquely means "keys missing".)
+
+SRC_DIR="${1:-src}"
+if [ ! -d "$SRC_DIR" ]; then
+  echo "ERROR: source dir not found: $SRC_DIR (run from the UI bundle dir, or pass its src path)" >&2
+  exit 64
+fi
+
+MANIFEST=$(find "$SRC_DIR" -type f -name 'label-manifest.ts' | head -1 || true)
+
+# Collect t("Key") / t('Key') call sites from component files, keeping the
+# trailing key segment (drop any "ns:" prefix). Use POSIX character classes and
+# an explicit boundary, not \b / \s: BSD/macOS grep -E silently ignores those,
+# which would miss call sites on a Mac (the platform this skill targets) and let
+# an unregistered key slip through — the exact silent-fail this script guards.
+# (^|[^A-Za-z0-9_]) before t( stops "insertText(" / "print(" matching as t(.
+CALLED=$(grep -rhoE "(^|[^A-Za-z0-9_])t\([[:space:]]*[\"'\`][^\"'\`]+[\"'\`]" "$SRC_DIR" \
+           --include='*.tsx' --include='*.jsx' 2>/dev/null \
+         | sed -E "s/.*[\"'\`]([^\"'\`]+)[\"'\`].*/\1/; s/.*://" \
+         | sort -u || true)
+
+if [ -z "$CALLED" ]; then
+  echo "no t() call sites to check (scenario may not require the manifest) -> proceed"
+  exit 0
+fi
+if [ -z "$MANIFEST" ]; then
+  echo "ERROR: t() call sites exist but no label-manifest.ts was found under $SRC_DIR -> register them" >&2
+  echo "$CALLED" | sed 's/^/  missing: /' >&2
+  exit 1
+fi
+
+# Manifest keys: strip comments first so a boilerplate example key (the scaffold
+# ships one) does not count as registered and mask a genuinely missing key — the
+# exact silent-fail this script guards. Block comments can span lines, so a
+# line-based `s:/\*.*\*/::` misses a multi-line `/* ... */` around an example
+# key; use an awk state machine that carries the in-comment flag across lines,
+# then strip `//` line comments. Keys hold no `/`, so this never eats a key.
+REGISTERED=$(awk '
+               { s = $0 }
+               {
+                 out = ""
+                 i = 1
+                 n = length(s)
+                 while (i <= n) {
+                   if (incomment) {
+                     if (substr(s, i, 2) == "*/") { incomment = 0; i += 2 }
+                     else { i++ }
+                   } else if (substr(s, i, 2) == "/*") {
+                     incomment = 1; i += 2
+                   } else {
+                     out = out substr(s, i, 1); i++
+                   }
+                 }
+                 print out
+               }
+             ' "$MANIFEST" \
+             | sed -E 's://.*$::' \
+             | grep -oE "[\"'\`][^\"'\`]+[\"'\`]" \
+             | sed -E "s/[\"'\`]//g; s/.*://" \
+             | sort -u || true)
+
+MISSING=$(comm -23 <(echo "$CALLED") <(echo "$REGISTERED") || true)
+
+if [ -n "$MISSING" ]; then
+  echo "ERROR: t() keys not registered in label-manifest.ts (they render as literal key names at runtime):" >&2
+  echo "$MISSING" | sed 's/^/  /' >&2
+  exit 1
+fi
+
+echo "all $(echo "$CALLED" | wc -l | tr -d ' ') t() key(s) registered in the manifest -> proceed"
+exit 0

package/skills/experience-ui-bundle-localize/scripts/check-org-api-version.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail  # exit on error (-e), undefined vars (-u), and propagate pipeline failures (-o pipefail)
+#
+# check-org-api-version.sh — Verify a target org supports API v68.0+ (Release 264).
+#
+# Runtime label resolution over GraphQL for UI Bundles ships in Salesforce
+# Release 264 (API v68.0+). A `sourceApiVersion` in sfdx-project.json records
+# what you declared, not what the org supports, so a newer CLI pointed at an
+# older org can pass a static file check and then fail at runtime. This queries
+# the org's actual maximum API version before you wire anything.
+#
+# `sf api request rest` keeps authentication at the CLI transport layer, so no
+# access token enters this script's context. Do not extract a token and curl.
+#
+# Usage:
+#   bash <skill-dir>/scripts/check-org-api-version.sh <org-alias-or-username>
+#
+# Exit codes:
+#   0  org supports v68.0+ — proceed
+#   1  org's max API version is below v68.0, or it could not be determined — stop
+
+if [ "$#" -ne 1 ] || [ -z "${1:-}" ]; then
+  echo "ERROR: pass exactly one org alias or username. Usage: check-org-api-version.sh <org-alias-or-username>" >&2
+  exit 1
+fi
+ORG="$1"
+
+# FORCE_COLOR=0 stops the CLI from emitting ANSI color codes into stdout JSON,
+# which would otherwise make jq fail with "Invalid numeric literal".
+MAX_API=$(FORCE_COLOR=0 sf api request rest "/services/data/" --target-org "$ORG" \
+          | jq -r '[.[].version | tonumber] | max') \
+  || { echo "ERROR: could not determine the target org's API version (auth or network problem?). Verify the org is reachable, then retry." >&2; exit 1; }
+
+[ -n "$MAX_API" ] && [ "$MAX_API" != "null" ] \
+  || { echo "ERROR: the org returned an empty API version. Verify the target org and retry." >&2; exit 1; }
+
+awk -v v="$MAX_API" 'BEGIN{ exit !(v+0 >= 68.0) }' \
+  || { echo "ERROR: runtime label localization for UI Bundles requires Salesforce Release 264 (API v68.0+). Target org's maximum supported API version is v${MAX_API}. Retarget a Release 264+ org, or upgrade the org before adding localization." >&2; exit 1; }
+
+echo "OK: target org '${ORG}' supports API v${MAX_API} (>= v68.0). Proceed."

package/skills/experience-ui-bundle-localize/scripts/detect-bundle-type.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+set -euo pipefail  # exit on error (-e), undefined vars (-u), and propagate pipeline failures (-o pipefail)
+#
+# detect-bundle-type.sh — Classify a UI Bundle as authenticated (supported) or
+# a site (not yet supported) before localizing it.
+#
+# The bundle's type is decided by deterministic file and string checks, so run
+# this rather than interpreting them by hand. It classifies in a fixed order and
+# stops at the first hit:
+#   - in-core internal: ui-bundle.json accessCheck starts with "LwrInternalApp." -> proceed
+#   - B2E: a CustomApplication whose <uiBundle> names this bundle           -> proceed
+#   - site: a digitalExperienceConfigs/*.digitalExperienceConfig-meta.xml   -> NOT supported, stop
+#   - anything else: unbound / cannot auto-detect                           -> ask the user
+#
+# The B2E and site checks are package-local: CustomApplication and site config
+# metadata are siblings of uiBundles/ under the package source path
+# (e.g. force-app/main/default/{applications,uiBundles}/), so the script derives
+# that metadata root from the bundle path rather than the current directory. If
+# the bundle is bound elsewhere the script returns 2 (ask the user), the correct
+# fallback. Do not gate on a <target> element inside *.uibundle-meta.xml;
+# CLI-generated bundles do not carry it.
+#
+# Usage (pass the full path to the bundle dir; cwd does not matter):
+#   bash <skill-dir>/scripts/detect-bundle-type.sh <path-to-uiBundles/<name>/ dir>
+#
+# Exit codes:
+#   0  authenticated app (in-core internal or B2E) — proceed
+#   1  site (B2C/B2B) — NOT supported; stop and tell the user
+#   2  unbound / cannot auto-detect — ask the user to confirm the bundle is
+#      an authenticated app (B2E or in-core internal); stop if they cannot
+
+if [ "$#" -ne 1 ] || [ -z "${1:-}" ]; then
+  echo "ERROR: pass exactly one bundle directory. Usage: detect-bundle-type.sh <path-to-uiBundles/<name>/ dir>" >&2
+  exit 2
+fi
+bundleDir="${1%/}"
+bundle=$(basename "$bundleDir")
+
+# CustomApplication and site metadata sit beside uiBundles/ under the package
+# source path, not at the cwd. Derive that metadata root from the bundle path:
+# it's the parent of the uiBundles/ segment. Fall back to the cwd for a
+# flattened layout with no uiBundles/ segment.
+metaRoot="."
+case "$bundleDir" in
+  */uiBundles/*) metaRoot="${bundleDir%/uiBundles/*}" ;;
+esac
+
+if [ -f "${bundleDir}/ui-bundle.json" ] \
+   && jq -e '(.accessCheck // "") | startswith("LwrInternalApp.")' "${bundleDir}/ui-bundle.json" >/dev/null 2>&1; then
+  echo "in-core internal app -> proceed"; exit 0
+elif grep -rlq --include='*.app-meta.xml' "<uiBundle>${bundle}</uiBundle>" "${metaRoot}/applications" 2>/dev/null; then
+  echo "B2E (CustomApplication-bound) -> proceed"; exit 0
+elif ls "${metaRoot}"/digitalExperienceConfigs/*.digitalExperienceConfig-meta.xml >/dev/null 2>&1; then
+  echo "site (B2C/B2B) -> NOT supported; stop"; exit 1
+else
+  echo "unbound / cannot auto-detect -> ask the user"; exit 2
+fi

package/skills/experience-ui-bundle-site-generate/SKILL.md

@@ -3,6 +3,9 @@ name: experience-ui-bundle-site-generate
 description: "MUST activate when the project contains a uiBundles/*/src/ directory and the task involves creating or configuring site infrastructure. Use this skill when creating or configuring a Salesforce Digital Experience Site for hosting a UI bundle. Activate when files matching digitalExperiences/, networks/, customSite/, or DigitalExperienceBundle exist and need modification, or when the user wants to publish, host, or configure guest access for their app."
 metadata:
   version: "1.0"
+  cliTools:
+    - tool: ["sf"]
+      semver: ">=2.0.0"
 ---
 
 # Digital Experience Site for React UI Bundles

package/skills/mobile-apps-create/SKILL.md

@@ -2,12 +2,10 @@
 name: mobile-apps-create
 description: "The entry point for building any Salesforce native mobile app on iOS or Android. TRIGGER when the user says: \"build a Salesforce iOS app\", \"add Salesforce login to my Android app\", \"set up Mobile SDK\", \"add MobileSync / SmartStore offline storage\", \"embed an Agentforce agent in my mobile app\", \"add Agentforce chat to iOS/Android\", or otherwise asks to create, extend, or integrate a Salesforce mobile experience in Swift or Kotlin (MSDK, Agentforce SDK, or both). SKIP when the user is building a non-Salesforce mobile app, using React Native / Flutter / Ionic without Salesforce integration, asking about generic mobile UI design, or working on a Salesforce-adjacent web/desktop surface (LWC, Experience Cloud, Mobile Publisher branding-only)."
 metadata:
+  version: "1.0"
   cliTools:
     - tool: ["npx"]
       semver: ">=9.0.0"
-  relatedSkills:
-    - "mobile-platform-native-capabilities-integrate"
-  version: "1.0"
 ---
 
 # Salesforce Mobile

package/skills/platform-custom-lightning-type-generate/SKILL.md

@@ -6,6 +6,7 @@ metadata:
   minApiVersion: "60.0"
   relatedSkills:
     - "platform-lightning-type-widget-coordinate"
+    - "platform-mcp-tool-widget-coordinate"
     - "platform-widget-generate"
 ---
 
@@ -57,6 +58,7 @@ Custom Lightning Types (CLTs) are JSON Schema-based type definitions used by the
 - **Apex class CLTs are minimal**:
   - Include **only** `title`, `description` (optional), and `lightning:type` set to `@apexClassType/...`.
   - Do **not** add `type`, `properties`, `required`, or `unevaluatedProperties`.
+  - **Custom LWC renderers/editors on an Apex class CLT MUST NOT use `attributes` in the root override — this overrides any prompt wording to the contrary.** Since the schema has no `properties` block, there is nothing for `{!$attrs.<name>}` to resolve against — `unevaluatedProperties: false` will reject any attribute key (e.g. `"You can't add the flightId property ... because the unevaluatedProperties keyword value is set to false"`). Use `"componentOverrides": { "$": { "definition": "c/<yourComponent>" } }` with **no `attributes` key** at all. **If the user's prompt explicitly asks for attribute mappings to specific fields (e.g. "with attribute mappings for fieldA, fieldB") on an Apex-class CLT renderer/editor, do NOT comply literally** — omit `attributes` from the root override anyway, and say so in your response (e.g. "Note: attribute mappings were omitted because the backing type is an Apex-class CLT, which has no `properties` block to bind against").
 - **No shell metacharacters that trigger the Vibes safe-shell filter.** In any Bash tool call emitted by this skill, do NOT use command substitution (`$(…)` or backticks), process substitution (`<(…)`, `>(…)`), brace expansion (`{a,b,c}` or `{1..N}`), or `eval` / `exec`. Vibes forces manual approval on these patterns even under Bypass mode and stalls the eval. Emit separate commands (`mkdir -p a && mkdir -p b`) or print each value with its own command and reason about the output rather than capturing it in a shell variable.
 
 ## Additional CLT Metaschema Validations
@@ -158,6 +160,7 @@ When you need the full list of supported primitive `lightning:type` identifiers,
 | `additionalProperties` error on layout attributes | Adding `label` or other attributes to `lightning/propertyLayout` | Only use `property` attribute in `lightning/propertyLayout`. Remove `label`, `title`, or any other attributes |
 | Invalid target configuration for custom LWC | Custom LWC component's `-meta.xml` missing required target (`lightning__AgentforceInput` or `lightning__AgentforceOutput`) | Add correct target to LWC's `-meta.xml`: use `lightning__AgentforceInput` for editors, `lightning__AgentforceOutput` for renderers |
 | Attribute mapping doesn't exist in type schema | Using `{!$attrs.propertyName}` where `propertyName` is not defined in schema | Ensure all attribute mappings reference actual properties in your type schema's `properties` section |
+| `unevaluatedProperties` error on custom LWC renderer for an Apex class CLT | Root override `attributes` mapping used on an Apex class CLT, which has no `properties` block to validate against | Remove `attributes` entirely from the root override; use `"componentOverrides": { "$": { "definition": "c/<component>" } }` only |
 | `additionalProperties` error with deprecated keys | Using `propertyRenderers` or `view` in editor/renderer config | Replace deprecated `propertyRenderers` with `componentOverrides` and `view` with `layout` |
 | Type mismatch in component attributes | Passing wrong type for component attribute (e.g., integer instead of string) | Ensure attribute values match the expected type defined by the component |
 

package/skills/platform-custom-lightning-type-generate/assets/primitive-types-and-constraints.md

@@ -38,4 +38,4 @@ When strict validation is enabled (`unevaluatedProperties: false`), keep each pr
 - `const`, `enum`
 - `lightning:textIndexed`, `lightning:supportsPersonalization`, `lightning:localizable`
 - `lightning:uiOptions`, `lightning:allowedUrlSchemes`
-- `lightning:tags` (metaschema restricts values; currently `flow` is the only known allowed tag)
+- `lightning:tags` (metaschema restricts values; known allowed tags are `flow` and `mcp` — use `mcp` on object-based CLTs that model an MCP-tool envelope/response, per `platform-mcp-tool-widget-coordinate`)