Fetches flowstudio-power-automate-mcp from github/awesome-copilot and configures it for Cursor.
3
Select Cursor when prompted
The CLI shows a list of agents. Use arrow keys and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ────────────────
│ · Cline · Codex · Goose · Windsurf
│ ●Cursor(selected)
│ · Cursor · Aider · Continue
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/flowstudio-power-automate-mcp
Restart Cursor to activate flowstudio-power-automate-mcp. Access via /flowstudio-power-automate-mcp in your agent's command palette.
⚠
Security Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your environment. Always review source, verify the publisher, and test in isolation before production.
This skill lets AI agents read, monitor, and operate Microsoft Power Automate
cloud flows programmatically through a FlowStudio MCP server — no browser,
no UI, no manual steps.
Requires: A FlowStudio MCP subscription (or
compatible Power Automate MCP server). You will need:
MCP endpoint: https://mcp.flowstudio.app/mcp (same for all subscribers)
API key / JWT token (x-api-key header — NOT Bearer)
Power Platform environment name (e.g. Default-<tenant-guid>)
Start every new session with tools/list.
It returns the authoritative, up-to-date schema for every tool — parameter names,
types, and required flags. The SKILL docs cover what tools/list cannot tell you:
response shapes, non-obvious behaviors, and end-to-end workflow patterns.
If any documentation disagrees with tools/list or a real API response,
the API wins.
Recommended Language: Python or Node.js
All examples in this skill and the companion build / debug skills use Python
with urllib.request (stdlib — no pip install needed). Node.js is an
equally valid choice: fetch is built-in from Node 18+, JSON handling is
native, and the async/await model maps cleanly onto the request-response pattern
of MCP tool calls — making it a natural fit for teams already working in a
JavaScript/TypeScript stack.
Language
Verdict
Notes
Python
✅ Recommended
Clean JSON handling, no escaping issues, all skill examples use it
Node.js (≥ 18)
✅ Recommended
Native fetch + JSON.stringify/JSON.parse; async/await fits MCP call patterns well; no extra packages needed
PowerShell
⚠️ Avoid for flow operations
ConvertTo-Json -Depth silently truncates nested definitions; quoting and escaping break complex payloads. Acceptable for a quick tools/list discovery call but not for building or updating flows.
cURL / Bash
⚠️ Possible but fragile
Shell-escaping nested JSON is error-prone; no native JSON parser
TL;DR — use the Core MCP Helper (Python or Node.js) below. Both handle
JSON-RPC framing, auth, and response parsing in a single reusable function.
What You Can Do
FlowStudio MCP has two access tiers. FlowStudio for Teams subscribers get
both the fast Azure-table store (cached snapshot data + governance metadata) and
full live Power Automate API access. MCP-only subscribers get the live tools —
more than enough to build, debug, and operate flows.
Live Tools — Available to All MCP Subscribers
Tool
What it does
list_live_flows
List flows in an environment directly from the PA API (always current)
list_live_environments
List all Power Platform environments visible to the service account
list_live_connections
List all connections in an environment from the PA API
get_live_flow
Fetch the complete flow definition (triggers, actions, parameters)
get_live_flow_http_schema
Inspect the JSON body schema and response schemas of an HTTP-triggered flow
get_live_flow_trigger_url
Get the current signed callback URL for an HTTP-triggered flow
trigger_live_flow
POST to an HTTP-triggered flow's callback URL (AAD auth handled automatically)
update_live_flow
Create a new flow or patch an existing definition in one call
add_live_flow_to_solution
Migrate a non-solution flow into a solution
get_live_flow_runs
List recent run history with status, start/end times, and errors
get_live_flow_run_error
Get structured error details (per-action) for a failed run
get_live_flow_run_action_outputs
Inspect inputs/outputs of any action (or every foreach iteration) in a run
resubmit_live_flow_run
Re-run a failed or cancelled run using its original trigger payload
cancel_live_flow_run
Cancel a currently running flow execution
Store Tools — FlowStudio for Teams Subscribers Only
These tools read from (and write to) the FlowStudio Azure table — a monitored
snapshot of your tenant's flows enriched with governance metadata and run statistics.
Tool
What it does
list_store_flows
Search flows from the cache with governance flags, run failure rates, and owner metadata
get_store_flow
Get full cached details for a single flow including run stats and governance fields
get_store_flow_trigger_url
Get the trigger URL from the cache (instant, no PA API call)
get_store_flow_runs
Cached run history for the last N days with duration and remediation hints
get_store_flow_errors
Cached failed-only runs with failed action names and remediation hints
List all makers (citizen developers) from the cache
get_store_maker
Get a maker's flow/app counts and account status
list_store_power_apps
List all Power Apps canvas apps from the cache
list_store_connections
List all Power Platform connections from the cache
Which Tool Tier to Call First
Task
Tool
Notes
List flows
list_live_flows
Always current — calls PA API directly
Read a definition
get_live_flow
Always fetched live — not cached
Debug a failure
get_live_flow_runs → get_live_flow_run_error
Use live run data
⚠️ list_live_flows returns a wrapper object with a flows array — access via result["flows"].
Store tools (list_store_flows, get_store_flow, etc.) are available to FlowStudio for Teams subscribers and provide cached governance metadata. Use live tools when in doubt — they work for all subscription tiers.
Step 0 — Discover Available Tools
Always start by calling tools/list to confirm the server is reachable and see
exactly which tool names are available (names may vary by server version):
import json, urllib.request
TOKEN ="<YOUR_JWT_TOKEN>"MCP ="https://mcp.flowstudio.app/mcp"defmcp_raw(method, params=None, cid=1): payload ={"jsonrpc":"2.0","method": method,"id": cid}if params: payload["params"]= params
req = urllib.request.Request(MCP, data=json.dumps(payload).encode(), headers={"x-api-key": TOKEN,"Content-Type":"application/json","User-Agent":"FlowStudio-MCP/1.0"})try: resp = urllib.request.urlopen(req, timeout=30)except urllib.error.HTTPError as e:raise RuntimeError(f"MCP HTTP {e.code} — check token and endpoint")from e
return json.loads(resp.read())raw = mcp_raw("tools/list")if"error"in raw:print("ERROR:", raw["error"]);raise SystemExit(1)for t in raw["result"]["tools"]:print(t["name"],"—", t["description"][:60])
Core MCP Helper (Python)
Use this helper throughout all subsequent operations:
import json, urllib.request
TOKEN ="<YOUR_JWT_TOKEN>"MCP ="https://mcp.flowstudio.app/mcp"defmcp(tool, args, cid=1): payload ={"jsonrpc":"2.0","method":"tools/call","id": cid,"params":{"name": tool,"arguments": args}} req = urllib.request.Request(MCP, data=json.dumps(payload).encode(), headers={"x-api-key": TOKEN,"Content-Type":"application/json","User-Agent":"FlowStudio-MCP/1.0"})try: resp = urllib.request.urlopen(req, timeout=120)except urllib.error.HTTPError as e: body = e.read().decode("utf-8", errors="replace")raise RuntimeError(f"MCP HTTP {e.code}: {body[:200]}")from e
raw = json.loads(resp.read())if"error"in raw:raise RuntimeError(f"MCP error: {json.dumps(raw['error'])}") text = raw["result"]["content"][0]["text"]return json.loads(text)
Common auth errors:
HTTP 401/403 → token is missing, expired, or malformed. Get a fresh JWT from mcp.flowstudio.app.
HTTP 400 → malformed JSON-RPC payload. Check Content-Type: application/json and body structure.
›Access to product documentation and roadmap tools (Jira, Notion, etc.)
›Understanding of product management frameworks (RICE, Jobs-to-be-Done, etc.)
›Stakeholder contact information and communication channels
Time Estimate
30-60 minutes to see productivity improvements
Steps
1Install product management skill
2Start with user story generation for known feature
3Progress to competitive analysis: research 2-3 competitors
4Use for roadmap prioritization: apply RICE/ICE scoring
5Draft stakeholder communications and refine based on feedback
6Build template library for recurring PM tasks
7Share effective prompts with product team
Common Pitfalls
⚠Not validating competitive research—verify facts before sharing
⚠Accepting user stories without involving engineering team
⚠Over-relying on frameworks without qualitative judgment
⚠Not customizing outputs to company culture and communication style
⚠Skipping stakeholder validation of generated requirements
Best Practices
✓ Do
+Validate research and competitive analysis with real data
+Collaborate with engineering when generating technical requirements
+Customize frameworks and templates to your company context
+Use skill for first drafts, refine with stakeholder input
+Document successful prompt patterns for PM tasks
+Combine AI efficiency with human judgment and intuition
✗ Don't
−Don't publish competitive analysis without fact-checking
−Don't finalize user stories without engineering review
−Don't make prioritization decisions solely on AI scoring
−Don't skip customer validation of generated requirements
−Don't ignore company-specific context and culture
💡 Pro Tips
★Provide context: company goals, constraints, customer feedback
★Ask for alternatives: 'Show 3 ways to prioritize this roadmap'
★Request stakeholder-specific formatting: 'Executive summary vs. engineering spec'
★Use skill for 70% generation + 30% customization to company needs
When to Use This
✓ Use when
Use for user story writing, competitive research, roadmap prioritization, stakeholder communication, and PRD drafting. Best for reducing repetitive documentation and research work.
✗ Avoid when
Avoid for strategic product vision (requires deep customer empathy), pricing decisions (needs market and financial expertise), or when face-to-face customer discovery is more valuable than speed.
Learning Path
1Basic: user stories, feature specs, status updates
