Documentation / codeappjs / Overview

Overview

Power Apps Code Apps — JavaScript

Power Apps empowers developers of all skill sets, including those building web apps in integrated developer environments (IDEs) like Visual Studio Code, to efficiently build and run business apps on a managed platform.

Code apps let developers bring Power Apps capabilities into custom web apps built in a code‑first IDE. You can develop locally and run the same app in Power Platform. Build with popular frameworks (React, Vue, and others) while keeping full control over your UI and logic.

Key features include:

Microsoft Entra authentication and authorization
Access to Power Platform data sources and 1,500+ connectors, callable directly from JavaScript
Easy publishing and hosting of line-of-business web apps in Power Platform
Adherence to your organization's Managed Platform policies (app sharing limits, Conditional Access, Data Loss Prevention, and so on)
Simplified deployment and application lifecycle management (ALM)

The managed platform accelerates safe, rapid innovation, and when ready, apps can be deployed to dedicated production environments.

Code Apps by default use React. CodeAppJs replaces React with vanilla JavaScript.

How to Start

Demo Solutions

Full App Solutions

Folder setup

Starter app files and power.config.json explained

codeapp/

codeApp folder

File	Purpose
`power.config.json`	Main app manifest for display name, environment, build output, connection references, and Dataverse sources.
`dist/index.html`	Bootstraps the app shell, sets the import map for `@microsoft/power-apps/data`, and loads `index.js`.
`dist/index.js`	Default JavaScript entry point where app startup logic lives.
`dist/codeapp.js`	Shared runtime helper for environment variables, Dataverse actions, and connector plumbing.
`dist/connectors/`	Connector specific files that enable integration with various services.
`dist/power-apps-data.js`	Bundled SDK runtime copied from the npm package for browser use inside the starter app.
`agent/`	Optional development folder that stores agent-specific files and schemas.

power.config.json

Generated files

src/generated and .power/ directories

Running pac code add-data-source generates typed connector files under src/generated/ and .power/. Both folders are designed for standard CodeApp React based development. They can help with some LLM models during AI development but in most cases can be ignored.

Path	Purpose
`src/generated/index.ts`	Barrel export that re-exports generated model namespaces and service classes for every added connector.
`src/generated/models/*.ts`	Generated request/response types, enums, and metadata interfaces for each connector (Outlook, Users, Groups, Jira, Key Vault).
`src/generated/services/*.ts`	Generated static service wrappers that call `getClient(dataSourcesInfo)` and expose typed connector operations.
`.power/`	PAC CLI internal metadata directory. Contains platform configuration such as schemas and should be committed alongside the project.

power.config.json keys

Top-level keys in the starter config

Key	What it does
`appId`	The unique identifier for the app (not required for first deployment).
`appDisplayName`	The name shown for the app when it is deployed.
`description`	Short app description for documentation and deployment metadata.
`environmentId`	The target Power Platform environment id used when pushing the app.
`buildPath`	The folder PAC packages and deploys. In the starter app this is `./dist`.
`buildEntryPoint`	The HTML file PAC treats as the app entry file, usually `index.html`.
`logoPath`	Path or placeholder for the app icon used in deployment metadata.
`localAppUrl`	The local URL used during development. Update it to match the server you actually use.
`region`	The Power Platform region, shown here as `prod` in the starter config.
`connectionReferences`	Connector bindings such as Dataverse, Outlook, SharePoint, Groups, Users, Teams, Jira, Key Vault, Power Platform Admin V2, or SQL.
`databaseReferences`	Dataverse table declarations used to generate service and model code.

connectionReferences shape

id is the connector API path such as shared_office365 or shared_sharepointonline.
displayName is the label shown for the connector.
dataSources contains the connector names the runtime expects.
dataSets, authenticationType, and sharedConnectionId are available when needed by the connection.

databaseReferences shape

default.cds is the Dataverse container used by the examples.
dataSources maps table aliases to entitySetName and logicalName.
isHidden controls whether a data source is hidden.
actions and databaseDetails appear when the config includes them.

CLI tools

The repo workflow is npm plus PAC CLI

CAP CLI v1.2.1

Repo commands

npm install
npm start
npm run start:codeapp

`npm install` rebuilds local `power-apps-data.js` files from the published SDK package so samples stay aligned with npm.

PAC commands

pac auth create
pac auth list
pac env select --environment "environment-id"
pac connection list
pac connection create --name "connection-name" --application-id "app-id" --client-secret "secret" --tenant-id "tenant-id"
pac code add-data-source -a "connection-name" -c "connection-id"
pac code add-data-source -a "dataverse" -c "table"
pac code push --solutionName YourSolutionName
npx power-apps list-flows
npx power-apps add-flow --flow-id <flow-id>
npx power-apps push

The readme makes PAC the deployment path, with auth, environment selection, connection creation, data source registration, and app push as the core flow.

CAP CLI

cap environment-variable --name "Service Settings" --publisher-prefix wd --value '{"url":"https://example.com"}'

Create an environment variable without interactive prompts. Use --environment <url|id> to override the configured environment. environmentvariable and envvar are supported aliases.

Command guide

What each command is for

Command	Use
npm install	Install dependencies and rebuild browser SDK files used by the starter app and examples.
npm start	Serve the whole repo on port 4173 so samples can be opened directly.
npm run start:codeapp	Open straight to the starter app under `codeApp/dist/`.
pac auth create	Create a login profile against a Power Platform environment.
pac env select	Choose the active environment profile for later PAC commands.
pac connection list	Inspect the connector connections available in the selected environment.
pac code add-data-source	Add connector or Dataverse source details used by the app.
pac code push / npx power-apps push	Package and deploy the app build output into the target solution (npx for apps calling Power Automate).
cap environment-variable	Create an environment variable non-interactively, optionally targeting a specific environment by URL or ID.

Debugger

Debug code apps with browser dev tools

codeapp.js

Debugging

To support debugging, all API interactions can be shown in a debug panel.
Enabling debugger will add a small button in the top right of the app.
Clicking will open the panel with detailed information about API calls and responses.
Each response can be copied to clipboard by clicking the copy icon

Enable Debugging

import { enableDebugger } from './codeapp.js';
enableDebugger();

Manual Debug

The debugger can be used for none api calls, like a console.log.


code_dbgWrap(
  'debugNote',
  [{ message: 'resolved list from cache' }],
  () => {
    return null;
  }
);

Debug Formatter

To view long debugger responses easier, use the debug formatter.
Open JSON Viewer

Environment variables

Read Dataverse environment variables through the generic codeapp.js Dataverse APIs

codeapp.js & Dataverse

Setup workflow

Create the environment variables in the maker portal under Solutions > Environment Variables.
Use the real Dataverse schema names when wiring the app. Do not invent or guess them.
Add both environment variable tables to `databaseReferences.default.cds.dataSources` in `power.config.json`.
Register `environmentvariabledefinitions` and `environmentvariablevalues`, then query them with the same Dataverse helpers used for any other table.

Table roles

`environmentvariabledefinition` stores the schema name, default value, and variable type metadata.
`environmentvariablevalue` stores the current environment-specific value and links back to the definition.
If a value row exists, use that first. If it does not, fall back to the definition row's `defaultvalue`.
The app reads the Dataverse tables at runtime. There is no separate `environmentVar.js` file in this repo anymore.

Required Dataverse tables

Add both environment variable tables to the Dataverse data source map

{
  "databaseReferences": {
    "default.cds": {
      "dataSources": {
        "environmentvariabledefinitions": {
          "entitySetName": "environmentvariabledefinitions",
          "logicalName": "environmentvariabledefinition",
          "isHidden": false
        },
        "environmentvariablevalues": {
          "entitySetName": "environmentvariablevalues",
          "logicalName": "environmentvariablevalue",
          "isHidden": false
        }
      }
    }
  }
}

Generic Dataverse read pattern

import { registerTable, listItems } from './codeapp.js';

registerTable('environmentvariabledefinitions', 'environmentvariabledefinitionid');
registerTable('environmentvariablevalues', 'environmentvariablevalueid');

async function loadEnvironmentVariable(sSchemaName) {
  const { entities: aDefinitions } = await listItems(
    'environmentvariabledefinitions',
    'environmentvariabledefinitionid',
    {
      filter: "schemaname eq '" + sSchemaName + "'",
      select: ['environmentvariabledefinitionid', 'schemaname', 'defaultvalue', 'type'],
      top: 1
    }
  );

  const oDefinition = aDefinitions[0];
  if (!oDefinition) {
    throw new Error('Environment variable not found: ' + sSchemaName);
  }

  const { entities: aValues } = await listItems(
    'environmentvariablevalues',
    'environmentvariablevalueid',
    {
      filter: '_environmentvariabledefinitionid_value eq ' + oDefinition.environmentvariabledefinitionid,
      select: ['value'],
      top: 1
    }
  );

  return aValues[0]?.value || oDefinition.defaultvalue || '';
}

This mirrors the Dataverse table relationship directly: definition first, value second, then default fallback.

Connections

Generated connector sources plus runtime helper examples

dist/connectors/

Required CLI step

pac code add-data-source -a "connection-name" -c "connection-id"

Run `pac code add-data-source` after creating the connector connection. PAC uses the selected connector metadata to generate typed source files under `src/generated` for connectors such as Outlook, Office 365 Users, and Office 365 Groups.

When generated files are needed

Generated connector files are the source of truth for operation names, parameter shapes, and return models for Microsoft 365 connectors.
Dataverse, SharePoint, Teams, Jira, and Azure Key Vault do not need these generated `src/generated` files in this repo because they already use handwritten helpers and configuration-based runtime support.
Power Platform Admin V2 uses the generated dist/connectors/powerplatformadminv2.js wrapper as its operation and parameter source of truth.
For generated connectors, keep the PAC output aligned with the connection metadata instead of hardcoding operation paths yourself.

Generated source overview

File	Purpose
`src/generated/index.ts`	Barrel export that re-exports the generated model namespaces and service classes for every added connector.
`src/generated/models/Office365OutlookModel.ts`	Generated Outlook request and response types, enums, and metadata interfaces used by the Outlook service methods.
`src/generated/services/Office365OutlookService.ts`	Generated static service wrapper that calls `getClient(dataSourcesInfo)` and exposes typed Outlook connector operations through `executeAsync`.
`src/generated/models/Office365UsersModel.ts`	Generated user profile, people, document, and photo types returned by the Office 365 Users connector.
`src/generated/services/Office365UsersService.ts`	Generated service class with typed methods such as `MyProfile_V2`, `SearchUserV2`, and other Office 365 Users operations.
`src/generated/models/Office365GroupsModel.ts`	Generated interfaces for group lists, membership payloads, calendar requests, and other Office 365 Groups connector shapes.
`src/generated/services/Office365GroupsService.ts`	Generated service class with typed wrappers for group membership, events, and HTTP request operations exposed by the connector.
`src/generated/models/AzureKeyVaultModel.ts`	Generated interfaces for Azure Key Vault secrets, keys, and certificates.
`src/generated/services/AzureKeyVaultService.ts`	Generated service class with typed wrappers for Azure Key Vault operations.
`src/generated/models/JiraModel.ts`	Generated interfaces for Jira issues, projects, and other Jira connector shapes.
`src/generated/services/JiraService.ts`	Generated service class with typed wrappers for Jira operations.

Connection Reference

