SkillAgentSearch skills...

test-native-extension

Validate a third-party control repo across four automated layers plus one printed manual recipe. Layer 1 asserts native-source structure (Android getName() and iOS +moduleName to manifest nativeModule; @ReactMethod / RCT_EXPORT_METHOD to methods; no @ReactModule) plus load/init readiness (ReactPacka…

Install / Use

npx skills add microsoft/power-platform-skills --skill test-native-extension

Installs into whichever agent you are using.

About this skill
πŸ“„

SKILL.md

Installable skill definition

Quality Score

84/100

Category

Automation

Supported Platforms

Universal

Our assessment of test-native-extension

test-native-extension scores 84/100 on our quality scale, 2080th of 2,758 Automation skills we index.

Its SKILL.md is 63 KB long, well organised into 44 sections with 16 code examples: long enough that it reads more like full documentation than a focused instruction file, which agents can find harder to follow.

It has 919 GitHub stars, a meaningful sign that others use it.

Substance
21/30
Structure
20/20
Description
15/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so test-native-extension is actively maintained.
  • Our last check on 2026-11-06 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit β€” read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk β€” read a skill before letting an agent act on it.

test-native-extension compared with similar skills

All 4 of these similar skills score higher than test-native-extension; compare them before choosing.

SkillScoreStarsUpdatedFormat
test-native-extension (this skill)by microsoft8491959d agoSKILL.md
Agent-Reachby Panniantong100114.0ktodayCLAUDE.md
rufloby ruvnet10082.3ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10040.6k12d agoCLAUDE.md
Scraplingby D4Vinci100104.9k5d agoMCP Server

Frequently asked questions

How do I install test-native-extension?
Run npx skills add microsoft/power-platform-skills --skill test-native-extension. The install tabs above show the steps for each supported agent.
Which AI agents does test-native-extension work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is test-native-extension safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is test-native-extension still maintained?
The repository was last updated about 2 months ago, so test-native-extension is actively maintained.

name: test-native-extension description: "Validate a third-party control repo across four automated layers plus one printed manual recipe. Layer 1 asserts native-source structure (Android getName() and iOS +moduleName to manifest nativeModule; @ReactMethod / RCT_EXPORT_METHOD to methods; no @ReactModule) plus load/init readiness (ReactPackage public no-arg constructor, iOS [cls new] no-arg init, requiresMainQueueSetup NO, non-throwing eager construction), so launch-time crashes surface before any build. Layer 2 validates the committed ./manifest.json against the ppmplugin-format rules. Layer 3 asserts request/response/error-code agreement across native and PCF. Layer 4 compiles the PCF (auto-skipped if absent). Layer 5 prints a device end-to-end recipe. Native compile belongs to /build-android-binary and /build-ios-binary β€” this is the cheap structural pre-flight before those slow builds. Reports pass/fail per layer with a fix hint and updates .extension-state.md." allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion, Skill model: opus

/test-native-extension

Runs the 4-layer validation ladder for a third-party control repo β€” the one that ships as a .ppmplugin binary bundle, not as a TypeScript extension. Layers 1–4 are automated; Layer 5 is interactive (requires a real device or simulator and the Companion PCF deployed to a test environment).

| Layer | What | Mode | Speed | Requires | |---|---|---|---|---| | 0 | Holistic contract consistency (native ↔ manifest ↔ PCF cross-check) | Automated, warn-only | seconds | at least a native module on disk | | 1 | Native-source structure asserts (Android getName() ↔ iOS +moduleName ↔ manifest) | Automated, grep/parse | seconds | android/ and/or ios/ | | 2 | Manifest validation (ppmplugin-format Β§4 rules) | Automated | seconds (skipped only if no manifest on disk) | ./manifest.json (committed; else staged copy) | | 3 | Native-source contract asserts (request/response/error grep cross-check) | Automated | seconds | native module(s) | | 4 | PCF compile (npm run build in pcf/<Pascal>PCF/) | Automated | seconds (after first install) | pcf/<Pascal>PCF/ must exist (skipped otherwise) | | 5 | Manual device / simulator end-to-end | Recipe-only β€” skill prints, user runs on own time | 5–10m, off-skill | pcf/ must exist + PCF deployed |

Run order is layer-by-layer for Layers 1–4. Stop on the first failure in the automated layers. Layer 5 is not gated by the skill β€” it prints the device recipe and exits; the user runs it on their own time and updates .extension-state.md manually.

What this skill does NOT validate: native code compilation into a loadable DEX / framework. That's the job of /build-android-binary and /build-ios-binary β€” they run the real Gradle / xcodebuild toolchain against the pinned RN version and surface the real compiler error. Standalone pod lib lint and ./gradlew assembleDebug from this skill would give false-confidence (they resolve dependencies from public CDN/maven, not against the wrap host's pinned versions). This skill is the structural pre-flight that runs in seconds with no toolchain β€” it asserts the native source is shaped correctly (right base class, right symbols, the Android getName() ↔ iOS +moduleName ↔ manifest agreement) so the build skills don't fail late on a fixable-in-seconds mistake. There is no TypeScript / INativeExtension layer in this track to type-check β€” a native-only .ppmplugin bundle dispatches straight to NativeModules.<nativeModule>.<method> (ppmplugin-format Β§2 β€” Runtime dispatch contract).


