Skip to main content
plugin

mobile-app — Claude Code plugin: what it does, how to install

A Claude skill that scaffolds a Power Apps mobile app on Expo and React Native, covering screens, native features and Power Platform connectors.

MIT ★ 1,167 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add microsoft/power-platform-skills
/plugin install mobile-app@power-platform-skills
Open on GitHub

What mobile-app does

The plugin gives Claude a /create-mobile-app skill. It works out the app plan, the data model, screens, native capabilities and the connector wiring, then generates the code inside an Expo, React Native and TypeScript template. Power Platform data comes in through @microsoft/power-apps-native-host.

Before the first run you need Node.js 24 LTS, npm 10 or newer, and the Power Apps Mobile Preview app on a phone, because that app is what opens the Metro QR code. Pull the template with npx degit microsoft/power-platform-skills/plugins/mobile-apps/template#main my-mobile-app, then run npm install. Microsoft keeps this in Private Preview, so it stays out of production.

During the run the skill lists Microsoft Entra app registrations it can read with your Azure CLI sign-in and flags the ones missing permissions. An app created without a client ID can get one later through /set-app-registration-native, which verifies permissions before writing auth.config.json. npm run dev starts Metro after schema generation and type-checking; /debug-app reads the logs kept in .powernative/metro-logs/.

What it helps with

  • scaffold a Power Apps mobile client on Expo without editing the template by hand
  • pick a Microsoft Entra app registration and spot missing permissions
  • hook app screens up to Power Platform connectors
  • start Metro with type-checking and read the logs through /debug-app
  • move an existing app onto a newer template

Example prompts for the agent

  • /create-mobile-app scaffold a small notes app
  • Add a list screen and wire in the Dataverse connector
  • Show me the build errors from the logs with /debug-app

How to install mobile-app

Plugin marketplace

/plugin marketplace add microsoft/power-platform-skills
/plugin install mobile-app@power-platform-skills

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about mobile-app

How do I install mobile-app in Claude Code?

Add the marketplace first: /plugin marketplace add microsoft/power-platform-skills. Then install the plugin: /plugin install mobile-app@power-platform-skills.

What does mobile-app do?

Its /create-mobile-app skill plans and generates a Power Apps mobile app on Expo and React Native, including screens, native features and connector wiring.

What does mobile-app need to run?

Node.js 24 LTS, npm 10 or newer, and the Power Apps Mobile Preview app on a phone for previewing. Microsoft ships the build path as a Private Preview, so it is not meant for production.

Source text

mobile-apps · MIT
# Power Apps Standalone App Template

This template is an Expo, React Native, and TypeScript starter for building a standalone mobile app that connects to Power Platform data through `@microsoft/power-apps-native-host`.

## Requirements

- Node.js 24 LTS.
- npm 10 or newer.
- The Power Apps Mobile Preview app from the Apple App Store or Google Play.

## Setup

**Building native mobile apps with Power Platform is in Private Preview; do not use this in production.**

Have questions or feedback? Join the [Native Apps Office Hours](OFFICE_HOURS.md).

Start from the Power Platform mobile app template, then use the mobile-app
skill to generate the app plan, data model, screens, native capabilities, and
connector wiring.

1. Create a new app from the template and install dependencies:

    ```sh
    npx degit microsoft/power-platform-skills/plugins/mobile-apps/template#main my-mobile-app
    cd my-mobile-app
    npm install
    ```

2. Install the mobile-app plugin from the Power Platform Skills marketplace.

    1. Open the Extensions pane.
    2. Enter `@agentPlugins mobile-app` in the search box.
    3. Select the **mobile-app** plugin and install it.
    4. Reload VS Code if prompted, then open Copilot Chat in Agent mode.

    Alternatively, install it from a terminal with GitHub Copilot CLI:

    ```sh
    copilot plugin marketplace add microsoft/power-platform-skills
    copilot plugin install mobile-app@power-platform-skills
    ```

    For Claude CLI:

    ```sh
    claude plugin marketplace add microsoft/power-platform-skills
    claude plugin install mobile-app@power-platform-skills --scope user
    ```

3. Open the template folder in VS Code and run the skill from Copilot Chat:

    ```text
    /create-mobile-app
    ```

    The template includes this host package and the required Expo / React Native
    runtime dependencies. The skill updates the app in place as it designs and
    generates the mobile experience.

    When prompted to sign in, use credentials for the tenant where the Dataverse
    environment belongs.