"connectionReferences": {
  "dataverse": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps",
    "displayName": "Microsoft Dataverse",
    "dataSources": ["commondataserviceforapps"],
    "authenticationType": null,
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

`dist/dataverse.js` registers tables before the first SDK call and reuses a shared client.
The skill file also requires matching `databaseReferences.default.cds.dataSources` entries for every table you touch.
Use entity set names such as `cr_contacts` in code, not display names.

Public Helper Surface

All exported Dataverse and shared helpers

enableDebugger() - enableDebugger();
getEnvironmentVariable(schemaName) - const sSite = await getEnvironmentVariable('wd_sharepointsite');
registerTable(tableName, primaryKey) - registerTable('cr_contacts', 'cr_contactid');
createItem(tableName, primaryKey, record) - await createItem('cr_contacts', 'cr_contactid', { cr_name: 'Jane Doe' });
getItem(tableName, primaryKey, id, select) - await getItem('cr_contacts', 'cr_contactid', sContactId, ['cr_name', 'createdon']);
listItems(tableName, primaryKey, options) - await listItems('cr_contacts', 'cr_contactid', { filter: "cr_name eq 'Jane Doe'", select: ['cr_name'], top: 5 });
updateItem(tableName, primaryKey, id, changedFields) - await updateItem('cr_contacts', 'cr_contactid', sContactId, { cr_name: 'Jane Smith' });
deleteItem(tableName, primaryKey, id) - await deleteItem('cr_contacts', 'cr_contactid', sContactId);
callUnboundAction(tableName, primaryKey, actionName, params) - await callUnboundAction('', '', 'GrantAccess', oParams);
whoAmI() - const sUserId = await whoAmI();

The Dataverse helper does not define a fixed action map like the managed connectors. Instead it wraps generic CRUD plus custom unbound actions over the configured tables in databaseReferences.

Connection Reference

"connectionReferences": {
  "sharepointonline": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_sharepointonline",
    "displayName": "SharePoint",
    "dataSources": ["sharepointonline"],
    "authenticationType": null,
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

sharepoint.js now exposes request helpers, list-id helpers, by-list helpers, attachment helpers, and file helpers.
The preferred pattern is resolveSharePointList(...) once, then use the by-list helpers for CRUD and attachments.
Pass the plain site URL to the dedicated helpers. The wrapper encodes it internally, and sendHttpRequest(...) / sendOpenHttpRequest(...) cover the raw connector request paths when needed.

Public Helper Surface

Current exports in sharepoint.js

Core and discovery
Example: const oListAccess = await resolveSharePointList('https://contoso.sharepoint.com/sites/demo', { listName: 'Tasks' });
callSharePointOperation(operationName, parameters) - await callSharePointOperation('GetDataSetsMetadata', { siteUrl: encodeURIComponent('https://contoso.sharepoint.com/sites/demo') });
sendHttpRequest(siteUrlOrRequest, requestOptions) - await sendHttpRequest('https://contoso.sharepoint.com/sites/demo', { method: 'GET', uri: '/_api/web/lists?$select=Title,Id' });
sendOpenHttpRequest({ siteUrl, method, uri, headers, body }) - await sendOpenHttpRequest({ siteUrl: 'https://contoso.sharepoint.com/sites/demo', method: 'GET', uri: '/_api/web?$select=Title' });
listTables(siteUrl) - await listTables('https://contoso.sharepoint.com/sites/demo');
listLibrary(siteUrl, libraryId, queryOptions) - await listLibrary('https://contoso.sharepoint.com/sites/demo', 'ecf7e0c2-b862-469a-9eee-8a4aba5395ba', { top: 20 });
resolveSharePointList(siteUrl, listReference) - const oListAccess = await resolveSharePointList('https://contoso.sharepoint.com/sites/demo', { listId: '12345678-abcd-1234-abcd-123456789012', listName: 'Tasks' });
listTables(siteUrl) only returns custom lists. Use listLibrary(...) with a document library GUID or call getItems(...) directly with the library name or GUID when you need library items.
List-id helpers
Example: await getItems('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', { top: 20 });
getItems(siteUrl, listId, options) - await getItems('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', { top: 20, orderBy: 'Modified desc' });
getSpItem(siteUrl, listId, itemId) - await getSpItem('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', 42);
createSpItem(siteUrl, listId, fields) - await createSpItem('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', { Title: 'New task' });
createSpItemAttachment(siteUrl, listId, itemId, displayName, fileContent, optionsOrContentType) - await createSpItemAttachment('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', 42, 'notes.txt', 'Draft notes', 'text/plain');
getSpItemAttachments(siteUrl, listId, itemId) - await getSpItemAttachments('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', 42);
getSpItemAttachmentContent(siteUrl, listId, itemId, attachmentId) - await getSpItemAttachmentContent('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', 42, '8');
deleteSpItemAttachment(siteUrl, listId, itemId, attachmentId) - await deleteSpItemAttachment('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', 42, '8');
updateSpItem(siteUrl, listId, itemId, changedFields) - await updateSpItem('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', 42, { Status: 'Done' });
deleteSpItem(siteUrl, listId, itemId) - await deleteSpItem('https://contoso.sharepoint.com/sites/demo', '12345678-abcd-1234-abcd-123456789012', 42);
By-list and attachment helpers
Example: await createSpItemByList('https://contoso.sharepoint.com/sites/demo', oListAccess, { Title: 'Task from resolved list' });
getItemsByList(siteUrl, listReference, queryOptions) - await getItemsByList('https://contoso.sharepoint.com/sites/demo', oListAccess, { top: 200 });
getSpItemByList(siteUrl, listReference, itemId) - await getSpItemByList('https://contoso.sharepoint.com/sites/demo', { listName: 'Tasks' }, 42);
createSpItemByList(siteUrl, listReference, fields) - await createSpItemByList('https://contoso.sharepoint.com/sites/demo', oListAccess, { Title: 'Task from resolved list' });
createSpItemAttachmentByList(siteUrl, listReference, itemId, displayName, fileContent, optionsOrContentType) - await createSpItemAttachmentByList('https://contoso.sharepoint.com/sites/demo', oListAccess, 42, 'notes.txt', 'Draft notes', 'text/plain');
getSpItemAttachmentsByList(siteUrl, listReference, itemId) - await getSpItemAttachmentsByList('https://contoso.sharepoint.com/sites/demo', oListAccess, 42);
getSpItemAttachmentContentByList(siteUrl, listReference, itemId, attachmentId) - await getSpItemAttachmentContentByList('https://contoso.sharepoint.com/sites/demo', oListAccess, 42, '8');
deleteSpItemAttachmentByList(siteUrl, listReference, itemId, attachmentId) - await deleteSpItemAttachmentByList('https://contoso.sharepoint.com/sites/demo', oListAccess, 42, '8');
updateSpItemByList(siteUrl, listReference, itemId, changedFields) - await updateSpItemByList('https://contoso.sharepoint.com/sites/demo', oListAccess, 42, { Status: 'Blocked' });
deleteSpItemByList(siteUrl, listReference, itemId) - await deleteSpItemByList('https://contoso.sharepoint.com/sites/demo', oListAccess, 42);
Files and libraries
Example: await createRawFile('https://contoso.sharepoint.com/sites/demo', '/Shared Documents', 'list.schema.json', jsonSchemaText);
createFile(siteUrl, folderPath, fileName, fileContent, optionsOrContentType) - await createFile('https://contoso.sharepoint.com/sites/demo', '/Shared Documents', 'notes.txt', 'Draft notes', 'text/plain');
createRawFile(siteUrl, folderPath, fileName, fileContent) - await createRawFile('https://contoso.sharepoint.com/sites/demo', '/Shared Documents', 'list.schema.json', jsonSchemaText);
createBinaryFile(siteUrl, folderPath, fileName, base64Content, contentType) - await createBinaryFile('https://contoso.sharepoint.com/sites/demo', '/Shared Documents', 'diagram.png', sBase64Png, 'image/png');
createBase64File(siteUrl, folderPath, fileName, base64Content, contentType) - await createBase64File('https://contoso.sharepoint.com/sites/demo', '/Shared Documents', 'report.pdf', sBase64Pdf, 'application/pdf');
createByteFile(siteUrl, folderPath, fileName, byteContent, contentType) - await createByteFile('https://contoso.sharepoint.com/sites/demo', '/Shared Documents', 'data.bin', aBytes, 'application/octet-stream');
createBlobFile(siteUrl, folderPath, fileName, fileContent, contentType) - await createBlobFile('https://contoso.sharepoint.com/sites/demo', '/Shared Documents', 'upload.json', oBlob, 'application/json');
updateFile(siteUrl, fileId, fileContent, optionsOrContentType) - await updateFile('https://contoso.sharepoint.com/sites/demo', '01ABCDEF234567...', 'Updated notes', 'text/plain');
deleteFile(siteUrl, fileId) - await deleteFile('https://contoso.sharepoint.com/sites/demo', '01ABCDEF234567...');
moveFile(siteUrl, sourceFileId, destinationFolderPath, newFileName) - await moveFile('https://contoso.sharepoint.com/sites/demo', '01ABCDEF234567...', '/Shared Documents/Archive', 'notes-archive.txt');
getFileMetadata(siteUrl, fileId) - await getFileMetadata('https://contoso.sharepoint.com/sites/demo', '01ABCDEF234567...');
getFileContent(siteUrl, fileId) - await getFileContent('https://contoso.sharepoint.com/sites/demo', '01ABCDEF234567...');

Use resolveSharePointList(...) when you know a list id or list name and want the wrapper to resolve the connector table token once. Use sendHttpRequest(...) for site-scoped SharePoint REST calls, sendOpenHttpRequest(...) for absolute or site-relative open requests, and callSharePointOperation(...) only when you already know the raw connector action and parameter shape.

const oListAccess = await resolveSharePointList('https://contoso.sharepoint.com/sites/demo', {
  listId: '12345678-abcd-1234-abcd-123456789012',
  listName: 'Tasks'
});

const aItems = await getItemsByList(oListAccess.sSiteUrl, oListAccess, { top: 200 });
await createSpItemByList(oListAccess.sSiteUrl, oListAccess, { Title: 'New item' });
await createSpItemAttachmentByList(oListAccess.sSiteUrl, oListAccess, 1, 'notes.txt', 'Draft notes', 'text/plain');
await updateSpItemByList(oListAccess.sSiteUrl, oListAccess, 1, { Title: 'Updated item' });
const oSiteInfo = await sendHttpRequest(oListAccess.sSiteUrl, {
  method: 'GET',
  uri: '/_api/web?$select=Title'
});

Supported Raw Actions

All SharePoint connector actions wired by the wrapper

GetItems
GetItem
PostItem
PatchItem
DeleteItem
GetItemAttachments
CreateAttachment
DeleteAttachment
GetAttachmentContent
GetTables
GetDataSetsMetadata
CreateFile (also used by createRawFile(...))
UpdateFile
DeleteFile
MoveFile
GetFileMetadata
GetFileContent
HttpRequest
OpenHttpRequest

callSharePointOperation(...) can invoke the actions above. createRawFile(...) is not a separate connector action; it is a helper that calls CreateFile while preserving raw string content. sendHttpRequest(...) routes to HttpRequest for site-scoped calls and to OpenHttpRequest for open requests, while sendOpenHttpRequest(...) always uses the open variant.

Bookmarklet

Use the SharePoint bookmarklet to capture list schema

sharepoint bookmarklet.js

javascript:(async()=>{if(typeof _spPageContextInfo==="undefined"||!_spPageContextInfo.listTitle||!_spPageContextInfo.listId){alert("Please run this on a SharePoint List or Library page.");return;}const listId=_spPageContextInfo.listId.replace(/[{}]/g,"");const r=await fetch(`${_spPageContextInfo.webAbsoluteUrl}/_api/web/lists/getbytitle('${_spPageContextInfo.listTitle}')/fields?$filter=Hidden eq false and ReadOnlyField eq false`,{headers:{Accept:"application/json; odata=verbose"}});const d=await r.json();const s={listName:_spPageContextInfo.listTitle,listId:listId,extractDate:new Date().toISOString(),columns:d.d.results.map(f=>({name:f.Title,internal:f.InternalName,type:f.TypeAsString,required:f.Required}))};const j=JSON.stringify(s,null,2);console.log(j);await navigator.clipboard.writeText(j);alert("JSON Schema copied to clipboard!");})();

How to create the bookmarklet

Create a new browser bookmark in Edge or Chrome.
Name it something obvious like SP Schema.
Paste the full javascript:(async()=>...) code into the bookmark URL field.
Open a SharePoint list or library page, then click the bookmark.
The script copies a JSON payload with the list name, list id, and visible writable columns to your clipboard.
Paste that output into codeApp/agent/list.schema.json so it stays with the app as local agent context.

Why this helps the AI agent

The bookmarklet captures the real SharePoint internal column names, which are what CRUD payloads actually need.
It also records field types and required flags, so the agent can generate safer createSpItem and updateSpItem examples without guessing.
Saving it as codeApp/agent/list.schema.json gives the agent a stable local schema file to read when scaffolding forms, filters, table columns, and validation logic.
That usually avoids the most common SharePoint mistakes: using display names instead of internal names, missing required fields, and sending the wrong payload shape.

Typical saved file

{
  "listName": "Tasks",
  "listId": "12345678-abcd-1234-abcd-123456789012",
  "extractDate": "2026-04-24T12:34:56.000Z",
  "columns": [
    {
      "name": "Title",
      "internal": "Title",
      "type": "Text",
      "required": true
    }
  ]
}

Connection Reference

"connectionReferences": {
  "<uuid>": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_logicflows",
    "displayName": "Logic flows",
    "dataSources": ["ApprovalWorkflow"],
    "authenticationType": null,
    "sharedConnectionId": null,
    "dataSets": {},
    "workflowDetails": {
      "workflowDisplayName": "Approval Workflow",
      "workflowName": "<flow-id>"
    }
  }
}

Flow Setup

Use the newer npm-based CLI commands such as npx power-apps list-flows, npx power-apps add-flow --flow-id <flow-id> and npx power-apps push, or add the flow by using the Code Apps VS Code extension.
pac code does not expose the flow commands, and Code Apps Plus is not yet compatible with the flow add/remove workflow.
Only solution-aware instant flows that use the Power Apps trigger are supported.

More information can be found here: Add Power Automate flows to a code app.

Public Helper Surface

Runtime helper for calling Power Automate flows

callFlow(flowTarget, input, options) - await callFlow('ApprovalWorkflow', { requester: 'Alex', amount: 1500 });
flowTarget can be a string data source name, an array of candidate data source names, or an object with dataSourceName, flowName, and dataSourceCandidates.
options supports apiVersion and raw parameters. Pass undefined for input when the flow trigger has no custom inputs.

callFlow(...) expects the flow data source name from power.config.json connectionReferences.*.dataSources[0], not the connection reference UUID key or the display name. Generated flow services created by add-flow call the same Run operation; this helper is the handwritten equivalent exposed by codeapp.js.

await callFlow('ApprovalWorkflow', {
  requester: 'Alex',
  amount: 1500
});

await callFlow(
  {
    dataSourceName: 'ApprovalWorkflow',
    dataSourceCandidates: ['ApprovalWorkflow', 'SendNotification']
  },
  undefined,
  {
    apiVersion: '2015-02-01-preview'
  }
);

Supported Raw Actions

Flow operation wired by the wrapper

Run

The wrapper posts to /{connectionId}/triggers/manual/run and injects api-version automatically unless you override it in options. Re-run npx power-apps add-flow --flow-id <flow-id> when a flow definition changes so generated models and connection metadata stay aligned.

Connection Reference

"connectionReferences": {
  "Office365Outlook": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_office365",
    "displayName": "Office 365 Outlook",
    "dataSources": ["Office365Outlook"],
    "authenticationType": null,
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

`dist/outlook.js` currently uses `DATA_SOURCE = 'Office365Outlook'` with handwritten helper wrappers.
The skill file anchors the connector id to `shared_office365` and recommends generated metadata as the source of truth for paths and parameters.
The helper covers both mail and calendar actions, not just inbox reads.

Mail Helpers

Every exported mail helper

callOutlookOperation(operationName, parameters) - await callOutlookOperation('ContactPatchItem_V2', { folder: 'Contacts', id: sContactId, item: { GivenName: 'Alex' } });
sendEmail(oOptions) - await sendEmail({ to: 'alex@contoso.com', subject: 'Weekly summary', body: '<p>Status attached.</p>' });
getEmail(messageId, oOptions) - await getEmail(sMessageId, { includeAttachments: true });
draftEmail(oOptions) - await draftEmail({ to: 'alex@contoso.com', subject: 'Draft status', body: 'Review this first.' });
updateDraftEmail(messageId, oOptions) - await updateDraftEmail(sDraftId, { subject: 'Updated subject', body: 'Revised content.' });
sendDraftEmail(messageId) - await sendDraftEmail(sDraftId);
forwardEmail(messageId, oOptions) - await forwardEmail(sMessageId, { to: 'team@contoso.com', comment: 'Please review.' });
replyToEmail(messageId, oOptions) - await replyToEmail(sMessageId, { comment: 'Received, thanks.', replyAll: true });
listEmails(oOptions) - await listEmails({ folderId: 'Inbox', top: 10, fetchOnlyUnread: true, searchQuery: 'from:alex' });
sendFromSharedMailbox(sharedMailbox, oOptions) - await sendFromSharedMailbox('support@contoso.com', { to: 'customer@contoso.com', subject: 'Case update', body: 'We have an update.' });
moveEmail(messageId, destinationFolderId, oOptions) - await moveEmail(sMessageId, 'Archive');
deleteEmail(messageId, oOptions) - await deleteEmail(sMessageId, { mailboxAddress: 'shared@contoso.com' });
markEmailAsRead(messageId, oOptions) - await markEmailAsRead(sMessageId, { isRead: true });
updateEmailFlag(messageId, oOptions) - await updateEmailFlag(sMessageId, { flagStatus: 'flagged' });
getEmailAttachment(messageId, attachmentId, oOptions) - await getEmailAttachment(sMessageId, sAttachmentId, { mailboxAddress: 'shared@contoso.com' });
listOutlookCategories() - await listOutlookCategories();
assignOutlookCategory(messageId, category) - await assignOutlookCategory(sMessageId, 'Blue category');
assignOutlookCategoryBulk(messageIds, categoryName) - await assignOutlookCategoryBulk([sMessageId1, sMessageId2], 'Follow up');
callOutlookHttpRequest({ uri, method, body, contentType, customHeaders }) - await callOutlookHttpRequest({ method: 'GET', uri: 'https://graph.microsoft.com/v1.0/me/messages?$top=5' });
manageOutlookEmails(queryRequest, sessionId) - await manageOutlookEmails({ prompt: 'Summarize unread email from today' }, 'session-1');

Calendar Helpers

Events, calendars, rooms, and meeting suggestions

createEvent(oOptions) - await createEvent({ subject: 'Sprint review', start: '2026-03-14T16:00:00Z', end: '2026-03-14T17:00:00Z', attendees: ['alex@contoso.com'] });
listEvents(oOptions) - await listEvents({ calendarId: 'Calendar', top: 10, orderBy: 'start/dateTime asc' });
editEvent(eventId, changedFields, calendarId) - await editEvent(sEventId, { location: 'Room 301', body: 'Updated agenda' }, 'Calendar');
deleteEvent(eventId, calendarId, oOptions) - await deleteEvent(sEventId, 'Calendar');
listCalendars(oOptions) - await listCalendars({ top: 25, orderBy: 'name asc' });
getEvent(eventId, calendarId, oOptions) - await getEvent(sEventId, 'Calendar');
getCalendarView(oOptions) - await getCalendarView({ calendarId: 'Calendar', startDateTimeUtc: '2026-04-01T00:00:00Z', endDateTimeUtc: '2026-04-02T00:00:00Z' });
respondToEventInvite(eventId, response, oOptions) - await respondToEventInvite(sEventId, 'accept', { comment: 'See you there.' });
listRoomLists() - await listRoomLists();
listRooms() - await listRooms();
listRoomsInRoomList(roomList) - await listRoomsInRoomList('building1@contoso.com');
findMeetingTimes(oRequest) - await findMeetingTimes({ attendees: ['alex@contoso.com'], timeConstraint: { activityDomain: 'work' } });
setAutomaticReplies(oSettings) - await setAutomaticReplies({ automaticRepliesSetting: { status: 'alwaysEnabled', internalReplyMessage: 'On leave' } });
getMailTips(oRequest) - await getMailTips({ mailboxAddress: 'alex@contoso.com' });
manageOutlookMeetings(queryRequest, sessionId) - await manageOutlookMeetings({ prompt: 'Find a 30 minute slot tomorrow afternoon' }, 'session-1');

Contact Helpers

Contact folder CRUD, including ContactPatchItem_V2

listContactFolders() - await listContactFolders();
listContacts(folderId, oOptions) - await listContacts('Contacts', { top: 25, orderBy: 'displayName asc' });
getContact(folderId, contactId, oOptions) - await getContact('Contacts', sContactId);
createContact(folderId, contact) - await createContact('Contacts', { GivenName: 'Alex', Surname: 'Wilber', EmailAddresses: [{ Address: 'alex@contoso.com' }] });
updateContact(folderId, contactId, contact) - await updateContact('Contacts', sContactId, { GivenName: 'Alex', CompanyName: 'Contoso' });
deleteContact(folderId, contactId, oOptions) - await deleteContact('Contacts', sContactId);
manageOutlookContacts(queryRequest, sessionId) - await manageOutlookContacts({ prompt: 'Find contacts at Contoso' }, 'session-1');

Supported Raw Actions

All Office365Outlook connector actions wired by the wrapper

CalendarGetTable
ContactGetTable
OnUpcomingEvents
OnUpcomingEventsV2
OnUpcomingEventsV3
GetEventsCalendarView
CreateOnChangedEventPokeSubscription
CreateGraphOnChangedEventPokeSubscription
DeleteEventSubscription
RenewEventSubscription
OnFilePickerOpen
OnFilePickerBrowse
GetEmails
SendEmail
GetOutlookCategoryNames
DraftEmail
UpdateDraftEmail
SendDraftEmail
AssignCategory
AssignCategoryBulk
GetEmailsV2
SendEmailV2
GetEmail
DeleteEmail
GetEmailV2
GetEmailsV3
Move
MoveV2
Flag
MarkAsRead
ReplyTo
ReplyToV2
ReplyToV3
GetAttachment
OnNewEmail
OnNewEmailV2
OnNewEmailV3
OnFlaggedEmail
OnFlaggedEmailV2
OnFlaggedEmailV3
OnFlaggedEmailV4
OnNewMentionMeEmail
OnNewMentionMeEmailV2
OnNewMentionMeEmailV3
SetAutomaticRepliesSetting
GetMailTips
GetSensitivityLabels
CreateOnNewEmailSubscription
CreateOnNewEmailPokeSubscription
CreateGraphOnNewEmailPokeSubscription
CreateOnNewMentionMeEmailPokeSubscription
CreateGraphOnNewMentionMeEmailPokeSubscription
CreateOnFlaggedEmailPokeSubscription
CreateGraphOnFlaggedEmailPokeSubscription
DeleteOnNewEmailSubscription
RenewOnNewEmailSubscription
GetDataSetsMetadata
SendMailWithOptions
SendApprovalMail
DeleteApprovalMailSubscription
DeleteOptionsMailSubscription
SharedMailboxSendEmail
SharedMailboxSendEmailV2
SharedMailboxOnNewEmail
SharedMailboxOnNewEmailV2
TestConnection
CalendarGetTables
CalendarGetItems
CalendarPostItem
CalendarGetItem
CalendarDeleteItem
CalendarPatchItem
V3CalendarGetItems
V3CalendarPostItem
V4CalendarGetItems
V4CalendarPostItem
V2CalendarGetItems
V2CalendarPostItem
GetEventsCalendarViewV2
GetEventsCalendarViewV3
V2CalendarGetItem
V2CalendarPatchItem
V3CalendarGetItem
V3CalendarPatchItem
V4CalendarPatchItem
CalendarGetOnNewItems
CalendarGetOnUpdatedItems
ODataStyleGetOnNewItems
ODataStyleCalendarGetOnUpdatedItems
CalendarGetOnNewItemsV2
CalendarGetOnNewItemsV3
CalendarGetOnUpdatedItemsV2
CalendarGetOnUpdatedItemsV3
CalendarGetOnChangedItems
CalendarGetOnChangedItemsV2
CalendarGetOnChangedItemsV3
ContactGetTables
ContactGetTablesV2
ContactGetItems
ContactPostItem
ContactGetItem
ContactDeleteItem
ContactPatchItem
GetDataSets
ExportEmail
ExportEmail_V2
Flag_V2
MarkAsRead_V2
MarkAsRead_V3
DeleteEmail_V2
GetAttachment_V2
RespondToEvent
RespondToEvent_V2
ForwardEmail
ForwardEmail_V2
GetRoomLists
GetRoomLists_V2
GetRooms
GetRooms_V2
GetRoomsInRoomList
GetRoomsInRoomList_V2
FindMeetingTimes
FindMeetingTimes_V2
SetAutomaticRepliesSetting_V2
GetMailTips_V2
CalendarGetTables_V2
CalendarDeleteItem_V2
ContactGetItem_V2
ContactDeleteItem_V2
ContactPatchItem_V2
ContactGetItems_V2
ContactPostItem_V2
UpdateMyContactPhoto
HttpRequest
mcp_EmailsManagement
mcp_MeetingManagement
mcp_ContactsManagement
ReceiveResponseGet
ReceiveResponsePost
ReceiveMailFromSubscription
ReceiveMailFromSubscriptionV2
ReceiveEventFromSubscription
ReceiveEventFromSubscriptionV2

Connection Reference

"connectionReferences": {
  "office365groups": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_office365groups",
    "displayName": "Office 365 Groups",
    "dataSources": ["office365groups"],
    "authenticationType": null,
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

`dist/office365groups.js` defines explicit connector metadata for group listing, membership, and raw HTTP requests.
The shared connections skill calls out exact operation metadata as mandatory for managed connectors.
Keep the key and `DATA_SOURCE` aligned with the generated schema you sync into the app.

Public Helper Surface

Every exported Office 365 Groups helper

callGroupsOperation(operationName, parameters) - await callGroupsOperation('ListOwnedGroups_V3', { extractSensitivityLabel: true });
openGroupsHttpRequest({ method, uri, headers, body, contentType, customHeaders }) - await openGroupsHttpRequest({ method: 'GET', uri: 'https://graph.microsoft.com/v1.0/me/memberOf' });
listMyGroups(oOptions) - await listMyGroups({ version: 3, extractSensitivityLabel: true });
listGroupMembers(groupId, oOptions) - await listGroupMembers('00000000-0000-0000-0000-000000000000', { top: 25 });
listOwnedGroups(oOptions) - await listOwnedGroups({ version: 2 });
listGroups(oOptions) - await listGroups({ filter: "startswith(displayName,'Team')", top: 25 });
onGroupMembershipChange(groupId, oOptions) - await onGroupMembershipChange('00000000-0000-0000-0000-000000000000', { select: ['id', 'displayName'] });
addMemberToGroup(userUpn, groupId) - await addMemberToGroup('alex@contoso.com', '00000000-0000-0000-0000-000000000000');
removeMemberFromGroup(userUpn, groupId) - await removeMemberFromGroup('alex@contoso.com', '00000000-0000-0000-0000-000000000000');
createGroupEvent(groupId, oOptions) - await createGroupEvent('00000000-0000-0000-0000-000000000000', { subject: 'Quarterly review', start: '2026-04-10T15:00:00Z', end: '2026-04-10T16:00:00Z' });
updateGroupEvent(eventId, oOptions, groupId) - await updateGroupEvent(sEventId, { groupId: '00000000-0000-0000-0000-000000000000', subject: 'Updated review' });
deleteGroupEvent(eventId, groupId) - await deleteGroupEvent(sEventId, '00000000-0000-0000-0000-000000000000');
onNewGroupEvent(groupId) - await onNewGroupEvent('00000000-0000-0000-0000-000000000000');
listDeletedGroups() - await listDeletedGroups();
restoreDeletedGroup(groupId) - await restoreDeletedGroup('00000000-0000-0000-0000-000000000000');
listDeletedGroupsByOwner(userId) - await listDeletedGroupsByOwner('alex@contoso.com');

Supported Raw Actions

All Office 365 Groups connector actions wired by the wrapper

ListGroupMembers
OnGroupMembershipChange
AddMemberToGroup
ListOwnedGroups
ListOwnedGroups_V2
ListOwnedGroups_V3
ListGroups
CreateCalendarEvent
CreateCalendarEventV2
CalendarDeleteItem_V2
UpdateCalendarEvent
RemoveMemberFromGroup
OnNewEvent
HttpRequestV2
HttpRequest
ListDeletedGroups
RestoreDeletedGroup
ListDeletedGroupsByOwner

Connection Reference

"connectionReferences": {
  "office365users": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_office365users",
    "displayName": "Office 365 Users",
    "dataSources": ["office365users"],
    "authenticationType": null,
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

`dist/office365users.js` exposes profile, org chart, photo, search, and raw HTTP request helpers.
The skill file confirms `UserPhoto_V2` returns JPEG content and uses `responseInfo` metadata.
No `databaseReferences` block is needed for this connector.

Public Helper Surface

Every exported Office 365 Users helper

callUsersOperation(operationName, parameters) - await callUsersOperation('MyProfile_V2', {});
openUsersHttpRequest({ method, uri, headers, body, contentType, customHeaders }) - await openUsersHttpRequest({ method: 'GET', uri: 'https://graph.microsoft.com/v1.0/me' });
updateMyProfile(oProfile) - await updateMyProfile({ city: 'Sydney', jobTitle: 'Architect' });
getMyProfile(oOptions) - await getMyProfile({ select: ['displayName', 'mail', 'jobTitle'] });
getUserProfile(userId, oOptions) - await getUserProfile('alex@contoso.com', { select: ['displayName', 'department'] });
getManager(userId, oOptions) - await getManager('alex@contoso.com', { select: ['displayName', 'mail'] });
getDirectReports(userId, oOptions) - await getDirectReports('alex@contoso.com', { top: 10, select: ['displayName', 'mail'] });
getMyTrendingDocuments(oOptions) - await getMyTrendingDocuments({ filter: "resourceVisualization/title ne null" });
getRelevantPeople(userId) - await getRelevantPeople('alex@contoso.com');
updateMyPhoto(oBodyOrOptions, contentType) - await updateMyPhoto({ body: sBase64Jpeg, contentType: 'image/jpeg' });
getUserPhotoMetadata(userId) - await getUserPhotoMetadata('alex@contoso.com');
getUserPhoto(userId) - await getUserPhoto('alex@contoso.com');
getTrendingDocuments(userId, oOptions) - await getTrendingDocuments('alex@contoso.com', { filter: "lastModifiedBy ne null" });
searchForUsers(oOptions) - await searchForUsers({ searchTerm: 'Alex', top: 10, skip: 0 });

Supported Raw Actions

All Office 365 Users connector actions wired by the wrapper

UpdateMyProfile
MyProfile_V2
UpdateMyPhoto
MyTrendingDocuments
RelevantPeople
MyProfile
UserProfile
UserProfile_V2
UserPhotoMetadata
UserPhoto
Manager
DirectReports
Manager_V2
DirectReports_V2
UserPhoto_V2
TrendingDocuments
SearchUser
SearchUserV2
TestConnection
HttpRequest

Connection Reference

"connectionReferences": {
  "teams": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_teams",
    "displayName": "Microsoft Teams",
    "dataSources": ["teams"],
    "authenticationType": null,
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

`codeApp/dist/connectors/teams.js` now exports the generated async helpers directly, plus the aggregated `MicrosoftTeamsService` object as both a named and default export.
Helper names map 1:1 to the connector actions declared in `dataSourcesInfo.apis`, so the docs in this section should mirror that generated file instead of a handwritten wrapper layer.
The current surface covers teams, channels, chats, notifications, adaptive cards, triggers, shifts, meetings, transcripts, recordings, tags, sections, and raw HTTP requests.

Generated Export Surface

Named helpers plus the aggregated Teams service

Import Pattern

import {
  GetAllTeams,
  CreateChannel,
  PostMessageToChannelV2,
  ListMeetingRecordings,
  UpdateTag,
  HttpRequest
} from './codeApp/dist/connectors/teams.js';

import MicrosoftTeamsService from './codeApp/dist/connectors/teams.js';

The named exports are the generated async helpers. The default export is the aggregated MicrosoftTeamsService object with the same method names.

Each helper calls executeConnectorOperation() for the action of the same name and accepts positional arguments in the same order defined by the generated connector metadata.

Exported Operations

All Teams helpers grouped by capability

Teams, Channels, and Chats

GetAllTeams
GetTeamwork
GetTeam
CreateATeam
GetTeamsAsyncResult
CreateChannel
GetChannel
ArchiveChannel
CreateChat
GetChats
GetMessagesFromChat
GetMessagesFromChannel
GetMessageDetails
ListRepliesToMessage
PostMessageToChannel
PostMessageToChannelV2
PostMessageToChannelV3
PostReplyToMessage
PostReplyToMessageV2
PostMessageToSelf
PostMessageToConversation
ReplyWithMessageToConversation
PostCardToConversation
PostCardAndWaitForResponse
ReplyWithCardToConversation
UpdateCardInConversation
AddMemberToChat
GetInstalledAppsForChat

Membership and Notifications

ListTeamMembers
AddMemberToTeam
RemoveMemberFromTeam
AddMemberToChannel
RemoveMemberFromChannel
ListMembers
AtMentionUser
AtMentionTag
AtMentionBot
PostUserNotification
PostChannelNotification
PostUserAdaptiveCard
PostChannelAdaptiveCard
PostFeedNotification
GetMessageLocations
GetFeedNotificationInputSchema
GetNotificationInputMetadata
GetAdaptiveCardInputMetadata
GetUnifiedActionSchema
GetPostToConversationResponseSchema
GetMessageDetailsInputSchema
GetMessageDetailsResponseSchema
ListMembersInputSchema

Triggers and Workflow Subscriptions

OnNewChannelMessage
OnNewChannelMessageMentioningMe
WebhookAtMentionTrigger
WebhookMessageReactionTrigger
WebhookChatMessageTrigger
WebhookKeywordTrigger
WebhookNewMessageTrigger
TeamsCardTrigger
ForASelectedMessage
ForASelectedMessageV2
ComposeAMessage
ComposeAMessageV2
OnGroupMembershipRemoval
OnGroupMembershipAdd
CallEventTrigger
TranscriptTrigger
RecordingTrigger
DeleteWorkflowsMiddleTierSubscriptions
RenewWorkflowsMiddleTierSubscriptions
DeleteWorkflowSubscription
RenewWorkflowSubscription
DeleteWebHookSubscription
RenewWebHookSubscription
SubscribeUserMessageWithOptions
SubscribeUserFlowContinuation
SubscribeChannelFlowContinuation
UnsubscribeMessageWithOptions
UnsubscribeFlowContinuation
GetMessageWithOptionsInputMetadata
GetFlowContinuationInputMetadata
GetMessageWithOptionsSubscriptionInputMetadata
GetFlowContinuationSubscriptionInputMetadata
GetMessageWithOptionsSubscriptionOutputMetadata
GetFlowContinuationSubscriptionOutputMetadata
GetFlowContinuationSubscriptionWithPosterOutputMetadata
GetSelectedMessageTriggerOutputsMetadata
GetComposeMessageTriggerOutputsMetadata
GetCardResponseTriggerOutputsMetadata
GetWebhookTriggerRequestSchema
GetWebhookTriggerResponseSchema
GetSubscriptionScopeSchema
WebhookResponse
WebhookLifecycleNotification

Meetings, Calls, and Insights

CreateTeamsMeeting
GetSupportedTimeZones
GetOnlineMeeting
ListMeetingTranscripts
GetMeetingTranscript
GetMeetingTranscriptContent
ListMeetingRecordings
GetMeetingRecording
GetMeetingRecordingContent
ListCallRecordings
GetCallRecording
GetCallRecordingContent
ListCallTranscripts
GetCallTranscript
GetCallTranscriptContent
GetAllAdhocCallRecordings
GetAllAdhocCallTranscripts
ListAiInsights
GetAiInsight

Scheduling and Shifts

ListTimeOffReasons
GetShift
DeleteShift
CreateOpenShift
GetOpenShift
UpdateOpenShift
DeleteOpenShift
GetSchedulingGroup
TimeOffRequestApprove
TimeOffRequestDecline
OfferShiftRequestApprove
OfferShiftRequestDecline
SwapShiftsChangeRequestApprove
SwapShiftsChangeRequestDecline
OpenShiftChangeRequestApprove
OpenShiftChangeRequestDecline
GetSchedule

Sections, Tags, Agents, and Raw HTTP

InvokeChannelAgent
GetChannelAgentOperation
GetVirtualAgentBots
HttpRequest
ListSections
CreateSection
GetSection
UpdateSection
DeleteSection
ListSectionItems
AddSectionItem
RemoveSectionItem
MoveSectionItem
GetTags
CreateTag
GetTag
UpdateTag
DeleteTag
AddMemberToTag
GetTagMembers
DeleteTagMember

Connection Reference

"connectionReferences": {
  "jira": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_jira",
    "displayName": "Jira",
    "dataSources": ["jira"],
    "authenticationType": "APIToken",
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

`codeapp.js` resolves Jira against `jira`, `Jira`, and `JIRA` data source names.
Issue, filter, task, and user helpers pass the Jira site through the `jiraInstance` argument, which maps to the required `X-Request-Jirainstance` header.
The wrapper set includes comments, issue create and edit, current-user lookup, project listing, filters, and async task helpers.

Issue Helpers

Every exported Jira issue helper

callJiraOperation(operationName, parameters) - await callJiraOperation('ListProjects_V2', {});
addJiraComment(issueKey, body, jiraInstance) - await addJiraComment('DEMO-42', 'Please review this issue.', 'https://contoso.atlassian.net');
createJiraIssue(oOptions) - await createJiraIssue({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO', summary: 'Connector docs update', issueTypeId: '10001' });
createJiraIssueV3(oOptions) - await createJiraIssueV3({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO', issueTypeIds: ['10001'], summary: 'Create via V3' });
editJiraIssue(issueIdOrKey, oOptions) - await editJiraIssue('DEMO-42', { jiraInstance: 'https://contoso.atlassian.net', fields: { summary: 'Updated summary' } });
editJiraIssueV2(issueIdOrKey, oOptions) - await editJiraIssueV2('DEMO-42', { jiraInstance: 'https://contoso.atlassian.net', notifyUsers: true, fields: { description: 'Updated body' } });
updateJiraIssue(issueKey, oOptions) - await updateJiraIssue('DEMO-42', { jiraInstance: 'https://contoso.atlassian.net', summary: 'Updated from helper' });
getJiraIssueByKey(issueKey, jiraInstance) - await getJiraIssueByKey('DEMO-42', 'https://contoso.atlassian.net');
listJiraIssues({ jiraInstance, jql, fields, expand }) - await listJiraIssues({ jiraInstance: 'https://contoso.atlassian.net', jql: 'project = DEMO ORDER BY updated DESC', fields: ['summary', 'status'] });
listJiraIssueTypes(oOptions) - await listJiraIssueTypes({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO' });
listJiraIssueTypeFields(oOptions) - await listJiraIssueTypeFields({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO', issueTypeIds: ['10001'] });
listJiraTransitions(issueIdOrKey, oOptions) - await listJiraTransitions('DEMO-42', { jiraInstance: 'https://contoso.atlassian.net' });
transitionJiraIssue(issueIdOrKey, oOptions) - await transitionJiraIssue('DEMO-42', { jiraInstance: 'https://contoso.atlassian.net', transition: { id: '31' } });

Project And Admin Helpers

Projects, users, filters, priorities, and categories

listJiraProjects(oOptions) - await listJiraProjects({ jiraInstance: 'https://contoso.atlassian.net' });
createJiraProject(oOptions) - await createJiraProject({ jiraInstance: 'https://contoso.atlassian.net', key: 'DOCS', name: 'Docs Project' });
updateJiraProject(projectIdOrKey, oOptions) - await updateJiraProject('DOCS', { jiraInstance: 'https://contoso.atlassian.net', name: 'Docs Project Updated' });
deleteJiraProject(projectIdOrKey, oOptions) - await deleteJiraProject('DOCS', { jiraInstance: 'https://contoso.atlassian.net', enableUndo: true });
listJiraProjectCategories(oOptions) - await listJiraProjectCategories({ jiraInstance: 'https://contoso.atlassian.net' });
createJiraProjectCategory(oOptions) - await createJiraProjectCategory({ jiraInstance: 'https://contoso.atlassian.net', name: 'Internal Apps' });
removeJiraProjectCategory(id, oOptions) - await removeJiraProjectCategory(10000, { jiraInstance: 'https://contoso.atlassian.net' });
listJiraStatuses(oOptions) - await listJiraStatuses({ jiraInstance: 'https://contoso.atlassian.net', projectId: '10000', issueType: 'Bug' });
listJiraProjectUsers(oOptions) - await listJiraProjectUsers({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO' });
listJiraAssignableUsers(oOptions) - await listJiraAssignableUsers({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO' });
listJiraPriorityTypes(oOptions) - await listJiraPriorityTypes({ jiraInstance: 'https://contoso.atlassian.net' });
listJiraResources() - await listJiraResources();
getCurrentJiraUser({ jiraInstance, expand }) - await getCurrentJiraUser({ jiraInstance: 'https://contoso.atlassian.net', expand: ['groups'] });
getJiraUser(accountId, oOptions) - await getJiraUser('5b10a2844c20165700ede21g', { jiraInstance: 'https://contoso.atlassian.net', expand: ['groups'] });
listJiraFilters(jiraInstance) - await listJiraFilters('https://contoso.atlassian.net');

Tasks, Automation, And MCP

Async jobs, datacenter helpers, and event-style actions

getJiraTask(taskId, jiraInstance) - await getJiraTask('10001', 'https://contoso.atlassian.net');
cancelJiraTask(taskId, jiraInstance, token) - await cancelJiraTask('10001', 'https://contoso.atlassian.net', 'nocheck');
listJiraIssuesDatacenter(oOptions) - await listJiraIssuesDatacenter({ jiraInstance: 'https://contoso.atlassian.net' });
onNewJiraIssue(oOptions) - await onNewJiraIssue({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO' });
onClosedJiraIssue(oOptions) - await onClosedJiraIssue({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO' });
onUpdatedJiraIssue(oOptions) - await onUpdatedJiraIssue({ jiraInstance: 'https://contoso.atlassian.net', projectKey: 'DEMO' });
onNewJiraIssueFromJql(oOptions) - await onNewJiraIssueFromJql({ jiraInstance: 'https://contoso.atlassian.net', jql: 'project = DEMO AND status = Open' });
manageJiraIssues(queryRequest, sessionId) - await manageJiraIssues({ prompt: 'Create a sprint summary for DEMO issues' }, 'session-1');

Supported Raw Actions

All Jira connector actions wired by the wrapper

AddComment_V2
CancelTask_V2
CreateIssue_V3
EditIssue_V2
GetCurrentUser
GetIssue_V2
ListFilters_V2
ListIssues
ListProjects_V2
GetTask_V2
GetUser_V2
EditIssue
DeleteProject
UpdateProject
DeleteProject_V2
UpdateProject_V2
GetAllProjectCategories
CreateProjectCategory
GetAllProjectCategories_V2
CreateProjectCategory_V2
RemoveProjectCategory
RemoveProjectCategory_V2
GetTask
CancelTask
GetUser
CreateIssue
CreateIssueV2
GetIssue
UpdateIssue
UpdateIssue_V2
AddComment
ListIssueTypes
ListIssueTypes_V2
ListIssueTypesFields
ListIssueTypesFields_V2
ListProjects
CreateProject
CreateProject_V2
ListProjects_V3
ListStatuses
ListStatuses_V2
ListProjectUsers
ListProjectUsers_V2
ListAssignableUsers
ListAssignableUsers_V2
ListPriorityTypes
ListPriorityTypes_V2
ListFilters
ListResources
ListIssues_Datacenter
ListTransitions
UpdateTransition
OnNewIssue
OnNewIssue_V2
OnNewIssue_Datacenter
OnCloseIssue
OnCloseIssue_V2
OnCloseIssue_Datacenter
OnUpdateIssue
OnUpdateIssue_V2
OnUpdateIssue_Datacenter
OnNewIssueJQL
OnNewIssueJQL_V2
OnNewIssueJQL_Datacenter
mcp_JiraIssueManagement

Connection Reference

"connectionReferences": {
  "keyvault": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_keyvault",
    "displayName": "Azure Key Vault",
    "dataSources": ["keyvault"],
    "authenticationType": "oauthDefault",
    "sharedConnectionId": null,
    "dataSets": {}
  }
}

Helper Coverage

`codeapp.js` checks common Azure Key Vault aliases including `keyvault`, `KeyVault`, `azurekeyvault`, `azureKeyVault`, and `AzureKeyVault`.
The sample wrapper exposes keys, secrets, and cryptography helpers as well as the generic action helper.
Pass the secret name only. The connected vault context comes from the configured connection reference.

Public Helper Surface

Every exported Azure Key Vault helper

callKeyVaultOperation(operationName, parameters) - await callKeyVaultOperation('ListSecrets', {});
listKeys(oOptions) - await listKeys();
listKeyVersions(keyName) - await listKeyVersions('app-encryption-key');
getKeyMetadata(keyName) - await getKeyMetadata('app-encryption-key');
getKeyVersionMetadata(keyName, keyVersion) - await getKeyVersionMetadata('app-encryption-key', 'key-version-id');
encryptData(keyName, inputOrOptions) - await encryptData('app-encryption-key', { rawData: 'sensitive text' });
encryptDataWithVersion(keyName, keyVersion, inputOrOptions) - await encryptDataWithVersion('app-encryption-key', 'key-version-id', { rawData: 'sensitive text' });
decryptData(keyName, inputOrOptions) - await decryptData('app-encryption-key', { encryptedData: sCipherText });
decryptDataWithVersion(keyName, keyVersion, inputOrOptions) - await decryptDataWithVersion('app-encryption-key', 'key-version-id', { encryptedData: sCipherText });
getSecret(secretName) - await getSecret('codeapp-api-key');
listSecrets(oOptions) - await listSecrets();
listSecretVersions(secretName) - await listSecretVersions('codeapp-api-key');
getSecretMetadata(secretName) - await getSecretMetadata('codeapp-api-key');
getSecretVersionMetadata(secretName, secretVersion) - await getSecretVersionMetadata('codeapp-api-key', 'secret-version-id');
getSecretVersion(secretName, secretVersion) - await getSecretVersion('codeapp-api-key', 'secret-version-id');

Supported Raw Actions

All Azure Key Vault connector actions wired by the wrapper

ListKeys
ListKeyVersions
GetKeyMetadata
GetKeyVersionMetadata
EncryptData
EncryptDataWithVersion
DecryptData
DecryptDataWithVersion
GetSecret
ListSecrets
ListSecretVersions
GetSecretMetadata
GetSecretVersionMetadata
GetSecretVersion

Connection Reference

"connectionReferences": {
  "<connection-reference-id>": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_powerplatformadminv2",
    "displayName": "Power Platform for Admins V2",
    "dataSources": ["powerplatformadminv2"],
    "authenticationType": "oauth2-auth",
    "dataSets": {}
  }
}

Helper Coverage

dist/connectors/powerplatformadminv2.js exports 176 generated administration operations.
Helpers cover environments, backups, disaster recovery, governance, capacity, billing, cloud flows, Copilot agents, Power Pages, and tenant resources.
Arguments are positional and most operations require an explicit API version. Preserve the generated order, spelling, and parameter casing.
Helpers return unwrapped connector data, throw descriptive connector errors, and integrate with the CodeAppJS debugger.

Import Pattern

import {
  ListEnvironmentsForUser,
  GetEnvironmentByIdForUser,
  GetOperationsForEnvironment
} from './codeApp/dist/connectors/powerplatformadminv2.js';

import Powerplatformadminv2Service
  from './codeApp/dist/connectors/powerplatformadminv2.js';

const environments = await ListEnvironmentsForUser(API_VERSION);
const operations = await GetOperationsForEnvironment(
  environmentId,
  API_VERSION,
  50,
  continuationToken
);

Import individual helpers for focused features, or use the default Powerplatformadminv2Service object when working across several administration capabilities.

Public Helper Surface

Every exported Power Platform Admin V2 action

Each example shows the required positional arguments without guessing tenant values or API versions. Optional arguments and their exact positions remain visible in the signature; pass undefined when you need to skip an earlier optional argument.

ExecuteRecommendationAction(body, actionName, api_version) - await ExecuteRecommendationAction(requestBody, actionName, API_VERSION);
GetRecommendations(api_version, $skipToken = undefined) - await GetRecommendations(API_VERSION);
GetActionSchema(scenario, actionName, x_ms_api_version) - await GetActionSchema(scenario, actionName, API_VERSION);
GetScenarioActions(scenario, x_ms_api_version) - await GetScenarioActions(scenario, API_VERSION);
GetRecommendationResources(scenario, api_version, $skipToken = undefined) - await GetRecommendationResources(scenario, API_VERSION);
GetRecommendationScenarios(x_ms_api_version) - await GetRecommendationScenarios(API_VERSION);
GetTenantApplicationPackage(api_version) - await GetTenantApplicationPackage(API_VERSION);
GetEnvironmentApplicationPackage(environmentId, api_version, appInstallState = undefined, lcid = undefined) - await GetEnvironmentApplicationPackage(environmentId, API_VERSION);
InstallApplicationPackage(environmentId, uniqueName, api_version, body = undefined) - await InstallApplicationPackage(environmentId, uniqueName, API_VERSION);
GetApplicationPackageInstallStatus(environmentId, operationId, api_version) - await GetApplicationPackageInstallStatus(environmentId, operationId, API_VERSION);
ListEnvironmentGroupRoleAssignments(environmentGroupId, api_version) - await ListEnvironmentGroupRoleAssignments(environmentGroupId, API_VERSION);
CreateEnvironmentGroupRoleAssignment(environmentGroupId, api_version, body) - await CreateEnvironmentGroupRoleAssignment(environmentGroupId, API_VERSION, requestBody);
DeleteEnvironmentGroupRoleAssignment(environmentGroupId, roleAssignmentId, api_version) - await DeleteEnvironmentGroupRoleAssignment(environmentGroupId, roleAssignmentId, API_VERSION);
ListEnvironmentRoleAssignments(environmentId, api_version) - await ListEnvironmentRoleAssignments(environmentId, API_VERSION);
CreateEnvironmentRoleAssignment(environmentId, api_version, body) - await CreateEnvironmentRoleAssignment(environmentId, API_VERSION, requestBody);
DeleteEnvironmentRoleAssignment(environmentId, roleAssignmentId, api_version) - await DeleteEnvironmentRoleAssignment(environmentId, roleAssignmentId, API_VERSION);
ListRoleAssignments(api_version) - await ListRoleAssignments(API_VERSION);
CreateRoleAssignment(api_version, body) - await CreateRoleAssignment(API_VERSION, requestBody);
DeleteRoleAssignment(roleAssignmentId, api_version) - await DeleteRoleAssignment(roleAssignmentId, API_VERSION);
ListRoleDefinitions(api_version) - await ListRoleDefinitions(API_VERSION);
ListConnections(environmentId, api_version) - await ListConnections(environmentId, API_VERSION);
ListConnectors(environmentId, $filter, api_version) - await ListConnectors(environmentId, filterExpression, API_VERSION);
GetConnectorById(environmentId, connectorId, $filter, api_version) - await GetConnectorById(environmentId, connectorId, filterExpression, API_VERSION);
DeleteCopilotAgent(EnvironmentId, BotId, api_version) - await DeleteCopilotAgent(EnvironmentId, BotId, API_VERSION);
ReassignCopilotAgent(EnvironmentId, BotId, api_version, body) - await ReassignCopilotAgent(EnvironmentId, BotId, API_VERSION, requestBody);
GetBotQuarantineStatus(EnvironmentId, BotId, api_version) - await GetBotQuarantineStatus(EnvironmentId, BotId, API_VERSION);
SetBotAsQuarantined(EnvironmentId, BotId, api_version) - await SetBotAsQuarantined(EnvironmentId, BotId, API_VERSION);
SetBotAsUnquarantined(EnvironmentId, BotId, api_version) - await SetBotAsUnquarantined(EnvironmentId, BotId, API_VERSION);
ListMakerEvaluationTestRuns(EnvironmentId, BotId, api_version) - await ListMakerEvaluationTestRuns(EnvironmentId, BotId, API_VERSION);
GetMakerEvaluationTestRun(EnvironmentId, BotId, TestRunId, api_version) - await GetMakerEvaluationTestRun(EnvironmentId, BotId, TestRunId, API_VERSION);
DownloadMakerEvaluationSnapshot(EnvironmentId, BotId, TestRunId, api_version) - await DownloadMakerEvaluationSnapshot(EnvironmentId, BotId, TestRunId, API_VERSION);
ListMakerEvaluationTestSets(EnvironmentId, BotId, api_version) - await ListMakerEvaluationTestSets(EnvironmentId, BotId, API_VERSION);
GetMakerEvaluationTestSet(EnvironmentId, BotId, TestSetId, api_version) - await GetMakerEvaluationTestSet(EnvironmentId, BotId, TestSetId, API_VERSION);
RunMakerEvaluationTestSet(EnvironmentId, BotId, TestSetId, api_version, body) - await RunMakerEvaluationTestSet(EnvironmentId, BotId, TestSetId, API_VERSION, requestBody);
GetFinOpsMaintenanceSettings(environmentId, api_version) - await GetFinOpsMaintenanceSettings(environmentId, API_VERSION);
UpdateFinOpsMaintenanceSettings(environmentId, api_version, body) - await UpdateFinOpsMaintenanceSettings(environmentId, API_VERSION, requestBody);
CreateEnvironmentManagementSettings(environmentId, api_version, body = undefined) - await CreateEnvironmentManagementSettings(environmentId, API_VERSION);
ListEnvironmentManagementSettings(environmentId, api_version, $top = undefined, $select = undefined) - await ListEnvironmentManagementSettings(environmentId, API_VERSION);
UpdateEnvironmentManagementSettings(environmentId, api_version, body = undefined) - await UpdateEnvironmentManagementSettings(environmentId, API_VERSION);
CreateEnvironmentBackup(environmentId, api_version, body = undefined) - await CreateEnvironmentBackup(environmentId, API_VERSION);
GetEnvironmentBackups(environmentId, api_version) - await GetEnvironmentBackups(environmentId, API_VERSION);
DeleteEnvironmentBackup(environmentId, backupId, api_version) - await DeleteEnvironmentBackup(environmentId, backupId, API_VERSION);
GetBusinessContinuityStateFullSnapshot(environmentId, api_version) - await GetBusinessContinuityStateFullSnapshot(environmentId, API_VERSION);
DisableEnvironment(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined, body = undefined) - await DisableEnvironment(environmentId, API_VERSION);
DisableDisasterRecovery(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await DisableDisasterRecovery(environmentId, API_VERSION);
PerformDRDrill(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await PerformDRDrill(environmentId, API_VERSION);
EnableEnvironment(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined, body = undefined) - await EnableEnvironment(environmentId, API_VERSION);
EnableDisasterRecovery(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await EnableDisasterRecovery(environmentId, API_VERSION);
PerformForceFailover(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined, body = undefined) - await PerformForceFailover(environmentId, API_VERSION);
DisableManagedEnvironment(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await DisableManagedEnvironment(environmentId, API_VERSION);
EnableManagedEnvironment(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await EnableManagedEnvironment(environmentId, API_VERSION);
ModifyEnvironmentSku(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined, body = undefined) - await ModifyEnvironmentSku(environmentId, API_VERSION);
GetOperationsForEnvironment(environmentId, api_version, limit = undefined, continuationToken = undefined) - await GetOperationsForEnvironment(environmentId, API_VERSION);
RecoverEnvironment(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await RecoverEnvironment(environmentId, API_VERSION);
GetEnvironmentCopyCandidates(sourceEnvironmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await GetEnvironmentCopyCandidates(sourceEnvironmentId, API_VERSION);
GetRestoreCandidates(sourceEnvironmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await GetRestoreCandidates(sourceEnvironmentId, API_VERSION);
CopyEnvironment(targetEnvironmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined, body = undefined) - await CopyEnvironment(targetEnvironmentId, API_VERSION);
RestoreEnvironment(targetEnvironmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined, body = undefined) - await RestoreEnvironment(targetEnvironmentId, API_VERSION);
GetOperationByID(operationId, api_version) - await GetOperationByID(operationId, API_VERSION);
ProvisionNewEnvironment(api_version, body = undefined) - await ProvisionNewEnvironment(API_VERSION);
LinkDataverse(environmentId, api_version, body = undefined) - await LinkDataverse(environmentId, API_VERSION);
GetSupportedLocations(api_version) - await GetSupportedLocations(API_VERSION);
GetProvisioningCurrencies(location, api_version) - await GetProvisioningCurrencies(location, API_VERSION);
GetProvisioningLanguages(location, api_version) - await GetProvisioningLanguages(location, API_VERSION);
GetProvisioningTemplates(location, api_version) - await GetProvisioningTemplates(location, API_VERSION);
GetEnvironmentGroupOperation(operationId, api_version) - await GetEnvironmentGroupOperation(operationId, API_VERSION);
CreateEnvironmentGroup(api_version, body) - await CreateEnvironmentGroup(API_VERSION, requestBody);
ListEnvironmentGroups(api_version) - await ListEnvironmentGroups(API_VERSION);
GetEnvironmentGroup(groupId, api_version) - await GetEnvironmentGroup(groupId, API_VERSION);
UpdateEnvironmentGroup(groupId, api_version, body) - await UpdateEnvironmentGroup(groupId, API_VERSION, requestBody);
DeleteEnvironmentGroup(groupId, api_version) - await DeleteEnvironmentGroup(groupId, API_VERSION);
AddEnvironmentToGroup(groupId, environmentId, api_version) - await AddEnvironmentToGroup(groupId, environmentId, API_VERSION);
RemoveEnvironmentFromGroup(groupId, environmentId, api_version) - await RemoveEnvironmentFromGroup(groupId, environmentId, API_VERSION);
ListEnvironmentsForUser(api_version, ids = undefined, $filter = undefined, $select = undefined, $top = undefined, $skip = undefined, $orderby = undefined) - await ListEnvironmentsForUser(API_VERSION);
GetEnvironmentByIdForUser(environmentId, api_version, $select = undefined) - await GetEnvironmentByIdForUser(environmentId, API_VERSION);
DeleteEnvironmentByID(environmentId, api_version, ValidateOnly = undefined, ValidateProperties = undefined) - await DeleteEnvironmentByID(environmentId, API_VERSION);
CreateRuleBasedPolicy(api_version, body) - await CreateRuleBasedPolicy(API_VERSION, requestBody);
ListRuleBasedPolicies(api_version) - await ListRuleBasedPolicies(API_VERSION);
GetRuleBasedPolicyByID(policyId, api_version) - await GetRuleBasedPolicyByID(policyId, API_VERSION);
UpdateRuleBasedPolicyByID(policyId, api_version, body) - await UpdateRuleBasedPolicyByID(policyId, API_VERSION, requestBody);
PatchRuleBasedPolicy(policyId, api_version, body) - await PatchRuleBasedPolicy(policyId, API_VERSION, requestBody);
ListRuleAssignmentsByPolicyId(policyId, includeRuleSetCounts, api_version) - await ListRuleAssignmentsByPolicyId(policyId, true, API_VERSION);
CreateEnviornmentGroupRuleBasedAssignment(policyId, groupId, api_version, body) - await CreateEnviornmentGroupRuleBasedAssignment(policyId, groupId, API_VERSION, requestBody);
CreateEnvironmentRuleBasedAssignment(policyId, environmentId, api_version, body) - await CreateEnvironmentRuleBasedAssignment(policyId, environmentId, API_VERSION, requestBody);
RemoveRuleFromRuleBasedPolicy(policyId, api_version, body) - await RemoveRuleFromRuleBasedPolicy(policyId, API_VERSION, requestBody);
ListRuleAssignments(includeRuleSetCounts, api_version) - await ListRuleAssignments(true, API_VERSION);
ListRuleAssignmentsByEnvironmentGroupId(environmentGroupId, includeRuleSetCounts, api_version) - await ListRuleAssignmentsByEnvironmentGroupId(environmentGroupId, true, API_VERSION);
ListRuleAssignmentsByEnvironmentId(environmentId, includeRuleSetCounts, api_version) - await ListRuleAssignmentsByEnvironmentId(environmentId, true, API_VERSION);
GetRuleSet(groupId, api_version) - await GetRuleSet(groupId, API_VERSION);
CreateRuleSet(groupId, api_version, body) - await CreateRuleSet(groupId, API_VERSION, requestBody);
GetRuleSetListForTenant(api_version, $select = undefined, $filter = undefined, $expand = undefined, $skiptoken = undefined, $top = undefined) - await GetRuleSetListForTenant(API_VERSION);
UpdateRuleSet(ruleSetId, api_version, body) - await UpdateRuleSet(ruleSetId, API_VERSION, requestBody);
DeleteRuleSet(ruleSetId, api_version) - await DeleteRuleSet(ruleSetId, API_VERSION);
ListCrossTenantConnectionReports(api_version) - await ListCrossTenantConnectionReports(API_VERSION);
CreateCrossTenantConnectionReport(api_version) - await CreateCrossTenantConnectionReport(API_VERSION);
GetCrossTenantConnectionReport(reportId, api_version) - await GetCrossTenantConnectionReport(reportId, API_VERSION);
ListBillingPolicies(api_version, $top = undefined) - await ListBillingPolicies(API_VERSION);
CreateBillingPolicy(api_version, body = undefined) - await CreateBillingPolicy(API_VERSION);
GetBillingPolicy(billingPolicyId, api_version) - await GetBillingPolicy(billingPolicyId, API_VERSION);
UpdateBillingPolicy(billingPolicyId, api_version, body = undefined) - await UpdateBillingPolicy(billingPolicyId, API_VERSION);
DeleteBillingPolicy(billingPolicyId, api_version) - await DeleteBillingPolicy(billingPolicyId, API_VERSION);
ListBillingPolicyEnvironments(billingPolicyId, api_version) - await ListBillingPolicyEnvironments(billingPolicyId, API_VERSION);
GetBillingPolicyEnvironment(billingPolicyId, environmentId, api_version) - await GetBillingPolicyEnvironment(billingPolicyId, environmentId, API_VERSION);
AddBillingPolicyEnvironment(billingPolicyId, api_version, body = undefined) - await AddBillingPolicyEnvironment(billingPolicyId, API_VERSION);
RemoveBillingPolicyEnvironment(billingPolicyId, api_version, body = undefined) - await RemoveBillingPolicyEnvironment(billingPolicyId, API_VERSION);
RefreshProvisioningStatus(billingPolicyId, api_version) - await RefreshProvisioningStatus(billingPolicyId, API_VERSION);
GetCurrencyAllocationByEnvironment(environmentId, api_version) - await GetCurrencyAllocationByEnvironment(environmentId, API_VERSION);
PatchCurrencyAllocationByEnvironment(environmentId, api_version, body = undefined) - await PatchCurrencyAllocationByEnvironment(environmentId, API_VERSION);
GetEnvironmentBillingPolicy(environmentId, api_version) - await GetEnvironmentBillingPolicy(environmentId, API_VERSION);
ListISVContracts(api_version, $top = undefined) - await ListISVContracts(API_VERSION);
CreateISVContract(api_version, body = undefined) - await CreateISVContract(API_VERSION);
GetISVContract(isvContractId, api_version) - await GetISVContract(isvContractId, API_VERSION);
UpdateISVContract(isvContractId, api_version, body = undefined) - await UpdateISVContract(isvContractId, API_VERSION);
DeleteISVContract(isvContractId, api_version) - await DeleteISVContract(isvContractId, API_VERSION);
GetStorageWarningByCategory(storageCategory, api_version) - await GetStorageWarningByCategory(storageCategory, API_VERSION);
GetStorageWarningByCategoryAndEntity(storageCategory, entityName, api_version) - await GetStorageWarningByCategoryAndEntity(storageCategory, entityName, API_VERSION);
ListStorageWarnings(api_version) - await ListStorageWarnings(API_VERSION);
RetrieveTemporaryCurrencyEntitlementCount(currencyType, api_version) - await RetrieveTemporaryCurrencyEntitlementCount(currencyType, API_VERSION);
GetTenantCapacityDetails(api_version) - await GetTenantCapacityDetails(API_VERSION);
ListCurrencyReports(api_version, includeAllocations = undefined, includeConsumptions = undefined) - await ListCurrencyReports(API_VERSION);
GetUserPerFlowCapacitySource(startDate, api_version, endDate = undefined, pageNumber = undefined, pageSize = undefined, userId = undefined, flowContext = undefined, flowLicenseCategorization = undefined, resourceId = undefined, environmentId = undefined) - await GetUserPerFlowCapacitySource(startDate, API_VERSION);
GetUserPerFlowCapacitySourceFlowContextSummary(startDate, api_version, endDate = undefined, pageNumber = undefined, pageSize = undefined, environmentId = undefined) - await GetUserPerFlowCapacitySourceFlowContextSummary(startDate, API_VERSION);
GetUserPerFlowCapacitySourceFlowContextSummaryForUserId(userId, startDate, api_version, endDate = undefined, pageNumber = undefined, pageSize = undefined, environmentId = undefined) - await GetUserPerFlowCapacitySourceFlowContextSummaryForUserId(userId, startDate, API_VERSION);
GetUserPerFlowCapacitySourceTenantContextSummary(startDate, api_version, endDate = undefined, environmentId = undefined) - await GetUserPerFlowCapacitySourceTenantContextSummary(startDate, API_VERSION);
GetUserPerFlowCapacitySourceUserContextSummary(startDate, api_version, endDate = undefined, pageNumber = undefined, pageSize = undefined, environmentId = undefined) - await GetUserPerFlowCapacitySourceUserContextSummary(startDate, API_VERSION);
GetUserPerFlowCapacitySourceUserContextSummaryForUserId(userId, startDate, api_version, endDate = undefined, pageNumber = undefined, pageSize = undefined, environmentId = undefined) - await GetUserPerFlowCapacitySourceUserContextSummaryForUserId(userId, startDate, API_VERSION);
Get_AdminApps(environmentId, api_version, $top = undefined, $skiptoken = undefined) - await Get_AdminApps(environmentId, API_VERSION);
Get_AdminApp(environmentId, app, api_version) - await Get_AdminApp(environmentId, app, API_VERSION);
ListCloudFlows(environmentId, api_version, workflowId = undefined, resourceId = undefined, createdBy = undefined, ownerId = undefined, createdOnStartDate = undefined, createdOnEndDate = undefined, modifiedOnStartDate = undefined, modifiedOnEndDate = undefined) - await ListCloudFlows(environmentId, API_VERSION);
ListFlowActions(environmentId, api_version, workflowId = undefined, parentProcessStageId = undefined, connector = undefined, isTrigger = undefined, parameterName = undefined, parameterValue = undefined, exact = undefined) - await ListFlowActions(environmentId, API_VERSION);
ListFlowRuns(environmentId, workflowId, api_version) - await ListFlowRuns(environmentId, workflowId, API_VERSION);
GetWebsites(environmentId, api_version, skip = undefined) - await GetWebsites(environmentId, API_VERSION);
CreateWebsite(environmentId, api_version, body) - await CreateWebsite(environmentId, API_VERSION, requestBody);
GetWebsiteById(environmentId, id, api_version) - await GetWebsiteById(environmentId, id, API_VERSION);
DeleteWebsite(Operation_Location, environmentId, id, api_version) - await DeleteWebsite(Operation_Location, environmentId, id, API_VERSION);
ConvertTrialToProduction(environmentId, id, api_version, body) - await ConvertTrialToProduction(environmentId, id, API_VERSION, requestBody);
CreateWafRules(environmentId, id, api_version, body) - await CreateWafRules(environmentId, id, API_VERSION, requestBody);
DeleteWafCustomRules(environmentId, id, api_version, body) - await DeleteWafCustomRules(environmentId, id, API_VERSION, requestBody);
DisableWaf(environmentId, id, api_version) - await DisableWaf(environmentId, id, API_VERSION);
EnableWAF(environmentId, id, api_version) - await EnableWAF(environmentId, id, API_VERSION);
GetWAFRules(environmentId, id, api_version, ruleType = undefined) - await GetWAFRules(environmentId, id, API_VERSION);
GetWAFStatus(environmentId, id, api_version) - await GetWAFStatus(environmentId, id, API_VERSION);
AddAllowedIpAddresses(environmentId, id, api_version, body) - await AddAllowedIpAddresses(environmentId, id, API_VERSION, requestBody);
RemoveAllowedIpAddresses(environmentId, id, api_version, body) - await RemoveAllowedIpAddresses(environmentId, id, API_VERSION, requestBody);
RestartWebsite(environmentId, id, api_version) - await RestartWebsite(environmentId, id, API_VERSION);
GetSecurityScanReport(environmentId, id, api_version) - await GetSecurityScanReport(environmentId, id, API_VERSION);
GetSecurityScanScore(environmentId, id, api_version) - await GetSecurityScanScore(environmentId, id, API_VERSION);
StartDeepScan(environmentId, id, api_version) - await StartDeepScan(environmentId, id, API_VERSION);
StartQuickScan(environmentId, id, api_version, lcid = undefined) - await StartQuickScan(environmentId, id, API_VERSION);
SetPortalBootstrapV5Enabled(environmentId, id, api_version) - await SetPortalBootstrapV5Enabled(environmentId, id, API_VERSION);
SetPortalDataModelVersion(environmentId, id, api_version, body) - await SetPortalDataModelVersion(environmentId, id, API_VERSION, requestBody);
StartWebsite(environmentId, id, api_version) - await StartWebsite(environmentId, id, API_VERSION);
StopWebsite(environmentId, id, api_version) - await StopWebsite(environmentId, id, API_VERSION);
ToggleAFDTrafficRouting(environmentId, id, enableAFD, api_version) - await ToggleAFDTrafficRouting(environmentId, id, true, API_VERSION);
UpdatePortalSecurityGroup(environmentId, id, api_version, securityGroupId = undefined) - await UpdatePortalSecurityGroup(environmentId, id, API_VERSION);
UpdateSiteVisibility(environmentId, id, api_version, siteVisibility = undefined) - await UpdateSiteVisibility(environmentId, id, API_VERSION);
QueryResources(api_version, body) - await QueryResources(API_VERSION, requestBody);
ApplyAdminRole(environmentId, api_version) - await ApplyAdminRole(environmentId, API_VERSION);
GetFlowRunActionsForDsr(aiFlowId, runId, api_version, continuationToken = undefined) - await GetFlowRunActionsForDsr(aiFlowId, runId, API_VERSION);
GetApprovals(api_version, continuationToken = undefined) - await GetApprovals(API_VERSION);
DeleteApproval(approvalId, api_version) - await DeleteApproval(approvalId, API_VERSION);
GetConnections(api_version, continuationToken = undefined) - await GetConnections(API_VERSION);
DeleteConnection(connectionIdentifier, api_version) - await DeleteConnection(connectionIdentifier, API_VERSION);
GetConversationTranscriptsForDsr(api_version, continuationToken = undefined) - await GetConversationTranscriptsForDsr(API_VERSION);
GetFlowRunActionsWithEnvironment(environmentId, aiFlowId, runId, api_version, continuationToken = undefined) - await GetFlowRunActionsWithEnvironment(environmentId, aiFlowId, runId, API_VERSION);
GetConversationTranscriptsWithEnvironment(environmentId, api_version, continuationToken = undefined) - await GetConversationTranscriptsWithEnvironment(environmentId, API_VERSION);
GetFlowRunsNonSingleton(environmentId, flowId, api_version, continuationToken = undefined) - await GetFlowRunsNonSingleton(environmentId, flowId, API_VERSION);
GetRunHistoryDataNonSingleton(environmentId, flowId, runId, api_version, continuationToken = undefined) - await GetRunHistoryDataNonSingleton(environmentId, flowId, runId, API_VERSION);
GetFlows(api_version, continuationToken = undefined) - await GetFlows(API_VERSION);
DeleteFlow(flowId, api_version) - await DeleteFlow(flowId, API_VERSION);
GetFlowRunsSingleton(flowId, api_version, continuationToken = undefined) - await GetFlowRunsSingleton(flowId, API_VERSION);
GetRunHistoryData(flowId, runId, api_version, continuationToken = undefined) - await GetRunHistoryData(flowId, runId, API_VERSION);
GetPrompts(api_version, continuationToken = undefined) - await GetPrompts(API_VERSION);
DeletePrompt(promptId, api_version) - await DeletePrompt(promptId, API_VERSION);
mcp_EnvironmentManagement(queryRequest = undefined, sessionId = undefined) - await mcp_EnvironmentManagement();
mcp_Governance(queryRequest = undefined, sessionId = undefined) - await mcp_Governance();

All 176 examples are generated from powerplatformadminv2.js. Destructive tenant actions such as delete, disable, failover, restore, quarantine, and capacity allocation should only run with clear user intent.

Connection Reference

"connectionReferences": {
  "sqlConnection": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_sql",
    "displayName": "SQL Server",
    "dataSources": ["sql"],
    "dataSets": {}
  }
}

Helper Coverage

dist/connectors/sql.js retries the data-source names sql, Sql, and SQL.
The wrapper includes inline metadata for all SQL actions it exposes.
The Power Apps runtime special-cases shared_sql, so do not hand-roll SQL connector paths.
server and database default to "default" when not supplied.

Action Examples

Action	Example
`callSqlOperation(operationName, parameters)`	`await callSqlOperation('GetTables_V2', { body: { server: 'default', database: 'default' } });`
`getSqlTables({ server, database })`	`await getSqlTables({ server: 'default', database: 'default' });`
`getSqlRows({ server, database, table, filter, orderBy, top, select })`	`await getSqlRows({ table: '[dbo].[Employees]', filter: "Department eq 'Engineering'", top: 50, orderBy: 'LastName asc' });`
`getSqlRow({ server, database, table, id })`	`await getSqlRow({ table: '[dbo].[Employees]', id: 42 });`
`insertSqlRow({ server, database, table, item })`	`await insertSqlRow({ table: '[dbo].[Employees]', item: { FirstName: 'Jane', LastName: 'Doe', Department: 'Engineering' } });`
`updateSqlRow({ server, database, table, id, item })`	`await updateSqlRow({ table: '[dbo].[Employees]', id: 42, item: { Department: 'Product' } });`
`deleteSqlRow({ server, database, table, id })`	`await deleteSqlRow({ table: '[dbo].[Employees]', id: 42 });`
`executeSqlQuery({ server, database, query })`	`await executeSqlQuery({ query: "SELECT TOP 10 * FROM [dbo].[Employees] WHERE Department = 'Engineering'" });`
`executeSqlStoredProcedure({ server, database, procedure, parameters })`	`await executeSqlStoredProcedure({ procedure: '[dbo].[usp_GetTeamMembers]', parameters: { TeamId: 5 } });`

Supported Raw Actions

All SQL connector actions wired by the wrapper

GetTables_V2
GetItems_V2
GetItem_V2
PostItem_V2
PatchItem_V2
DeleteItem_V2
ExecutePassThroughNativeQuery_V2
ExecuteProcedure_V2

Screenshot: SQL Server connector in action

Connection Reference

"connectionReferences": {
  "autoreview": {
    "id": "/providers/Microsoft.PowerApps/apis/shared_autoreview",
    "displayName": "AutoReview",
    "dataSources": ["autoreview"],
    "dataSets": {},
    "authenticationType": null,
    "sharedConnectionId": null
  }
}

Helper Coverage

dist/connectors/autoreview.js is the generated source of truth for the connector action names and payloads.
Prefer structured JSON for in-app analysis and POST_file_V2 for generated review or report files.
Use the raw HTTP action only when a dedicated action does not provide the required output.
All actions are available as named exports and through the default AutoReviewService object.

Action Examples

Action	Use
`GET_info()`	`const info = await GET_info();` returns current AutoReview metadata and service information.
`POST_json(body)`	`const review = await POST_json({ properties: flowProperties, configs });` returns machine-readable flow review data.
`POST_file_V2(body)`	`const files = await POST_file_V2({ properties: flowProperties, configs });` generates the current file artifacts.
`POST_diagram(body)`	`const diagram = await POST_diagram({ properties: flowProperties, configs });` returns a rendered flow diagram.
`POST_http(path, body)`	`await POST_http('v2/autoreview', body);` calls a raw AutoReview endpoint.

The legacy POST_file(body) export remains available for compatibility, but new implementations should use POST_file_V2(body).

Demos

Five example apps from `examples`

Demo	Connection	Actions used	What it shows
Dataverse Demo	Dataverse	`listItems`, `createItem`	Simple CRUD starter using the `tasks` table with a small recent-items grid.
Groups Demo	Office 365 Groups	`listMyGroups`	Lists the current user’s groups and renders basic metadata like name, mail, visibility, and description.
My Profile	Office 365 Users	`getMyProfile`, `getUserPhoto`, `getManager`, `getDirectReports`	Builds a profile page with manager and direct reports in one call flow.
Outlook Demo	Office 365 Outlook	`listEmails`	Shows the first 10 inbox emails and includes a fallback if the first response shape is awkward.
SharePoint Demo	SharePoint	`callSharePointOperation`, `listTables`, `getItems`	Loads rows by list name first, then falls back to connector table lookup and list id resolution.

FYI

Gotchas, tips, and things to know

PAC CLI is required

The docs should treat pac auth create, environment selection, and pac code push as first-class setup steps. Without PAC, you cannot deploy or add data sources.

Node.js is a prerequisite

Node.js is required for npm install, npm start, and rebuilding the browser SDK files. Install it before starting.

SharePoint env vars need Dataverse

SharePoint environment variables require a Dataverse connection reference — unlike with standard canvas apps where the SharePoint connector handles it natively.

Connector reference names must match

Names must stay aligned with the values used by the helper files: sharepointonline, Office365Outlook, office365users, office365groups, teams, jira, keyvault, powerplatformadminv2, sql, and autoreview.

Initialize one shared client

Call const client = getClient(ALL_DATA_SOURCES) once and reuse it across the app. Creating multiple clients wastes resources and can cause authentication issues.

Route calls through helpers

Use the provided helpers like execConnector(tableName, operationName, parameters) and unwrapResult to normalize executeAsync results instead of building raw calls.

Use Promise.allSettled for parallel loads

Load multiple resources with Promise.allSettled and surface partial failures via a unified status bar instead of Promise.all which fails fast.

Dataverse entity set names, not display names

Always use entity set names like cr_contacts in code, never display names. The databaseReferences block must have matching entries for every table you touch.

SQL server & database default to "default"

When using the SQL helpers, server and database default to "default". This works when only one SQL connection is configured.

Jira requires the instance URL

All Jira helpers need the jiraInstance parameter (e.g., https://contoso.atlassian.net). This maps to the X-Request-Jirainstance header.

Key Vault uses connected vault context

Pass the secret name only when calling Key Vault helpers. The vault URL comes from the connection reference, not from app code.

Generated files are source of truth

Generated connector files under src/generated/ contain the correct operation names, parameter shapes, and return models. Don't hardcode operation paths yourself.

Initialized sources now reach connectors

initDataSources(...) entries are merged into connector clients, so configured Dataverse tables and runtime connector operations share the same resolved source context.

SDK v1.3.1 improves operation URLs

The bundled SDK now uses declared HTTP methods, normalizes SQL dataset overrides and runtime URLs, validates typed OData function parameters, and returns record counts when explicitly requested.

Use the sample custom agent and skills in VS Code

Download AI resources

What `codeapp.agent.md` is

The sample `codeapp.agent.md` file defines an implementation-focused Copilot agent for Power Apps code-first work: Dataverse CRUD, connector setup, environment variables, deployment, decision logging, and app scaffolding.

In VS Code, custom agents are Markdown files with the `.agent.md` extension. Once the file is placed in a supported agent folder, it appears in the Copilot Chat agents picker and can be used like any other specialized agent.

VS Code setup

Place the sample agent file in `.github/agents/codeapp.agent.md` for workspace-wide discovery, or create a user agent through the Chat Customizations editor.
Open Copilot Chat, use the agents dropdown or type `/agents`, and select `codeapp` after VS Code discovers the file.
Place skill folders under `.github/skills/<skill-name>/SKILL.md` so VS Code can load them automatically or expose them as slash commands.
Use `/skills` to inspect available skills, or invoke one directly with commands such as `/dataverse`, `/sharepoint`, or `/office365-outlook`.

Recommended workspace layout

.github/
  agents/
    codeapp.agent.md
  skills/
    autoreview/SKILL.md
    connections/SKILL.md
    dataverse/SKILL.md
    docs/SKILL.md
    docs/docs-template.html
    environment-variables/SKILL.md
    frontend-design/SKILL.md
    jira/SKILL.md
    keyvault/SKILL.md
    logicflows/SKILL.md
    office365-groups/SKILL.md
    office365-outlook/SKILL.md
    office365-users/SKILL.md
    power-platform-admin-v2/SKILL.md
    security-review/SKILL.md
    sharepoint/SKILL.md
    sql/SKILL.md
    start/SKILL.md
    teams/SKILL.md

The downloadable templates come from the repo's AI/ folder. Move or copy the agent and skill files into .github/agents/ and .github/skills/ if you want VS Code to discover them automatically in your workspace.

Sample	VS Code name	Use in chat
`codeapp.agent.md`	`codeapp`	Select the `codeapp` agent for implementation-oriented Code App work with skill loading, connector-aware guidance, and a persistent `dist/config/decision-log.md`.
`autoreview/`	`autoreview`	Use for Power Automate flow reviews, structured JSON results, generated review files, diagrams, and raw AutoReview requests.
`connections/`	`connections`	Use when wiring connector references, data source names, and shared connection setup across the app.
`dataverse/`	`dataverse`	Use for entity-set registration, CRUD patterns, unbound actions, relationships, explicit paging, and Dataverse-backed environment variable reads.
`docs/`	`docs`	Use for evidence-based Code App documentation in Markdown or HTML, including the reusable HTML docs template.
`environment-variables/`	`environment-variables`	Use for schema-name driven runtime configuration, including a single object-type variable loaded and parsed through `dist/config/app-config.js`.
`frontend-design/`	`frontend-design`	Use when you want stronger UI direction, layout refinement, and less generic-looking frontend output.
`jira/`	`jira`	Use for Jira issue, project, task, and Jira-instance aware helper flows.
`keyvault/`	`keyvault`	Use for Azure Key Vault keys, secrets, metadata, version access, encryption, and decryption helpers.
`logicflows/`	`logicflows`	Use for adding or invoking solution-aware Power Automate flows through generated services or `callFlow(...)`.
`office365-groups/`	`office365-groups`	Use for Microsoft 365 group listings, members, and event-related helper flows.
`office365-outlook/`	`office365-outlook`	Use for mail, calendar, contacts, rooms, mailbox settings, and raw Outlook action guidance.
`office365-users/`	`office365-users`	Use for profile, manager, direct reports, photos, search, and user document helpers.
`power-platform-admin-v2/`	`power-platform-admin-v2`	Use for Power Platform tenant administration, environments, governance, capacity, billing, cloud flows, Copilot agents, and Power Pages operations.
`security-review/`	`security-review`	Use for evidence-based security reviews of shipped Code Apps using the Microsoft managed-platform threat model.
`sharepoint/`	`sharepoint`	Use for list, attachment, and library operations with exact site URLs and list IDs from app config or environment variables.
`sql/`	`sql`	Use for SQL table discovery, row CRUD, native queries, and stored procedure execution.
`start/`	`start`	Use for new Code App setup, theme decisions, optional five-option mockups, and mockup-to-production implementation.
`teams/`	`teams`	Use for teams, channels, chats, mentions, notifications, and message posting flows.

Skills load on demand

VS Code first reads the `name` and `description` from the skill frontmatter, then loads the full `SKILL.md` only when the task or slash command matches.

Slash command or automatic load

You can call a skill directly with `/skill-name`, or let Copilot load it automatically when the description matches your task.

Folder name must match `name:`

VS Code skill discovery expects the parent folder and the `name` field in `SKILL.md` to match. Review copied samples before relying on them.

Admin actions need clear intent

The Power Platform Admin V2 skill treats destructive tenant operations as high impact and preserves generated validation flags where available.

Review the shipped app

The security review skill focuses on concrete client-side Code App risks while respecting the authentication and infrastructure controls owned by the Microsoft managed platform.

Use diagnostics when discovery fails

If the agent or skills do not appear, open the Chat Customizations editor or the Chat diagnostics view to verify the folder location, frontmatter, and discovery settings.

Blog

Articles, tutorials, and updates

Getting Started dev.to

Power Apps — A Cooler Way to Use Code Apps

An introduction to using CodeAppJS to build Power Apps code apps with vanilla JavaScript instead of React. Covers setup, configuration, and first deployment.

Read article →

Code App Plus

How to Create Your Own AI Coding Agent

YBuilding a bespoke AI coding agent for Power Platform Code Apps—using custom system prompts, skills, and a VS Code extension—to overcome the limitations of general LLMs in your highly niche vanilla‑JavaScript workflow and to consistently capture, refine, and reuse all your hard‑won learnings..

Read article →

Dataverse

Read and Write to Dataverse

Learn how to interact with Dataverse tables, perform CRUD operations, and leverage the Dataverse API for your Power Apps code apps.

Read article →

Coming Soon

Building a Outlook App

Step by step guide to creating an Outlook integration app using CodeAppJS, including reading, sending emails, and calendar overview

Coming soon

SharePoint

Read and Write to SharePoint

Connect to SharePoint lists and libraries, perform CRUD operations, and manage documents from your code app.

Read article →

Coming Soon

Using AI to Create CodeApp.js apps

Learn how to leverage AI to streamline the development of CodeApp.js applications, including VS Code setup, prompts, and debugging.

Coming soon

Article

Blog article

Change Log

Version history and release notes

Version	Changes	Download
v0.0.0	Launch version.	codeapp-js.zip
v0.1.1	Consolidation of codeapp.js file, improved context handling.	codeapp-js.zip
v0.2.1	Improved Skill.md files, debugger added, fixed unbound action.	codeapp-js-v021.zip
v0.2.2	Fixed missing Outlook actions. Added new Outlook demo.	codeapp-js-v022.zip
v0.3.0	Added Teams, Jira, and Azure Key Vault connections. New SQL Server connector. Updated documentation site with dark mode, blog section, and comprehensive connector examples.	codeapp-js-v030.zip
v0.3.1	Bug fix Outlook, added extra actions.	codeapp-js-v030.zip
v1.0.1	Broke up codeapp.js into multiple files for better maintainability. Updated all actions for more robust performance. Extended actions for all connectors. Created agent and skill files for AI development.	codeapp-js-v101.zip
v1.0.2	Fix start and frontend-design skills.	codeapp-js-v101.zip
v1.1.0	Updated connector.js files to align with the Microsoft CLI approach, enabling quicker development of additional connectors. Updated skills for better performance.	codeapp-js-v110.zip
v1.1.1	Updated the SharePoint connector and skill for additional functions like `CreateRawFile`. Improved the debugger by passing root functions instead of showing each as separate entries.	codeapp-js-v111.zip
v1.1.2	Updated the SharePoint connector and skill for additional functions like attachments. Improved the agent file.	codeapp-js-v112.zip
v2.0.0	Updated to SDK v1.1.1, enabling Power Automate flows to be called in the app. Added the flow demo and a new Agile Poker update.	codeapp-js-v200.zip
v2.0.1	Update to Teams connector, agent file and start skill..	codeapp-js-v201.zip
v2.1.0	Added the Power Platform for Admins V2 connector with searchable examples for all 176 generated operations. Added Power Platform Admin V2 and Code App security review AI skills, plus a downloadable AI resources bundle.	codeapp-js-v210.zip
v2.1.1	Added docs skill with html or markdown templates.	codeapp-js-v211.zip
v2.1.2	Added chart.js and mermaid.js libraries. Updated agent file, rebuilt environment variables. Introduced app-config.js file. Updated to SDK v1.1.3. Updated SharePoint and Dataverse skills. Created security review skill.	codeapp-js-v212.zip