Step 1 β€” Read the shared docs and PRD

  1. Read shared/shared-instructions.md, shared/naming-conventions.md, shared/ppmplugin-format.md.

  2. Apply the per-skill minimal prereq policy (shared-instructions.md Β§1.5). Layers 1–3 need no toolchain (pure read + grep + validate against the working tree). Layer 4 needs Node + npm only when a PCF is present β€” and only for the first run (to npm install the PCF's own deps from the public npm registry). This track is self-contained and requires no package-feed or source-control authentication (shared-instructions Β§0a). Run the /test-native-extension check from prereq-check.md (Layers 0–3 need nothing; Node + npm only if a PCF is present for Layer 4 β€” there is no "baseline" check in this self-contained track).

    Print the prereq status as a visible block per shared-instructions.md Β§9.2 before continuing:

    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     Prereq check β€” /test-native-extension
    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    
     🟒 βœ“ git installed
     🟒 βœ“ Node 20+ installed            (only needed for Layer 4 β€” PCF compile)
     🟒 βœ“ npm installed                 (only needed for Layer 4 β€” PCF compile)
    
     🟒 3 checks passed. Ready to proceed.
    

    If no pcf/ is present, Node/npm aren't needed at all β€” note them as n/a (no PCF) rather than failing. Layers 1–3 always run regardless. If any check fails, print the β†’ Fix: line for that check and STOP.

  3. Read ./PRD.md. If missing, the Layer 3 contract asserts fall back to the native source itself as source-of-truth (it's still useful) β€” note it and continue rather than STOP.

  4. Read ./.extension-state.md. If Phase is below manifest (no native module on disk yet), STOP β€” there's nothing scaffolded to test.


OS-neutral β€” run these checks with the built-in Read/Grep tools, not a shell. Every extraction/assert in this skill (the find / grep / sed / awk snippets below) is shown in bash for readability only β€” it describes what to match, not a shell to execute. RUN them with the agent's built-in Read and Grep tools (plus your own parsing), which behave identically on macOS, Linux, and Windows PowerShell. Do NOT shell out to grep/sed/awk/sort/find β€” they aren't on a stock Windows box, and Layers 0–3 are deliberately pure read+parse (no toolchain) so they run everywhere. Layer 4's npm run build is the only real command, and npm is cross-platform.

Step 2 β€” Confirm scope with the user

First, auto-detect whether the PCF companion is on disk β€” use the Grep tool (glob: pcf/**/ControlManifest.Input.xml) so case differences and minor layout variations don't trip the check. (Illustrative bash β€” don't run it verbatim on Windows):

PCF_MANIFEST=$(find pcf -type f -name "ControlManifest.Input.xml" 2>/dev/null | head -1)
[ -n "$PCF_MANIFEST" ] && PCF_PROJECT_ROOT=$(dirname $(dirname "$PCF_MANIFEST"))

If $PCF_MANIFEST is set, the PCF is scaffolded; use $PCF_PROJECT_ROOT (e.g. pcf/<Pascal>PCF) for Layer 4's build step. If empty, distinguish: no pcf/ at all β†’ "not yet scaffolded"; pcf/ exists but no manifest β†’ "scaffold appears incomplete; re-run /generate-pcf-companion or inspect the folder."

Also detect the manifest that drives Layer 2. Prefer the committed ./manifest.json (the source of truth /generate-native-extension writes at scaffold time, so it normally exists here, right after scaffold) and fall back to the staged build copy:

MANIFEST=$( [ -f ./manifest.json ] && echo ./manifest.json || ls ppmplugin/staging/manifest.json 2>/dev/null )

If $MANIFEST is empty, Layer 2 is skipped (no manifest on disk yet β€” a hand-authored module that hasn't run /generate-ppmplugin-manifest; with the scaffold, ./manifest.json is present from the start).

This drives Layer 4 (PCF compile) and Layer 5 (manual recipe β€” both require the PCF to exist).

| State | Default layer set | |---|---| | No pcf/ folder (PCF not yet scaffolded) | Layers 1, 2, 3 run; Layers 4 and 5 marked deferred β€” re-run after /generate-pcf-companion | | pcf/ folder exists | Layers 1–4 run automated; Layer 5 prints the device recipe (no wait, no gate) |

Print:

Test plan
─────────
Repo: <cwd>
Extension: @powerapps/extension-<kebab>  (class <Pascal>Extension, module <Pascal>Module)
PCF companion: <found pcf/<Pascal>PCF/ | NOT yet scaffolded>
Manifest: <found ./manifest.json (committed) | ppmplugin/staging/manifest.json (staged) | NONE>

Automated layers (skill runs these and reports pass/fail):
  0. Holistic contract check β€” native ↔ manifest ↔ PCF cross-grep (warn-only)
  1. Native-source structure β€” getName()/+moduleName/@ReactMethod asserts + load/init readiness (no-arg package ctor, iOS [cls new]/requiresMainQueueSetup, non-throwing construction)
  2. Manifest validation     β€” <ppmplugin-format Β§4 rules | SKIPPED β€” no manifest>
  3. Native-source contract  β€” request/response/error grep cross-check
  4. PCF compile             β€” <npm run build in pcf/<Pascal>PCF | DEFERRED>

Manual layer (skill prints a recipe; you run it on a device on your own time):
  5. Device end-to-end       β€” <print recipe | DEFERRED>

Not validated by this skill: native iOS / Android compile into a loadable DEX / framework (run /build-android-binary // /build-ios-binary for that).

Stop on first failure: <yes by default>

Use AskUserQuestion:

Run the test plan?

  • Run the default set above (recommended)
  • Run only Layers 1–3 (skip PCF compile; skip the Layer 5 recipe)
  • Run a single layer (specify which)
  • Cancel

If the user picks a single layer, validate dependencies β€” e.g. "Layer 3 (contract asserts) is more useful after Layer 1 (structure asserts) has passed in this run or a recent run; do you want to skip the check and run anyway?". Don't enforce strictly; surface the implication and let the user decide.


Step 2.5 β€” Layer 0: Holistic contract consistency

Diagnostic layer, not a hard gate. Reports findings; downgrades to warnings rather than blocking. Useful for catching drift between native modules ↔ manifest.json ↔ PCF before the harder-to-debug runtime symptoms surface in Layer 5.

This layer cross-checks the contracts that flow across the native modules, the staged manifest.json, and the PCF. None of these checks compile or run code β€” they're all grep/parse-based. If any check finds a mismatch, the skill prints a numbered warning with the mismatched values + suggested fix, but continues to Layer 1 unless the user opts to stop. The point is to surface inconsistencies early; the engineer decides which ones matter.

What's checked

| # | Contract | Sources cross-checked | Mismatch surfaces | |---|---|---|---| | 1 | Routing key | manifest receivers[].name β†’ ROUTING_KEY const in pcf/<Pascal>PCF/<Pascal>PCF/index.ts | Both must be the same receiver key (our scaffold uses '<Pascal>Extension'; any JS-identifier works β€” see ppmplugin-format Β§2). Mismatch = silent routing failure at runtime (the wrap bridge can't dispatch). | | 1b | PCF transport (wire format) | the dispatch call in index.ts: it MUST call window.PowerApps.NativeExtension.sendAsync("<key>", { method, args: [request] }) and MUST NOT call cordova.exec (or any cordova.*) directly; the sendAsync payload MUST be a raw object (not pre-JSON.stringify'd β€” sendAsync stringifies internally) and the inner args MUST be [request] (an array). Grep for \.sendAsync\( present AND cordova\.exec absent in the file. | This is the one structural check that maps to a wire-format bug. A direct cordova.exec call passes every other check (the array IS an array, the key IS aligned) and fails only on the first device tap β€” the raw cordova global is not in the PCF sandbox, so the tap does nothing (worst on Android). Likewise a pre-stringified payload double-encodes β†’ BRIDGE_FAILED. If `s

Truncated for display β€” read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars919
CategoryAutomation
Updated1mo ago
Forks186

Languages

JavaScript

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit β€” see the Safety scan above for what the skill file itself contains.

No cautions
test-native-extension β€” Universal Skill: Install & Safety Check | SkillAgent