4. Select or create the Microsoft Entra app registration.

    `/create-mobile-app` uses your Azure CLI sign-in to list all app registrations
    that Microsoft Graph allows you to read in the selected environment's tenant.
    Registrations passing every applicable native runtime permission check appear first, and
    the rest remain available through pagination. Each choice shows only a short
    client-ID prefix and either `✓ All required permissions configured` or
    `✗ Missing required permissions`. The full client ID and missing-permission
    details are shown after selection.
    Discovery is best-effort: if Azure CLI,
    Microsoft Graph, tenant validation, or permission checking fails, the skill
    immediately falls back to asking for the app registration client ID and
    continues with its permission check marked unavailable.

    To create a registration or repair one whose permissions are incomplete,
    open the Power Apps Wrap page for the selected environment:

    ```text
    https://make.powerapps.com/environments/<environment-id>/wraps#create-app-registration
    ```

    The Wrap experience configures the native registration, flags missing
    permissions, and offers one-click repair. Do not add redirect URIs or API
    permissions manually. Some repairs and consent operations require an Azure
    tenant admin.

    If the app was created without a client ID, run
    `/set-app-registration-native` later from the app folder. It provides the
    same discovery and verification flow before writing `auth.config.json`.

    ### Required API permissions

    The read-only checker validates the native runtime profile. The baseline is
    Dynamics CRM `user_impersonation` plus Power Platform API
    `PowerApps.Apps.Read`. Apps using Power Platform connectors additionally
    require Azure API Connections `Runtime.All` and the Power Platform API
    `Connectivity.Connectors.Read`, `Connectivity.Connections.Read`,
    `Connectivity.Connections.Write`, and
    `Connectivity.Connections.UserConsent` scopes. The checker does not require
    unrelated Wrap packaging permissions. Platform redirects, packaging
    permissions, third-party-app allowlisting, and admin consent are finalized
    in Wrap.

5. Start mobile app:

    `/create-mobile-app` starts Metro with `npm run dev`; its `predev` lifecycle
    runs schema generation and type-checking before Expo starts.
    The template's Metro config delegates sanitized logging to the native host package, which writes `.powernative/metro-logs/`,
    so `/debug-app` works after switching between VS Code, Copilot CLI, and
    Claude Code without asking for a terminal ID.

    To start Metro manually instead, run the command below from the app directory.
    Manual starts and `/debug-app` use the same `.powernative` log source.

    ```bash
    npm run dev
    ```

    The Metro config removes sensitive lines before writing logs. The complete
    `.powernative/` folder is ignored by the template's `.gitignore`.

6. Preview the app by scanning the QR code with the Power Apps Mobile Preview app

    - App store: https://apps.apple.com/us/app/power-apps-developer/id6753083462
    - Play store: https://play.google.com/store/apps/details?id=com.microsoft.PreviewApp

## License and notices

This template is provided under the license in `LICENSE`.

The mobile-app plugin is stored in `plugins/mobile-apps` in the `power-platform-skills` marketplace. It works with GitHub Copilot in VS Code and Claude Code.

## Manual migration to a new template

To migrate without `upgrade-template`, create a new app from the latest template
instead of modifying the old app in place. Commit or back up the old app first.

1. Create the new app and install its dependencies.
2. Copy the contents of `app/` and `src/` from the old app into the same
    directories in the new app:

    ```bash
    cp -R ../old-app/app/. app/
    cp -R ../old-app/src/. src/
    ```

3. Copy app-owned assets and settings such as `assets/`, `auth.config.json`,
    `power.config.json`, and `offline-profile.json` as needed. Review each file
    before replacing the version supplied by the new template.
4. Keep the new template's `package.json`, root configuration files,
    `android/`, and `ios/`. Reapply old customizations selectively rather than
    copying these files wholesale.
5. Run `npm install`, `npm run type-check`, and the bundle command for each
    target platform, such as `npm run bundle:android` or `npm run bundle:ios`.
6. Give the resulting errors to GitHub Copilot in Agent mode and ask it to
    update the migrated `app/` and `src/` code for the new template APIs while
    preserving the new template configuration. Review the changes and rerun the
    failing command until the build succeeds.

## Hello world — your first run

After the prereq sanity check passes:

```text
> /create-mobile-app build me a small notes app
```

Expected: ~6 prompts (wizard + gates), then ~5 minutes of scaffolding, table creation, and parallel screen builds. End state: a working Notes app with a project-local Metro session ready to scan and debug.

If creation stops, explicitly ask to continue that creation. The skill checks
the [memory bank](#glossary), saved build-plan progress, and current artifacts,
then confirms the unfinished phase. A plan written before app initialization
is not a completed app. Opening an existing app or asking for a feature change
does not automatically resume creation, even if a memory bank exists.

## Quick examples

The plugin is conversational: slash commands are optional when the agent host
loads the app guidance and advertises the matching skills. Describe the task
naturally, such as "Add signature capture", "Connect a data source", or "Upgrade
this app's dependencies". The agent selects the most specific matching skill by
description and supported scope, then invokes it after any required entry
consent rather than asking you to repeat the prompt as a command.

The intent table in the generated app guidance is examples, not a closed
allowlist. Future or custom skills advertised by your host are eligible too.
An ambiguous scope prompts clarification; a missing plugin requires approval
before installation or enabling. Opening the folder alone starts nothing, and
`edit-app` is not the default for every request. Existing approval gates and
fresh-template safeguards still apply.

There is no extra approval just to select or load a clearly matching skill.
Approvals cover the work: integration scope/cost, Dataverse schema/data changes,
installations, native builds, and deployment. Dataverse workflows validate the
app root and selected environment/tenant, inspect existing inventory, and show
the proposed changes before mutation approval. Missing skills or unresolved
targets block that work instead of falling back to ad-hoc commands. Approval to
install a plugin never authorizes its Dataverse changes; current approvals are
reused only for the same target and scope.

Five typical flows:

### 1. Create a new app from a one-liner

```text
> /create-mobile-app I want a field inspection app where technicians log site visits with photos, GPS location, and notes
```

What happens:
1. **Wizard** (~30s) — confirms device class / aesthetic
2. **Requirements brief** — the orchestrator infers features (data entry, camera, location), pre-checks them, asks you to confirm or adjust
3. **Industry confirmation** — only fires if the inference is shaky (your description matched multiple industries, or none)
4. **Up to 4 approval gates** — data platform + native capabilities + connectors → Dataverse model when selected → screen graph → screen specs (reviewed in markdown before code is written)
5. **Design system** — brand inputs (logo, brand doc, website, or free-text) → cost picker → style picker → component reference sheet → branded screen previews
6. **Scaffold + build** — validates the prepared template folder, runs `pa app init`, verifies installed dependencies, generates schemas, builds Dataverse tables, wires connectors, spawns N parallel screen-builders for the TSX
7. **Dev server** — the plugin starts a portable Metro session; scan the QR with your native dev client and use `/debug-app` against its persisted sanitized log

End state: a working app you can iterate on with hot reload. ~5–12 minutes for the planning gates, then scaffolding runs.

### 2. Add Dataverse tables to an existing app

```text
> /add-dataverse I need an Asset table with name, serial number, and a lookup to an existing Account
```

Or paste an ER diagram (image / Mermaid / text). For an existing app, this first
asks whether to integrate through `/edit-app`, do data-only work, or cancel.
Full integration approves the schema delta and affected screens together.
The data-model-architect checks reuse vs extend vs create before the Dataverse
leaf applies approved operations and regenerates services.

### 3. Add a native capability

```text
> /add-native camera
```

On an existing app, `/add-native` first asks whether to do implementation-only
work, full app integration, or cancel. Only full integration invokes `/edit-app`,
which resolves how the camera will be used, updates the Native Capabilities and
Screens plan, and asks about retention only when needed. It then generates the supported
wrappers/helpers and integrates the approved screen flow. Dataverse schema
changes are conditional, not required for every capture. Native modules must
already ship in the template; no native dependency or permission-config edits.

For other capabilities (only those actually shipped by the template):
```text
> /add-native document-picker   # expo-document-picker wrapper
> /add-native secure-store      # expo-secure-store wrapper
> /add-native file-system       # expo-file-system wrapper
> /add-native sharing           # expo-sharing wrapper
> /add-native haptics           # expo-haptics impact, selection, and notification wrapper
```

Native modules are allowlist-bound by the current template `package.json`. If the relevant package is present, `/add-native` can use it through the proper wrapper or host control. If the package is absent, the skill does not install it or fake support; it adds a transparency note and stops for that capability. For example, push notifications require `expo-notifications`; if the template does not ship it, notifications cannot be added until the upstream template includes it.

### 4. Add a connector

```text
> /add-sharepoint                # SharePoint Online lists / documents
> /add-connector                 # any other Power Platform connector
```

On an existing app, these entry points ask before invoking the fuller, more
costly `/edit-app` workflow. Choose implementation-only work, full integration,
or cancel. Full integration clarifies the operation and consuming screens,
approves the Connectors delta, generates services with `pa app add data-source`,
and wires the intended behavior. Teams/email actions and profile lookups
do not automatically create a Dataverse model. SQL/Excel/SharePoint tables
also stay in the connector plan unless Dataverse storage is separately required.

Choose implementation-only in that question, or use `--implementation-only` (for example,
`/add-native secure-store --implementation-only`) or explicitly request only a
wrapper/service registration. The skill keeps applicable plan entries current,
but leaves screens unchanged and reports that integration was not performed.
When the change is already part of an approved creation/edit workflow, the
extra entry question is skipped. This choice runs before costly app scans or
planners and does not replace mutation/removal approval.

### Data-source planning, refresh, and retirement

Use `/setup-datamodel` or `/add-dataverse` to review and approve a data change.
Add `--plan-only` to preview it without changing the app or its data.

For existing sources, use the dedicated refresh/removal operation:

```text
> /add-dataverse --refresh --data-source-name <registered-name>
> /add-connector --refresh --data-source-name <registered-name>
> /add-sharepoint --remove --data-source-name <registered-name>
```

Refresh updates an existing source without adding it again. Removal stops if
app code still uses the source and never deletes server tables, records, lists,
or connections. For a fully integrated removal, `/edit-app` updates the approved
consumers before retiring their data sources. Offline-profile changes require
separate approval. Cloud-flow integration is not supported.

### 5. Iterate on the generated app after the fact

```text
> /edit-app "Improve the search screen to make it easier to use on mobile"
> /deploy                        # npm run build + pa app push
> /open-wrap-url --app-id <id> --env-id <env-id>   # open make.powerapps.com Wrap page for this app
> /preview-screens               # browser preview of generated screens (no Metro needed)
> /list-connections              # diagnostic when a service call returns 401
> /check-updates                 # ordered dependency updates
> /report-issue                  # copy-paste-ready GitHub issue body
```

Use `/edit-app` for post-generation improvements. Users can invoke it directly
or ask naturally, for example, "This app already exists; add an asset detail
screen." For a natural-language existing-app feature request, the generated app
guidance asks whether the user wants **Implementation only**, **Full app
integration**, or **Cancel**. Full integration invokes `/edit-app` with the
original request; it does not merely recommend the command or ask the user to
repeat the prompt. Reported failures still go to `/debug-app`, dependency or
template upgrades go to `/check-updates`, and small app-owned fixes remain
small.

A fresh starter is not an already-generated app. Native-control requests such
as "Add signature capture" use `/add-native` and its standalone prerequisites;
they do not automatically start `/edit-app` or full app creation. An existing
app with a missing plan is not considered fresh and must not be re-scaffolded.

`/edit-app` first inspects the existing app and asks only for missing intent
details (which screen, table, scanned field, launch point, brand source, etc.).
Then it updates `native-app-plan.md` when the request changes the plan, applies
the generated app edits, runs the relevant verification, updates
`memory-bank.md`, and regenerates `preview.html` when UI changed. You do not
need to manually run `npm run generate-schemas`,
`npx --no-install tsc --noEmit`, or `/preview-screens` after each edit unless
you are doing diagnostics outside the skill.

Common follow-ups:

| Prompt | What `/edit-app` does |
|---|---|
| "Improve the search screen for mobile" | Re-plans/rebuilds the affected search or list screen, then previews. |
| "Add loading, empty, and error states" | Updates the screen spec and TSX state handling, then type-checks. |
| "Add a detail screen for the selected record" | Updates navigation contracts, creates the detail route, and updates the source screen navigation. |
| "Update the design to match branding" | Runs the design refresh/reskin path, rebuilds affected screens when layout grammar changes, then previews. |
| "Add a form to create a new Dataverse record" | Updates plan/data needs, builds the form route and create payload, and verifies generated services. |
| "Add barcode scanning and use the scan value to search" | Adds the native scanner wrapper if supported, updates screen flow, and rebuilds affected screens. |
| "Add a new requirement with a new screen" | Determines whether the feature needs data model, connector, native, or design changes, applies those first, then plans/builds the new screen. |
| "Add a new data source" | Routes through Dataverse, SharePoint, or the generic connector flow, regenerates services, and rebuilds screens only if the request includes UI. |
| "Generate a new static preview" | Runs the preview path without changing source unless the app is stale. |

Example edit flows:

| User prompt | If intent is missing, `/edit-app` asks | Then it runs |
|---|---|---|
| `/edit-app "Add loading, empty and error states to the list screen"` | Which list screen, unless only one exists; whether to improve existing states or add missing ones | Existing screen inspection, screen spec update if needed, targeted TSX rebuild, `tsc`, screen validators |
| `/edit-app "Add a detail screen for the selected record"` | Source list/search screen, table/service, fields/actions, route style | Screen-plan delta, route/layout update, Generated Services snapshot, detail skeleton, detail + source screen builders, route check |
| `/edit-app "Add a form to create a new record in Dataverse"` | Table, required/editable fields, launch point, after-save behavior, lookup/file/image fields | Data-model update via `/add-dataverse` if needed, schema generation, form skeleton, form + parent screen builders, create-payload validation |
| `/edit-app "Add barcode scanning and use the scanned value to search records"` | Scanner location, scanned value meaning, table/service/field to search, no/multiple-match behavior | `/add-native barcode-scanner`, data-model update if target field is missing, scanner/search screen rebuild, static gates, optional `/debug-app` handoff if you report a symptom |
| `/edit-app "Update the design to better match company branding"` | Brand source and scope: palette, typography, components/density, or full reskin | `/design-system --refresh` or `--reskin`, affected screen rebuild when layout grammar changes, style sweep, preview |

## Commands

**For an app problem, try `/debug-app` before reporting an issue.** It can
distinguish local setup/configuration problems from app-code or package defects
and collect useful evidence without assuming a Microsoft package is broken.

```text
/debug-app startup "npm run dev fails before the QR appears"
/debug-app "QR won't open the app"
/debug-app "orders screen is empty"
```

If diagnostics cannot resolve the issue, use `/report-issue` with the sanitized
findings and original reproduction steps. Do not include raw logs or credentials.
A confirmed package defect should be reported rather than patched locally.
This is a recommended first step, not a barrier to an explicit issue-report
request; plugin installation/loading failures may need reporting before any
app-level skill can run.

For startup or QR-opening failures, use `/debug-app startup "<symptom>"` even
when no native app is loaded. It inspects installation/lock consistency, relevant
Node requirements, installed versions, and package entry points before proposing
a repair. Restoring the same locked dependencies and restarting Metro each need
explicit approval; upgrades remain outside this workflow. A successful install
is not an app fix: the original startup or device symptom must be verified.
`--no-fix` performs inspection only. Creation offers this same startup path if
its `npm run dev` launch fails; it does not start indefinite runtime monitoring.

The inspector checks static metadata, not every possible startup cause. When
those checks do not explain the symptom, diagnosis follows the original error
into relevant app scripts/configuration or reports the missing evidence. Clean
metadata alone never means the app is healthy.

| Command | Status | Description |
| --- | --- | --- |
| `/create-mobile-app` | ✅ v0 | Orchestrator — starts from a fresh installed `expo-app-standalone` template folder, gates planning, runs `pa app init`, resolves the selected environment tenant, discovers tenant-visible app registrations and checks the complete required permission profile, lets the user select or create one (or skip auth), then applies data/native/connectors, builds screens, starts dev server |
| `/set-app-registration-native` | ✅ v0 | Auth helper — discovers tenant-visible app registrations, checks the applicable native runtime permission profile, opens the environment-specific Wrap page for creation or repair, and writes the selected client ID to `auth.config.json`. |
| `/add-dataverse` | ✅ v0 | Add Dataverse — connect to existing tables, or create / extend tables in Tier 0 → N order via the Dataverse Web API, then generate TS services. Accepts ER diagrams via image / Mermaid / text, or spawns the data-model-architect agent. |
| `/setup-datamodel` | ✅ v0 | Plan and approve a scoped Dataverse/connector change. Choose data-only work or full `/edit-app` integration; `--plan-only` returns a proposal without applying it. |
| `/add-connector` | ✅ v0 | Generic connector — runs `pa app add data-source` for any first-party or custom connector |
| `/add-native` | ✅ v0 | Add a supported native capability/control (camera, image-picker, barcode/QR scanner, document-picker, PDF viewer/report, pen/signature, secure-store, file-system, sharing, haptics, etc.) — verifies the module already ships in the template and writes typed wrappers under `src/native/` without installing native packages or editing `app.config.js` |
| `/list-connections` | ✅ v0 | Finds or creates a Power Platform connection ID, or resolves a solution connection reference, for `pa app add data-source`. Use when adding non-Dataverse connectors or re-binding after a 401. |
| `/edit-app` | ✅ v0 | Post-generation app editor — updates affected sections of `native-app-plan.md`, applies Dataverse/native/design/connector changes, rebuilds affected screens, runs verification, updates `memory-bank.md`, and regenerates `preview.html` when UI changed. `--plan-only` preserves the old docs-only behavior. |
| `/debug-app` | ✅ v0 | Diagnoses install/startup/QR failures before an app is loaded, then monitors live sanitized `.powernative` logs for runtime or silent failures. Same-lock restoration and Metro restart require explicit approval; it does not upgrade dependencies. `startup` returns without the runtime monitor; `--no-fix` stays non-mutating. |
| `/setup-app-insights` | ✅ v0 | Configure optional customer-owned Application Insights telemetry — discover or accept an existing Azure resource and wire `app.json` → `expo.extra.appInsightsConfig` + `PowerAppsProvider`, change the resource, or disable it. Off by default; invoking it is the opt-in. Also delegated to by `/edit-app`. Never provisions Azure resources or stores the connection string. |
| `/check-updates` | ✅ v0 | Standalone dependency maintenance — checks for a plugin update and restart first, then presents, approves, updates, and validates direct packages one at a time in host, other `@microsoft/*`, and remaining npm package order. |
| `/deploy` | ✅ v0 | Build + push — `npm run build` then `pa app push` to the env in `power.config.json`. **Does not** drive `expo run:ios` or `expo run:android` (out of scope for v0). |
| `/open-wrap-url` | ✅ v0 | Opens the Wrap URL in browser for an app ID using `https://make.powerapps.com/environments/<envID>/wrap?appID=<appID>`. Requires both `--app-id` and `--env-id`. |
| `/report-issue` | ✅ v0 | Read-only diagnostic — collects env / Expo / Node versions, project context, recent errors, and renders a copy-paste-ready GitHub issue body. Sanitizes secrets. |
| `/telemetry` | ✅ v0 | Enable, disable, or show the per-user Mobile Apps telemetry transmission preference. |
| `/design-system` | ✅ v0 | End-to-end design system — collects brand inputs (logo, brand doc, website, free text, canvas app, code app, Figma), runs a 3-style visual picker, writes `brand/design-system.md` + `brand/tokens.ts`, renders branded screen previews. Auto-invoked at Step 6.75 of `/create-mobile-app`; also standalone. |
| `/preview-screens` | ✅ v0 | Renders generated TSX screens as a browser-viewable HTML preview (no Metro needed). Uses Tamagui → HTML mapping. |
| `/add-datasource` | ✅ v0 | Intent-aware entry point for data/action integrations; asks full `/edit-app` integration vs implementation-only, then uses the approved Dataverse/SharePoint/connector leaf. |
| `/add-sharepoint`, `/add-teams`, `/add-office365`, `/add-excel`, `/add-onedrive`, `/add-azuredevops` | 🟡 v1 | Pre-filled wrappers around `/add-connector` |
| `/setup-offline-profile` | 🟡 v0.1 | Create a Dataverse Mobile Offline Profile for the app's tables. One consolidated configuration questionnaire (no per-step approval clicks), schema+screen-aware architect proposal, single `accept` confirm. Writes `offline-profile.json`; never mutates `power.config.json`. The bundled offline package is consumed by the native host for local storage, queued synchronization, reconnect handling, and status UX, so the skill configures the host runtime instead of generating duplicate app-owned offline infrastructure. Offered explicitly by `/create-mobile-app` after Dataverse materialization; connectivity wording in the initial prompt does not auto-enable it. Also runs standalone on existing apps. |
| `/enable-tables-offline` | 🟡 v0.1 | Pre-flight pass — flip `IsAvailableOffline` + `ChangeTrackingEnabled` on selected tables' EntityMetadata, then `PublishAllXml`. Idempotent. Mostly a no-op for fresh scaffolds since `/add-dataverse` Step 5b now sets these flags at create time; primary use case is fixing legacy / imported tables. |
| `/assign-offline-profile` | 🟡 v0.1 | Bind users / teams to a Mobile Offline Profile via `usermobileofflineprofilemembership` / `teammobileofflineprofilemembership` rows. Without this, the profile exists but no one's app uses it. Accepts `--user <upn>`, `--team <name>`, `--me`, `--all-app-users`, `--unassign-*` flags. |
| `/edit-offline-profile` | 🟡 v0.1 | Change ONE aspect of an existing profile (table scope, sync frequency, column list, name/description) without re-running the full wizard. Mirrors the `/edit-app` gated edit pattern. Accepts `--rename`, `--table X --scope`, `--table X --sync`, `--table X --columns add:/remove:/reset` flags. |
| `/add-table-to-offline-profile` | 🟡 v0.1 | Add ONE new table to an existing profile (typically after running `/add-dataverse` to extend the data model). Auto-enables table prereqs; single scope-picker question; POST item + PATCH selectedcolumns + publish. `--all-new` for bulk-adding every manifest table not yet in the profile. |
| `/preview-offline-scope` | 🟡 v0.1 | Read-only diagnostic. Per-table row count + cache-size estimate + sync-cost forecast. Useful before `/assign-offline-profile` (so users don't get surprised by data caps) and after `/edit-offline-profile` to gauge impact. Wraps `verify-offline-profile.js` with row-count probes. |

## Agents

| Agent | Role |
| --- | --- |
| `native-app-planner` | Orchestrator — approves data platform + native capabilities + connectors, conditionally coordinates the data-model architect, coordinates screen planning, and runs up to 4 approval gates |
| `data-model-architect` | Read-only — discovers Dataverse, scores reuse / extend / create, returns an ER section |
| `screen-planner` | Read-only — picks navigation pattern, designs per-screen specs |
| `screen-builder` | Mutation — writes ONE TSX file per assigned screen, runs N in parallel |
| `offline-profile-architect` | Read-only — proposes per-table row scope, relationships, selected columns, sync frequency; returns `_offline_section.md` for `/setup-offline-profile` to embed in `native-app-plan.md` |

## Telemetry and privacy

The Mobile Apps plugin sends usage and measured workflow telemetry to Microsoft by default. Events can include skill and checkpoint names, plugin/agent/OS/Node versions, random app/run/span/event IDs, measured durations, outcomes, retry attempts, and fixed error classifications. When verified target metadata is available, events can also include Power Platform environment and Entra tenant IDs plus the Dataverse organization ID.

Events never include Entra user/object IDs, Dataverse user IDs, prompts, arguments, tool inputs, business records, document contents, file paths, cwd, app/site names, URLs, cr...

© Microsoft · MIT · microsoft/power-platform-skills

Similar plugins

All plugins for Mobile →

From the same set157

The whole set →
setup-auth setup-auth sets up sign-in, sign-out, and role-aware UI for a Power Pages SPA. Use it to connect an identity provider and wire its settings into the site. CX Codex +1 ★ 1,167repo stars process-intelligence process-intelligence pulls Power Automate Process Mining data over MCP to find bottlenecks, compare variants and cohorts, and dig into rework. ★ 1,167repo stars power-automate Connects Claude Code to Power Automate cloud flows via the bundled FlowAgent MCP engine. Useful for editing flow actions, diagnosing run failures, and copying flows across environments. ★ 1,167repo stars power-apps-mobile-extension power-apps-mobile-extension is a Claude Code plugin for designing and building native Power Apps Mobile controls as .ppmplugin bundles, with matching PCF controls for Canvas apps. ★ 1,167repo stars code-apps-preview code-apps-preview is a Claude Code plugin for scaffolding, building, and deploying Power Apps with React, Vite, and Power Platform connectors. ★ 1,167repo stars canvas-apps canvas-apps is a Claude Code plugin that connects the agent to an app open in Power Apps Studio, where it can build or edit screens, controls, and formulas. ★ 1,167repo stars mcp-apps mcp-apps writes the server runtime for a codeful MCP tool, its JSON registration sidecar, and an HTML widget that shows the results — with or without CDN libraries. ★ 1,167repo stars pcf Build, test, deploy, and audit PCF components for Power Apps. Assists with controls for model-driven, canvas, and Power Pages projects. ★ 1,167repo stars

Project sponsors

Companies that keep this analytics open