· 1 observation
Technical updates · 1
Package or technical metadata updated
View technical comparison →CrowdStrike v1.7.1
Build Falcon Foundry apps
From the developer
Not specified in the available declarations: limitations, pricing & account requirements.
Create a Falcon Foundry app
Developer declarations; not independently tested. Listing last checked Nov 22, 2026. Package observed Nov 21, 2026.
From the marketplace listing
Create, validate, deploy, and troubleshoot Falcon Foundry apps with specialized guidance for UI, functions, collections, Falcon Fusion SOAR workflows, security, and OpenAPI integrations.
Language: English · Automatically detected from descriptions.
· 1 observation
Package or technical metadata updated
View technical comparison →· 16 observations
Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30 tags: [foundry, ui, react, vue, shoelace] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.7.1 updated: 2026-11-10 tags: [foundry, ui, react, vue, shoelace] author: CrowdStrike license: MIT compatibility: Claude...
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.7.0 updated: 2026-10-30 tags: [foundry, debugging, cli, deployment, artifacts, functions, logs, execution] author: CrowdStrike license: MIT compatibility:...” to “1.7.1 updated: 2026-11-10 tags: [foundry, debugging, cli,...
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Skill instructions changed from “1.7.0 updated: 2026-10-30” to “1.7.1 updated: 2026-11-10”.
View comparison →Package or technical metadata updated
View technical comparison →Package or technical metadata updated
View technical comparison →· 15 observations
Full description changed from “Fusion SOAR", "add an on-demand workflow", runs `foundry workflows create`, or needs help with” to “Falcon Fusion SOAR", "add an on-demand workflow", runs `foundry workflows create`, or needs help with Falcon”. Supporting files updated; open the comparison for details. Skill...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, ui, react, vue, shoelace] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.7.0 updated: 2026-10-30 tags: [foundry, ui, react, vue,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, oauth, rbac, xss, csp] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.7.0 updated: 2026-10-30 tags: [foundry, oauth, rbac, xss, csp]...
View comparison →Skill instructions changed from “1.6.0 updated: 2026-10-01” to “1.7.0 updated: 2026-10-30”.
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, functions, falcon-api, falconpy, gofalcon] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0...” to “1.7.0 updated: 2026-10-30 tags: [foundry, functions, falcon-api,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, functions, serverless, python, go, execution, debugging, logs, testing] author: CrowdStrike license: MIT...” to “1.7.0 updated: 2026-10-30 tags: [foundry, functions, serverless,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, e2e, playwright, testing] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.7.0 updated: 2026-10-30 tags: [foundry, e2e, playwright,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, lifecycle, cli, deployment] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.7.0 updated: 2026-10-30 tags: [foundry, lifecycle, cli,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, debugging, cli, deployment, artifacts, functions, logs, execution] author: CrowdStrike license: MIT compatibility:...” to “1.7.0 updated: 2026-10-30 tags: [foundry, debugging, cli,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, collections, json-schema, nosql] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata:...” to “1.7.0 updated: 2026-10-30 tags: [foundry, collections,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, openapi, api, workflows] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.7.0 updated: 2026-10-30 tags: [foundry, openapi, api,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.6.0 updated: 2026-10-01 tags: [foundry, ai, agents, knowledge-bases, charlotte, agent-tools] author: CrowdStrike license: MIT compatibility: Claude Code...” to “1.7.0 updated: 2026-10-30 tags: [foundry, ai, agents,...
View comparison →Privacy policy url added: “https://www.crowdstrike.com/en-us/legal/privacy-notice/”. Terms of service url added: “https://www.crowdstrike.com/en-us/legal/terms-conditions/”. Declared skill added: “app-audit”. Declared skill added: “app-upgrades”. 3 more changes in the comparison.
View comparison →Package or technical metadata updated
View technical comparison →· 1 observation
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →· 2 observations
Package or technical metadata updated
View technical comparison →Package or technical metadata updated
View technical comparison →· 14 observations
Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, workflows, fusion-soar, yaml] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.6.0 updated: 2026-10-01 tags: [foundry, workflows, fusion-soar, yaml] author: CrowdStrike license: MIT...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, ui, react, vue, shoelace] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.6.0 updated: 2026-10-01 tags: [foundry, ui, react, vue,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, oauth, rbac, xss, csp] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.6.0 updated: 2026-10-01 tags: [foundry, oauth, rbac, xss, csp]...
View comparison →Skill instructions changed from “1.5.0 updated: 2026-08-19” to “1.6.0 updated: 2026-10-01”.
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, functions, falcon-api, falconpy, gofalcon] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0...” to “1.6.0 updated: 2026-10-01 tags: [foundry, functions, falcon-api,...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, functions, serverless, python, go, execution, debugging, logs, testing] author: CrowdStrike license: MIT...” to “1.6.0 updated: 2026-10-01 tags: [foundry, functions, serverless,...
View comparison →Skill instructions changed from “1.5.0 updated: 2026-08-19” to “1.6.0 updated: 2026-10-01”.
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, lifecycle, cli, deployment] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.6.0 updated: 2026-10-01 tags: [foundry, lifecycle, cli,...
View comparison →Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, debugging, cli, deployment, artifacts, functions, logs, execution] author: CrowdStrike license: MIT compatibility:...” to “1.6.0 updated: 2026-10-01 tags: [foundry, debugging, cli, deployment, artifacts, functions, logs, execution] author:...
View comparison →Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, collections, json-schema, nosql] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata:...” to “1.6.0 updated: 2026-10-01 tags: [foundry, collections, json-schema, nosql] author: CrowdStrike license: MIT compatibility:...
View comparison →Supporting files updated; open the comparison for details. Skill instructions changed from “1.5.0 updated: 2026-08-19 tags: [foundry, openapi, api, workflows] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category:...” to “1.6.0 updated: 2026-10-01 tags: [foundry, openapi, api,...
View comparison →Declared skill added: “ai-agents-development”. Version changed from “1.5.0” to “1.6.0”.
View comparison →Package or technical metadata updated
View technical comparison →Finding similar plugins… Results will appear here automatically.
Browse plugins →--- name: ai-agents-development description: Build AI agents and knowledge bases for Falcon Foundry apps. TRIGGER when user asks to "create an AI agent", "add a Foundry agent", "build a knowledge base", "give my agent documents", "expose a collection as an agent tool", "expose an API operation to an agent", "put my agent in Charlotte", "expose an agent as a tool for other agents", "delete an agent or knowledge base", runs `foundry agents create`, `foundry agents delete`, `foundry knowledge-bases create`, or `foundry knowledge-bases delete`, or needs help with the `ai.agents` / `ai.knowledge_bases` manifest blocks, agent system prompts, agent input/output formats, agent exposure, or agent tool references. DO NOT TRIGGER for Fusion SOAR workflow YAML — use workflows-development. DO NOT TRIGGER for serverless function handlers — use functions-development. DO NOT TRIGGER for designing a collection schema itself — use collections-development, then return here to wire the collection up as an agent tool. version: 1.7.1 updated: 2026-11-10 tags: [foundry, ai, agents, knowledge-bases, charlotte, agent-tools] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: ai --- # Foundry AI Agents and Knowledge Bases > Create knowledge bases before the agents that reference them, and scaffold both with the CLI. > **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination. An **AI agent** is a Foundry artifact that pairs a system prompt with a model, a set of tools, and optional knowledge bases. A **knowledge base** is a named bundle of files the agent can draw on. Both live under a single `ai:` block in `manifest.yml`. Agents are the only consumer of knowledge bases. A knowledge base on its own does nothing; a collection or API integration becomes agent-usable only when it is exposed as a tool and named in the agent's `tools` list. ## Build Order Is Mandatory ``` 1. Collections / API integrations (if the agent needs them as tools) 2. Knowledge bases → foundry knowledge-bases create 3. Agents → foundry agents create (exposure via --expose-* flags) 4. Hand-edit ai.agents[].model / .tools (no CLI flags exist for these two) ``` **Create knowledge bases first.** `foundry agents create --knowledge-bases X` validates that `X` is already in the manifest and fails the whole command otherwise: ``` agent "my_agent" references knowledge base "X" which is not defined in the manifest ``` The agent directory is rolled back, so nothing is left half-created. ## Naming and Description Constraints Both artifacts share the CLI's create-time validators, which bite constantly: **names are 5–100 chars** (must start alphanumeric; `kb`, `agent`, `bot` all fail), **descriptions 3–500 chars** when present (`-d "x"` fails), agent names unique among agents and KB names among KBs. KBs are the one asymmetry — `knowledge-bases create` enforces the 5-char floor, but the *manifest* validator accepts a KB name as short as 1 character (and no longer checks the description), so a short name already in the manifest passes `apps validate`. The on-disk directory is a sanitized form of the name (every char outside `[a-zA-Z0-9-_]` → `_`, then leading/trailing `_` trimmed): `--name "Threat Intel Docs"` yields `knowledge-bases/Threat_Intel_Docs/` and records `path: Threat_Intel_Docs`; the manifest resolves files against `path`, never `name`. Full regex/length table: [references/manifest-schema.md](references/manifest-schema.md#shared-validators). ## CLI Scaffolding Both artifacts support `create` and `delete`. There is no `list` or `edit`. To change an agent beyond the [allowed hand-edits](#allowed-manifest-hand-edits), delete and recreate it, which orphans the deployed copy in AgentWorks (see below). ```bash # 1.
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 3 — file references are metadata, not package contents.
---
name: api-integrations
description: Expose external APIs to Falcon Foundry via OpenAPI specs. TRIGGER when user asks to "create an API integration", "adapt an OpenAPI spec for Foundry", "expose an API to workflows", "connect to a third-party API", or runs `foundry api-integrations create`. Also trigger when user has an OpenAPI/Swagger spec and wants it working in Falcon Foundry. DO NOT TRIGGER when user wants to call Falcon platform APIs from function code — use functions-falcon-api instead.
version: 1.7.1
updated: 2026-11-10
tags: [foundry, openapi, api, workflows]
author: CrowdStrike
license: MIT
compatibility: Claude Code >=1.0
metadata:
category: integration
---
# Foundry API Integrations
> Build API integrations from the vendor's published OpenAPI spec, adapted for Foundry, with its authentication scheme configured.
>
> For `api-integrations create`, always include `--description` (50 characters max) — the CLI still prompts for it even with `--no-prompt` if omitted.
> **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination.
This skill covers exposing external APIs (third-party services or CrowdStrike Falcon APIs) to the Falcon Foundry platform via OpenAPI/Swagger specifications. These integrations make API operations available to Falcon Fusion SOAR workflows, Foundry UI extensions, Foundry Functions, and other Foundry capabilities.
**API integrations are how Foundry manages credentials.** There is no secrets system, no encrypted env vars, and no key vault. When you register an API integration, the platform collects credentials at install time and manages tokens automatically. Change them later under **App catalog > the app > ⋮ > Modify settings**; `development-workflow` covers integrations added after install. This is why functions MUST call third-party REST APIs through `APIIntegrations().execute_command_proxy()` — not via raw HTTP with env vars.
For calling Falcon APIs from within Function code, see **functions-falcon-api** instead.
## Decision Tree
```
What kind of API integration?
External API (Okta, VirusTotal, ServiceNow, etc.)
├── Vendor publishes OpenAPI spec → Download it, adapt for Foundry
└── No vendor spec available → Write minimal spec as last resort
CrowdStrike Falcon API
├── From functions → use functions-falcon-api instead
├── From workflows → use CrowdStrike auto-auth (no spec needed)
└── API family FalconPy does not wrap
→ API integration with oauth2 clientCredentials against /oauth2/token.
The Falcon swagger at assets.falcon.*.crowdstrike.com returns AccessDenied
without console auth, so a minimal spec written from the product docs
is acceptable here — the one case where hand-writing is not a last resort.
```
## Workflow: Download, Adapt, Register
**Always follow this order.** Hosts that load this plugin's hooks enforce adaptation (see the hook safety net below). Antigravity CLI and a skill-symlink install MUST run the script explicitly.
### 1. Download the vendor's spec
**NEVER write an OpenAPI spec from scratch when the vendor publishes one.** Hand-written specs produce incorrect response schemas, miss required parameters, and lack proper security definitions. Download the vendor's spec even if it has hundreds of endpoints — Foundry handles large specs fine. Do NOT rationalize writing a "focused" or "minimal" spec because the vendor spec is big.
1. **Ask the user** if they have a local copy or know where to download it
2. **Browse the repo first, don't guess URLs.** List its YAML and JSON files in one call (`HEAD` is the default branch), then download the spec with `curl`.
```bash
gh api "repos/{owner}/{repo}/git/trees/HEAD?recursive=1" \
--jq '.tree[] | select(.type=="blob" and (.path|test("\\.(ya?ml|json)$"))) | .path'
```
Narrow a long list with `grePreview of the first 4,000 characters. Read full instructions →
Referenced files: 4 — file references are metadata, not package contents.
--- name: app-audit description: Audit an existing Falcon Foundry app for documented anti-patterns and fix the safe ones, like npm audit. TRIGGER when user asks to "audit my Foundry app", "check my app for problems", "review this Foundry app", "scan for anti-patterns", "why might this deploy fail", or runs `audit_app.py`. DO NOT TRIGGER for creating a new app (use development-workflow) or for debugging an error the user already has (use debugging-workflows). version: 1.7.1 updated: 2026-11-10 tags: [foundry, audit, lint, best-practices] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: quality --- # Auditing a Foundry App Run the bundled script against the app directory (the one with `manifest.yml`). It reads the manifest and the files it points to, calls no API, and needs only `pyyaml`: ```bash python3 skills/app-audit/scripts/audit_app.py path/to/app # report python3 skills/app-audit/scripts/audit_app.py path/to/app --json # machine-readable python3 skills/app-audit/scripts/audit_app.py path/to/app --fix # apply the safe fixes, then report ``` It exits `1` when an error-level finding remains. Each finding names the skill and section that explains it; read that section before changing anything. ## What It Checks | Check | Severity | Why | |-------|----------|-----| | `function-count` | warn | More than 20 functions. Each is a separate container build, and a fresh install with 43 failed where the same handlers in 11 functions deployed. | | `handler-name-length` | error | Handler names must be 5 to 64 characters (the CLI's own limits). | | `handler-name-duplicate` | error | Handler names must be unique within a function. | | `request-property-undeclared` | error | A workflow passes a property the function's `request_schema` doesn't declare, so it's silently dropped. | | `response-key-missing` | warn | A workflow reads a `FaaS` output key the handler's `response_schema` doesn't declare. | | `unknown-function-action` | error | A workflow calls `functions.<name>.<handler>` that isn't in the manifest. | | `missing-workflow-integration` | error | A workflow calls a handler that has no `workflow_integration`, so deploy fails. | | `provision-on-install-missing` | warn, fixable | Installing won't create the workflow. Leave it off only when the app provisions the workflow itself through the Workflows API, as rapid-response and scalable-rtr do. | | `provision-on-install-false` | info | Fine when deliberate. | | `pycache-not-ignored` | warn, fixable | A local `__pycache__/` would deploy. The CLI already skips hidden paths like `.venv/`. | | `secret-in-env` | warn | A function reads a key, token, secret, or password from an environment variable, which is visible in app exports. | | `server-url-protocol` | error | An OpenAPI server URL with variables starts with `https://` or `http://`, so the protocol doubles. | | `server-variable-default` | warn | A server variable has a `default` but no `enum`, which renders as a one-value dropdown. | | `ui-not-built` | error | A page or extension has no `dist/`; deploy never builds the UI. | | `ui-stale-build` | warn | `src/` is newer than `dist/`, so deploy would ship the previous build. | | `invalid-file` | error | `manifest.yml`, a workflow, or an API spec it points to doesn't parse, so the checks that read it were skipped. | ## Fixing Findings `--fix` applies only the fixes marked fixable: it adds the `__pycache__` pattern to `ignored:` and `provision_on_install: true` to workflows that lack it. Both are single-line insertions that leave the rest of the file as written. Tell the user what `--fix` will change before running it, and show the diff afterward. Everything else needs judgment, so handle it with the user: - **Undeclared request properties:** add each property to the handler's `request_schema.json`, then redeploy. If the handler has no schema, the function needs one bound at create time (see the `functions-development` skill → Fun
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
--- name: app-upgrades description: Upgrade a Falcon Foundry app that was installed from a template to a newer version of that template, in place. TRIGGER when user asks to "upgrade an app", "update an app installed from a template", "pull the latest template into my app", "update a sample app installed in my CID to the latest version", or gives an app ID plus a newer template archive, directory, or GitHub repo. DO NOT TRIGGER for creating a new app (use development-workflow) or for deploying changes to an app the user develops locally (use development-workflow's deploy steps). version: 1.7.1 updated: 2026-11-10 tags: [foundry, templates, upgrade, deploy] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: deployment --- # Upgrading Template-Installed Apps A Falcon Foundry template installs an app into a CID once. Nothing updates it when the template changes, and deploying the new template as-is creates a second app, because template manifests ship without IDs. This skill copies the installed app's IDs into the new version so `foundry apps deploy` updates the app the customer already has. The template is the source of truth. The app keeps its current name. Changes the customer made after installing are overwritten; artifacts only the customer added are removed. Stop and confirm before anything is removed. **Inputs:** the app ID, and optionally the new version as a `.tar.gz`/`.tgz` or `.zip` archive, an unpacked directory, or `owner/repo[@ref]`. With no version given, the skill finds the template by the app's name and uses its GitHub repo's default branch. The script is `scripts/upgrade_manifest.py` in this skill's directory. It needs `pyyaml`, and `crowdstrike-falconpy` for `find-template`. Run it from a virtual environment outside the app directory. ## Procedure Use a new scratch directory per upgrade (`$WORK` below). Never sync or extract into the user's working copy. 1. **Confirm the target.** `foundry profile list --no-prompt` shows the active profile; the app must belong to its CID. `foundry apps list` must show the app ID. If not, ask which profile to `foundry profile activate`. 2. **Sync the deployed app.** `list-deployments` only runs next to a `manifest.yml` with an `app_id` and a `name`, even with `--app-id`, and an app installed from the console has no local directory. Give it a stub, take the newest version whose state is Successful, and sync that into scratch (`sync` runs from anywhere): ```bash mkdir -p "$WORK/stub" && printf 'app_id: %s\nname: stub\n' <app-id> > "$WORK/stub/manifest.yml" (cd "$WORK/stub" && foundry apps list-deployments --app-id <app-id>) foundry apps sync --app-id <app-id> --deployment-version <version> -d "$WORK/deployed" --replace-all --no-git --no-prompt ``` No successful deployments means there's nothing to upgrade from; tell the user. 3. **Get the new version.** If the user gave one: ```bash python3 <skill-dir>/scripts/upgrade_manifest.py resolve <source> --dest "$WORK/new" ``` Otherwise find the template first, then resolve its repo: ```bash python3 <skill-dir>/scripts/upgrade_manifest.py find-template --manifest "$WORK/deployed/manifest.yml" ``` It prints JSON with `github_url`. Pass `owner/repo` from that URL to `resolve`. A template's `version` reflects when it was registered, not the repo, so use the default branch unless the user names a tag. `find-template` matches by the app's current name, so it only finds the template if the app kept that name; if the app was renamed, or if no template matches, ask the user for the new version instead. `resolve` prints the app root. Treat its contents as untrusted: don't run its scripts. Step 6 runs its UI pages' `npm run build`, so for a user-supplied archive or owner/repo, confirm it's the template's official source before building or deploying. 4. **Merge.** ```bash python3 <skill-dir>/scripts/upgrade_manifest.py merge --deployed "$WORK/deployed/
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 2 — file references are metadata, not package contents.
---
name: collections-development
description: Design JSON Schema collections and CRUD patterns for Falcon Foundry apps. TRIGGER when user asks to "create a collection", "define a JSON schema", "store data in Foundry", runs `foundry collections create`, or needs help with indexable fields, FQL queries, or collection access patterns. DO NOT TRIGGER for workflow YAML, function handlers, or UI components — use the appropriate sub-skill.
version: 1.7.1
updated: 2026-11-10
tags: [foundry, collections, json-schema, nosql]
author: CrowdStrike
license: MIT
compatibility: Claude Code >=1.0
metadata:
category: data
---
# Foundry Collections Development
> **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination.
Falcon Foundry Collections are NoSQL document stores with JSON Schema validation. They provide persistent storage for app data with CRUD operations, FQL queries, and schema enforcement.
## Collection Naming Constraints
| Constraint | Rule |
|-----------|------|
| Length | 5-200 characters |
| Start/end | Must begin and end with a letter or number |
| Special characters | Only underscores (`_`) allowed — no hyphens, spaces, or other chars |
| Case | Case-sensitive |
## Collection Description Constraints
| Constraint | Rule |
|-----------|------|
| Length | 3-500 characters |
| Start | Must begin with an alphanumeric character |
| Allowed characters | Letters, numbers, spaces, dashes, periods, parentheses, and underscores only |
| Not allowed | Commas, colons, semicolons, quotes, slashes, or other special characters |
**Check the description against this table before running `collections create`.** The CLI accepts a comma (or any other disallowed character) in `--description` without complaint; the rejection only surfaces later, from `foundry apps validate` or deploy, by which time the collection is already in the manifest and has to be fixed by hand. Write the description with letters, numbers, spaces, dashes, periods, parentheses, and underscores only.
## Collection Limits
| Resource | Limit |
|----------|-------|
| Single object size | ~50 MB |
| Schema size | 256 KB |
| Object key length | 1-1,000 characters |
| Indexed fields per schema | 10 |
| Objects per collection | No enforced limit |
| Collections per app | No enforced limit |
| Search results per page | 500 max (default 50) |
## JSON Schema Requirements
- **JSON Schema draft 7 only** — newer drafts (`draft/2020-12`, `draft/2019-09`) fail validation
- Schema is auto-versioned: v1.0 on creation, auto-incremented on modification
- `additionalProperties: false` by default — extra fields leak internal data and break type safety. Exception: a collection written with `custom_storage_object_key` whose fields may grow. Schema changes may not reach it after creation (see Common Pitfalls), so ship `true` there
- `x-cs-indexable: true` on individual properties for searchable fields (max 10 per collection)
## CLI Scaffolding
```bash
# Write schema to /tmp/ first — the CLI copies it into collections/
foundry collections create \
--name "my_collection" \
--schema /tmp/schema.json \
--description "App data store" \
--no-prompt \
--wf-expose \
--wf-tags "tag1,tag2"
```
This creates the collection directory, copies the schema, and updates `manifest.yml`. Edit the project copy at `collections/my_collection.json` afterward to refine.
## Exposing a Collection as an Agent Tool
Add `--agent-tools-expose` to let a Foundry AI agent read and write the collection:
```bash
foundry collections create --name "triage_notes" --schema /tmp/schema.json \
--description "Agent triage notes" --agent-tools-expose --no-prompt
```
That writes one block onto the collection's manifest entry:
```yaml
collections:
- name: triage_notes
agent_tools_integration:
exposed: true
```
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
--- name: debugging-workflows description: Systematic troubleshooting for Falcon Foundry CLI errors, manifest validation failures, deploy failures, artifact runtime errors, and development server issues. TRIGGER when user encounters CLI errors, `foundry ui run` not working, deploy failures, authentication issues, function execution failures, "debug my function", "why did this fail", or any unexpected behavior during Foundry app development. Also trigger for headless/CI environment setup failures. version: 1.7.1 updated: 2026-11-10 tags: [foundry, debugging, cli, deployment, artifacts, functions, logs, execution] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: troubleshooting --- # Foundry Debugging Workflows Systematic procedures for diagnosing and resolving common CrowdStrike Falcon Foundry development issues. > **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination. ## Quick Diagnosis ``` What's happening? CLI command hangs ├── In headless/CI environment → Missing --no-prompt or required flags (see Headless section) └── In interactive terminal → Check network/auth with foundry profile list Deploy fails ├── Validation error → Check manifest YAML syntax, then deploy again ├── "Unknown error" → Duplicate workflow name across apps in tenant ├── "no deployable artifacts found" → Diff is only manifest/logo/metadata; deploy needs an artifact change (function/collection/UI/agent). No --force; bundle it or put the logo in the first deploy ├── "Failed" with no reason in the CLI → Falcon console: App manager > app > "Show errors (N)" (per capability) ├── validate says "deployment is currently in progress" → A deploy is still running; poll list-deployments, then retry ├── validate or deploy says "no changes detected" → No packaged file changed since the last deploy (still true right after a failed one). Change a file the deploy packages, not one in ignored: └── Silent failure → Tenant may be missing required module (SKU) for requested scopes foundry ui run fails ├── On new app → Deploy backend capabilities first (API integrations, functions, collections resolve from cloud) ├── Permission errors → Check manifest OAuth scopes, restart server, verify auth └── Blank page / CORS error → noAttr() or base path removed from vite.config.js (see ui-development) Released change doesn't show └── UI fix missing from the app → Grep the built dist; rebuild if it's absent (see Confirm a Fix Is in the Built Bundle) Function execution fails ├── Status 500 + "Server Error" → Check function logs: foundry functions logs <exec_id> ├── Status 202 + no result → Async execution: foundry functions exec status <exec_id> ├── 403 "app is not installed" → Deployed but not released + installed from App Catalog; FalconPy calls need an installed app ├── 401 on every FalconPy call, scopes correct → Client constructed at module scope; move it inside the handler ├── "authorization failed" → Confirm the CLI profile's API client has Apps read + write; if it does, it's a platform permission problem: report the trace ID, don't edit scopes ├── "artifact is not deployed" → Deploy first: foundry apps deploy --no-prompt ├── 404 "no app artifacts found of type FAAS_FUNCTION" right after a deploy → Pin the deployment: add --version <the version deploy printed>, e.g. --version v0.0.4-pre-release ├── No logs available → Wait 5-10 min, then: foundry functions logs <exec_id> --refresh │ └── Still "Log query failed" → Temporarily return the diagnostic values in the handler's response body, deploy a pre-release (don't release it), exec once, then remove them and deploy again so the latest deployment matches the code ├── UI page: repeated 404s on /api2/faas-gateway/entities/execution/v1 in the browser
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 2 — file references are metadata, not package contents.
--- name: development-workflow description: Orchestrates the complete Falcon Foundry app lifecycle from requirements through deployment. TRIGGER when user asks to "create a Foundry app", "build a Foundry app", "plan a Foundry app", runs any `foundry apps` CLI command, or discusses Foundry app architecture. DO NOT TRIGGER when user is working on a specific capability (UI, function, workflow, collection) within an existing app — use the appropriate sub-skill instead. This skill OWNS the entire Foundry development flow. Do not delegate Foundry app creation to superpowers:brainstorming or superpowers:writing-plans — those skills do not know about the Foundry CLI. version: 1.7.1 updated: 2026-11-10 tags: [foundry, lifecycle, cli, deployment] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: orchestration --- # Foundry Development Workflow > This skill owns the Foundry development flow. Follow the **App Creation Flow** below from user prompt to running app, scaffold with `foundry apps create` and related CLI commands, delegate capability-specific content to the Foundry sub-skills, and hand-write only what the CLI can't generate (OpenAPI content, workflow logic, UI code). > > Don't hand Foundry app creation to superpowers:brainstorming or superpowers:writing-plans. They don't know the Foundry CLI and produce plans that hand-write manifest.yml and boilerplate files. They can supplement this flow (TDD discipline, code review), not replace it. > > **CRITICAL: add `--no-prompt` to every command that accepts it** — without it, interactive prompts cause `Error: EOF`. The `create`, `validate`, `deploy`, `release`, and `delete` commands all accept it (`apps delete` also needs `--force-delete`). These reject it and fail with `unknown flag`: `foundry version`, `apps list`, `apps list-deployments`, `ui extensions list-sockets`, and `auth scopes list`. Verify with `foundry <command> --help`. When a command fails, MUST NOT fall back to `mkdir` — fix the command and retry. > > **CRITICAL: All `foundry` app commands MUST run from the app root directory** (where `manifest.yml` lives). The CLI resolves manifest paths relative to `os.Getwd()`, not relative to the manifest's location. Running `foundry apps validate`, `foundry apps deploy`, or `foundry ui run` from a subdirectory (e.g., `ui/extensions/my-ext/`) causes doubled paths and misleading "file not found" errors. Commands that work from anywhere: `foundry version`, `foundry profile *`, `foundry apps list`. This skill coordinates the full Falcon Foundry app lifecycle — from parsing requirements through scaffolding, implementation, and deployment. It delegates capability-specific work to sub-skills that know the platform details. ## Decision Tree ``` What does the user need? Create a new Foundry app └── Follow the App Creation Flow below Upgrade a template-installed app └── app-upgrades Audit an existing app for anti-patterns └── app-audit Add a capability to an existing app ├── API integration → api-integrations ├── Workflow → workflows-development ├── UI page/extension → ui-development ├── Function → functions-development ├── Collection → collections-development ├── AI agent / knowledge base → ai-agents-development └── Falcon API from funcs → functions-falcon-api Execute / test a deployed function ├── "run my function", "execute function" → functions-development ├── "check execution status", "exec status" → functions-development ├── "get function logs", "show logs" → functions-development ├── "list executions" → functions-development ├── "test my function" (function tests.yml) → functions-development └── "run tests", "test cases" → functions-development Debug a function failure ├── "debug my function", "why did it fail" → debugging-workflows ├── "function returning errors" → debugging-workflows └── "no logs available"
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 7 — file references are metadata, not package contents.
---
name: e2e-testing
description: End-to-end testing for Falcon Foundry apps using Playwright and @crowdstrike/foundry-playwright. TRIGGER when user asks to "add e2e tests", "add playwright tests", "write end-to-end tests", "test my app", or mentions "e2e", "playwright", or "end-to-end" in the context of testing a Foundry app. DO NOT TRIGGER during normal app creation, UI development, or function development. This skill is opt-in; not all apps need e2e tests.
version: 1.7.1
updated: 2026-11-10
tags: [foundry, e2e, playwright, testing]
author: CrowdStrike
license: MIT
compatibility: Claude Code >=1.0
metadata:
category: testing
---
# Foundry E2E Testing
End-to-end testing for Falcon Foundry apps using [Playwright](https://playwright.dev/) and the [`@crowdstrike/foundry-playwright`](https://github.com/CrowdStrike/foundry-playwright) library.
The library provides authentication, app install/uninstall, page objects, and configuration so each app only writes its app-specific tests.
> **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination.
## Quick Start
### 1. Create the `e2e/` directory
```
my-foundry-app/
├── e2e/
│ ├── .env # Local credentials (git-ignored)
│ ├── .env.sample # Template for other developers
│ ├── .gitignore
│ ├── package.json
│ ├── playwright.config.ts
│ └── tests/
│ └── foundry.spec.ts
├── manifest.yml
└── ...
```
### 2. `package.json`
Node.js LTS is recommended.
```json
{
"name": "playwright-foundry",
"version": "1.0.0",
"scripts": {
"test": "npx playwright test",
"test:ui": "npx playwright test --ui",
"test:debug": "npx playwright test --debug",
"test:verbose": "DEBUG=true npx playwright test --reporter=list"
},
"type": "commonjs",
"devDependencies": {
"@crowdstrike/foundry-playwright": "0.5.6",
"@types/node": "25.6.0"
}
}
```
**Always pin exact versions** — never use `"latest"`, `"^"`, or `"~"`. Check npm for the current version of each package.
The library brings `@playwright/test`, `@dotenvx/dotenvx`, and `otpauth` as transitive dependencies; don't install them separately.
### 3. `.env`
```sh
FALCON_USERNAME=your.email@company.com
FALCON_PASSWORD=your-password
FALCON_AUTH_SECRET=your-totp-secret
FALCON_BASE_URL=https://falcon.us-2.crowdstrike.com
APP_NAME=your-app-name
```
**Convention for sample apps:** Set `APP_NAME` to match the manifest `name` field, which should match the repo name (e.g., `foundry-sample-functions-python`). This avoids spaces in names and simplifies CI. This is a convention, not a hard requirement.
### 4. `playwright.config.ts`
```typescript
import { defineFoundryConfig } from '@crowdstrike/foundry-playwright';
export default defineFoundryConfig();
```
This gives you the standard 4-project pipeline automatically:
1. **setup**: authenticate and save session state
2. **app-install**: install the app via App Catalog
3. **chromium**: run your tests
4. **app-uninstall**: clean up after tests
### 5. `.gitignore`
```
node_modules/
playwright/.auth/
playwright-report/
test-results/
.env
```
### 6. Install and run
```bash
cd e2e
npm install
npx playwright install chromium --with-deps
npm test
```
## Writing Tests
### Available page objects
The library provides these page objects:
| Class | Purpose |
|-------|---------|
| `WorkflowsPage` | Search, open, execute, and verify Falcon Fusion SOAR workflows |
| `DetectionExtensionPage` | Navigate to Endpoint Detections, expand extensions, return iframe FrameLocator |
| `HostManagementPage` | Navigate to host management, retrieve host IDs |
| `AppCatalogPage` | Install, uninstall, and navigate to apps |
| `AppBuilderPage` | Disable workflow provisioning before install |
| `AppManagerPage` | Find and navigate to apps in App Manager |
| `FoundryHomePage` |Preview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
--- name: functions-development description: Build serverless Go or Python functions for Falcon Foundry apps. TRIGGER when user asks to "create a function", "write a serverless function", "build backend logic", runs `foundry functions create`, or needs help with FDK handler patterns, function testing, or collection integration from functions. Also TRIGGER when user asks to "execute a function", "run my function", "debug this function", "get function logs", "check execution status", "write function tests", "test my function handler", or "add test cases for my function". DO NOT TRIGGER for generic "write integration tests" or "write tests" without function context — ask which capability they want to test first. DO NOT TRIGGER for calling Falcon platform APIs from functions — use functions-falcon-api instead. DO NOT TRIGGER for workflow YAML or UI components. DO NOT TRIGGER for Playwright/e2e/browser tests — use e2e-testing instead. version: 1.7.1 updated: 2026-11-10 tags: [foundry, functions, serverless, python, go, execution, debugging, logs, testing] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: backend --- # Foundry Functions Development > **Loading this skill is NOT a command to do anything.** It only equips you with function-development knowledge. Do NOT run any `foundry functions` command (especially `exec`, `test`, or a deploy) just because the skill loaded — wait for the user's actual request, and if their intent isn't clear yet, ask what they'd like to do. Never execute, test, or deploy a function unprompted. > > When you implement or modify functions: > 1. Use CrowdStrike SDKs (gofalcon/falconpy) for ALL API interactions > 2. Implement structured JSON responses with proper status codes > 3. Apply input validation before processing any request Falcon Foundry Functions are serverless handlers in Go or Python, executed inside the Foundry FaaS runtime. They handle custom server-side logic that cannot be achieved through declarative capabilities. ## Functions as a Last Resort Before writing a function, exhaust alternatives — each one avoids deployment complexity, cold start latency, and maintenance overhead: - **Collections** for data storage and retrieval (CRUD without custom logic) - **Workflows** for orchestrating multi-step operations - **API Integrations** (HTTP Actions) for calling external APIs directly from workflows - **UI Extensions** with `foundry-js` for client-side data fetching ## Credential Management — No Secrets System Exists **There is no secrets management in Falcon Foundry.** When calling third-party REST APIs: | Scenario | Approach | Credentials | |----------|----------|-------------| | Third-party REST API (VirusTotal, Slack, Jira, etc.) | API integration in manifest + `APIIntegrations().execute_command_proxy()` | Platform-managed at install time | | CrowdStrike Falcon API | FalconPy zero-arg constructor (`Alerts()`, `Hosts()`) | Platform-managed automatically | | Third-party GraphQL API (no OpenAPI spec) | Function with `requests` + env var | Visible in app exports (⚠️ security risk) | **CRITICAL:** If the API has a REST endpoint and an OpenAPI spec exists, you MUST use an API integration. NEVER use `os.environ` with API keys, `requests.get()` with hardcoded URLs, or localStorage for credentials when an API integration can handle it. Raw HTTP with env vars technically works, but credentials are unencrypted and visible in app exports. ## Reference Files This skill is split across multiple files. Consult these for full examples: | Task | Reference | |------|-----------| | Python handler, collection CRUD, error class, lookup file uploads, LogScale ingestion | [references/python-patterns.md](references/python-patterns.md) | | Go FDK handler, Falcon client auth, collection CRUD, alerts handler | [references/go-patterns.md](references/go-patterns.md) | | Too many functions: build failures, consolidation | [references/function-count-and-build-time.md](re
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 6 — file references are metadata, not package contents.
---
name: functions-falcon-api
description: Call CrowdStrike Falcon platform APIs (detections, alerts, hosts, RTR) from within Foundry function handlers. TRIGGER when user asks to "call Falcon APIs from a function", "use FalconPy in a function", "use gofalcon in a function", or needs to integrate Falcon platform APIs within serverless function code. DO NOT TRIGGER when user wants to expose external third-party APIs to Foundry — use api-integrations instead.
version: 1.7.1
updated: 2026-11-10
tags: [foundry, functions, falcon-api, falconpy, gofalcon]
author: CrowdStrike
license: MIT
compatibility: Claude Code >=1.0
metadata:
category: backend
---
# Falcon API Integration in Functions
> Call Falcon APIs through the CrowdStrike SDKs inside Foundry function handlers. Authentication is automatic with the FDK handler pattern.
>
> The FalconPy `Detects` class is **deprecated**: it still ships, but its API returns 405. Do not import it. Use `Alerts` for detection queries.
> **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination.
This skill covers calling CrowdStrike Falcon APIs from within Foundry functions (serverless Go or Python code). Authentication is completely automatic when code runs inside Foundry function handlers — the platform handles all OAuth flows, token management, and credential injection.
For exposing external APIs to Foundry via OpenAPI specs, see **api-integrations** instead.
> **🚫 DEPRECATED API — NEVER USE:**
>
> **Do NOT import or use the `Detects` class from FalconPy.** The Detects API (`/detects/entities/detects/v2`) is deprecated and returns **405 Method Not Allowed**. Any code using `Detects()`, `query_detects()`, or `get_detect_summaries()` will fail at runtime.
>
> **Use instead:** `from falconpy import Alerts` with `query_alerts_v2()` / `get_alerts_v2()`. Filter by `product:'epp'` to scope to endpoint detections.
## Reference Files
| Topic | Reference |
|-------|-----------|
| Retry, worker threads, shared-CID listing, Workflows API as the app, enrichment | [references/advanced-patterns.md](references/advanced-patterns.md) |
## Python: Zero-Argument Authentication
FalconPy Service Classes require zero arguments when called inside Foundry Function handlers. The `crowdstrike.foundry.function` FDK provides the handler decorator that enables automatic authentication:
```python
from logging import Logger
from typing import Any, Dict, Union
from crowdstrike.foundry.function import Function, Request, Response
from falconpy import Alerts, Hosts
func = Function.instance()
@func.handler(method='GET', path='/api/alerts')
def get_alerts(request: Request, config: Union[Dict[str, Any], None], logger: Logger) -> Response:
falcon = Alerts() # Zero-arg constructor — auth is automatic
limit = min(int(request.params.query.get("limit", ["50"])[0]), 100)
# FQL filter: high-severity alerts from the last 24 hours.
# Combine conditions with '+' (AND); relative times like 'now-24h' are supported.
response = falcon.query_alerts_v2(
filter="severity_name:'High'+created_timestamp:>'now-24h'",
limit=limit,
sort="created_timestamp|desc",
)
if response["status_code"] != 200:
logger.error(f"Failed to query alerts: {response.get('errors')}")
return Response(body={"error": "Failed to fetch alerts"}, code=500)
alert_ids = response.get("body", {}).get("resources", [])
if not alert_ids:
return Response(body={"alerts": []}, code=200)
details_response = falcon.get_alerts_v2(composite_ids=alert_ids)
if details_response["status_code"] != 200:
return Response(body={"error": "Failed to fetch alert details"}, code=500)
alerts = details_response.get("body", {}).get("resources", [])
return Response(body={"alerts": alerts}, code=200)
if __nPreview of the first 4,000 characters. Read full instructions →
Referenced files: 2 — file references are metadata, not package contents.
--- name: fusion-redirect description: TRIGGER when user asks for a "standalone Falcon Fusion workflow" that needs NO Foundry app — just a trigger plus actions that already exist in their CID, with no UI, function, collection, or custom API integration to build. DO NOT TRIGGER when the request needs anything built (a custom action, a UI page, a function, a collection) — that is a Foundry app and development-workflow owns it. This skill exists so the redirect works without hooks and yields to the real Falcon Fusion plugin when both are loaded. version: 1.7.1 updated: 2026-11-10 tags: [foundry, fusion, redirect] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: routing --- # Falcon Fusion Redirect When this skill triggers, the user's request is not a Falcon Foundry task. It is a standalone Fusion workflow and belongs to the sibling Falcon Fusion plugin. ## What to do Do NOT scaffold a Foundry app. Do NOT produce a `manifest.yml`. Do NOT hand-write workflow YAML with placeholder action IDs. Respond with all three: 1. A clear statement that this request does not need a Foundry app 2. The plugin name: **`crowdstrike-falcon-fusion`** 3. How to install it: `/plugin install crowdstrike-falcon-fusion` or https://github.com/CrowdStrike/fusion-skills ## Why this exists The correct tool for a standalone Fusion workflow is the Falcon Fusion plugin. It discovers real action IDs from the live API, validates YAML against the platform schema, and imports and releases to the CID. A redirect skill with no artifact is strictly better than producing a YAML block with placeholder IDs that cannot deploy. When both plugins are loaded, the Fusion plugin's own `workflows` skill matches the same prompt and handles it directly. This skill fires only when the Fusion plugin is absent, ensuring the user is told about it rather than left with an incomplete workaround. ## Distinguishing a redirect from a Foundry workflow | Signal in the prompt | Route | |---|---| | "standalone workflow", "just a workflow", "no app needed" | Here (redirect) | | Uses only existing actions: contain host, Slack, email, print data | Here (redirect) | | Needs a custom API integration, a UI, a function, or a collection built | `development-workflow` (Foundry app) | | Workflow is part of an app already being built | `workflows-development` (sub-skill) | The key test: does the user need something *built* that does not exist yet, or do they need existing pieces *wired together*? Building is Foundry. Wiring is Fusion.
---
name: security-patterns
description: Security patterns for Falcon Foundry apps including OAuth scopes, RBAC, input validation, UI security, and credential management. TRIGGER when user asks to "configure OAuth scopes", "secure a Foundry app", "handle secrets", "add input validation", or needs to review a Foundry app for security concerns (XSS, CSP, credential management). Also trigger during pre-deployment security reviews.
version: 1.7.1
updated: 2026-11-10
tags: [foundry, oauth, rbac, xss, csp]
author: CrowdStrike
license: MIT
compatibility: Claude Code >=1.0
metadata:
category: security
---
# Foundry Security Patterns
> **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination.
Security patterns for Falcon Foundry app development covering authentication, input validation, UI security, and platform-specific considerations. Foundry apps run on a cybersecurity platform — security is a core requirement.
## RBAC (Role-Based Access Control)
| Capability | RBAC Supported |
|-----------|----------------|
| Collections | Yes |
| Dashboards | Yes |
| Functions | Yes |
| UI extensions / pages / navigation | Yes |
| RTR scripts | Yes |
| API integrations | **No** |
| Queries | **No** |
| Workflows | **No** |
### The Permission → Role → Artifact Model
RBAC is three linked pieces the table above doesn't spell out — you need all three or the gate is silently absent.
**1. Permission** (one command, also creates the role):
```bash
foundry auth permissions create \
--key "myapp:access" \
--name "My App Access" \
--description "Access to My App" \
--role-name "My App Operator" \
--role-description "My App operator role" \
--no-prompt
```
**`--key` must be colon-segmented** (`myapp:access`, not a plain word; otherwise `invalid permission key, should be permission segments separated by :`), and **`--description` must be 50 characters or fewer** (`input must be at most 50 characters long`). `--name` needs at least 3 characters and `--role-description` at least 5. The command writes `auth.permissions["myapp:access"]: {id, name, description}` into `manifest.yml` and adds the role to `auth.roles`, with the permission key in its `permissions` list.
> **Prefix the key and role name with your app name.** A generic name (`app:access`, `Operator`) is hard to tell apart from other apps' roles in the console's role list.
**2. Role** — appears automatically under `auth.roles` after step 1; inspect it there, and do NOT run `foundry auth roles create` for it (that would orphan a duplicate role). Reserve standalone `foundry auth roles create` for a role built *independently* of `permissions create` — e.g. one that bundles permission keys that already exist (via `--permissions`); it creates a role but no permission:
```bash
foundry auth roles create --name "Analyst" --permissions "myapp:access" --description "Read-only analyst access" --no-prompt
```
That makes a second role carrying already-created permission keys; it does NOT create a new permission. Use it only when you deliberately want a role separate from the one `permissions create` already made — never to "add" the role from step 1.
**3. Artifact gates** — pass `--permissions "myapp:access"` to `collections create`, `functions create`, `ui pages create`, `ui extensions create`, or `ui navigation add` (CLI 2.1.2), or add the permission **key** to the `permissions:` list the CLI already wrote on an existing artifact ([docs](https://docs.crowdstrike.com/access?ft:originId=w88f0d03)). Edit only that list; leave the generated `path`, `entrypoint`, and `ref` values alone. The page gate is what blocks access; a gate on the navigation link only hides the menu entry (Foundry checks roles on pages, not links), so set both:
```yaml
ui:
pages:
dashboard: # pages is a map kPreview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
--- name: ui-development description: Build UI pages and extensions for Falcon Foundry apps using React or Vue with the Shoelace design system and Foundry-JS. TRIGGER when user asks to "create a UI page", "build a UI extension", "add a Shoelace component", "call an API from the UI", runs `foundry ui pages create` or `foundry ui run`, or needs help with Vite config, Foundry-JS, or Falcon console theming. DO NOT TRIGGER for backend functions, workflow YAML, or collection schemas. version: 1.7.1 updated: 2026-11-10 tags: [foundry, ui, react, vue, shoelace] author: CrowdStrike license: MIT compatibility: Claude Code >=1.0 metadata: category: frontend --- # Foundry UI Development > Build UI with Shoelace components using the `falcon-shoelace` theme (not vanilla Shoelace or raw HTML), and load both the dark and light theme stylesheets so it matches the Falcon console. Use `foundry ui run` for live development, and apply the iframe security patterns to every extension. > **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination. Falcon Foundry UI pages and extensions use React or Vue with the Shoelace design system (Falcon-themed) and Foundry-JS for platform integration. ## Pages vs Extensions If the user doesn't specify page or extension, **ask which they prefer** before scaffolding. Present this table to help them decide: | | UI Pages | UI Extensions | |---|---|---| | **What** | Standalone applications | Console-embedded components | | **Where** | Full-page view in Falcon console | Sidebar widget in detection/host/incident pages | | **Sockets** | N/A | One per extension (see socket table below) | | **Use when** | Complex interactions, multiple views, dashboards | Contextual enrichment, quick-glance data | | **Framework** | Vue, React, or Vanilla JS | Vue, React, or Vanilla JS | ## CLI Scaffolding ```bash # Create a React page foundry ui pages create --name "my-page" --description "Page description" --from-template React --homepage --no-prompt # Create a Vanilla JS page (no npm install or build step needed) foundry ui pages create --name "my-page" --description "Page description" --from-template "Vanilla JS" --homepage --no-prompt # Add navigation entry (separate step — --no-prompt skips this during page creation) foundry ui navigation add --name "My Page" --path / --ref pages.my-page # Create an extension targeting a console socket # REQUIRED: --sockets must be specified — omitting it launches an interactive picker that hangs with Error: EOF # REQUIRED: Use ONLY values from the Extension Socket Locations table below — do NOT guess socket IDs foundry ui extensions create --name "my-ext" --description "Description" --from-template React --sockets "activity.detections.details" --no-prompt # Create a Vanilla JS extension (no npm install or build step needed) foundry ui extensions create --name "my-ext" --description "Description" --from-template "Vanilla JS" --sockets "activity.detections.details" --no-prompt ``` **Vanilla JS** needs no `npm install` or `npm run build`. The importmap loads foundry-js from CDN. Use it for simple extensions that display data or make API calls without complex state management. Deploy works with just the raw `src/` files. > **`--homepage` / `homepage:` is not a navigation link.** It sets the app's root page only and doesn't add a side-menu entry. Only `ui.navigation.links` (via `foundry ui navigation add`) creates a menu item, so an app can be reachable at root yet absent from the menu. Add a nav link for every page you want listed. The blueprint output is deterministic — see [references/blueprint-templates.md](references/blueprint-templates.md) for exact file contents, Shoelace import patterns, and API integration calling examples. **Editing a React blueprint:** put the UI in `src/routes/home.jsx`, which g
Preview of the first 4,000 characters. Read full instructions →
Referenced files: 8 — file references are metadata, not package contents.
---
name: workflows-development
description: Create and configure Falcon Fusion SOAR workflow YAML for Falcon Foundry apps. TRIGGER when user asks to "create a workflow", "build an automation", "configure Falcon Fusion SOAR", "add an on-demand workflow", runs `foundry workflows create`, or needs help with Falcon Fusion YAML syntax, triggers, actions, or variable references. DO NOT TRIGGER for UI pages, functions, or collection schemas — use the appropriate sub-skill.
version: 1.7.1
updated: 2026-11-10
tags: [foundry, workflows, fusion-soar, yaml]
author: CrowdStrike
license: MIT
compatibility: Claude Code >=1.0
metadata:
category: automation
---
# Foundry Workflows Development
> Write every workflow definition in Falcon Fusion YAML, validate step dependencies before running it, and handle failures with conditional routing and action-level flags ([Error Handling](#error-handling)) — Fusion has no `onError` blocks and no built-in retry.
> **Part of a suite.** If `development-workflow` has not already run, and this is a new app or its first capability, load the `development-workflow` skill first — it owns the CLI prerequisite check, scaffolding order, and manifest coordination.
## Prerequisites
- **Workflow Author role** is required in addition to the Falcon Developer role
- Workflows are YAML templates provisioned as active instances (up to **25** per template)
- **`provision_on_install: true` is REQUIRED** in the workflow YAML — treat it as a per-workflow checklist item, not a footnote. With `true`, installing the app creates the workflow in Falcon Fusion SOAR, turned on. With `false`, the deploy is "Successful" and the template is listed in the app's **Logic** section, but installing creates no workflow, so nothing runs until something provisions it (the `/workflows/system-definitions/provision` API). Use `false` deliberately: for a workflow with an action ID you can't verify, which the user finishes in the console (see [Platform Action Fallback Strategy](references/advanced-patterns.md#platform-action-fallback-strategy)), or to let an app install without the credentials a workflow needs, as the sample apps' e2e tests do.
## CLI Scaffolding
```bash
# Write the workflow YAML to /tmp/ first — the CLI copies it into workflows/
foundry workflows create --name "my-workflow" --spec /tmp/workflow.yaml --no-prompt
# After: edit workflows/my-workflow.yml to refine workflow logic
```
### Discover Available Actions and Triggers
```bash
foundry workflows actions view --name "send email" --no-prompt # Look up by name
foundry workflows actions view --name "send email" --no-prompt --output-schema # Output schema
foundry workflows actions view --name "send email" --no-prompt --mock # Mock output
foundry workflows triggers view --no-prompt # List triggers
```
> **Always use `--no-prompt` on `actions view`/`triggers view`** — without it, multiple or partial matches trigger an interactive prompt that fails in headless environments (`Error: no TTY available`); as of CLI 2.1.1 matches are listed non-interactively. The bundled `action_search.py` works without a manifest directory — see [references/action-discovery.md](references/action-discovery.md).
## Workflow Structure
### Trigger + Actions Format (standard)
This is the format produced by `foundry workflows create` and used by many Foundry sample apps — a `trigger:` (with `next:` naming the first action) plus an `actions:` map where each action carries an `id`, `properties`, `version_constraint`, and optional `next:`, closing with `output_fields: []`. See [references/workflow-examples.md](references/workflow-examples.md#standard-trigger-actions-format) for the full canonical YAML (on-demand Okta list → print).
**Trigger types:**
| Type | Format |
|------|--------|
| On demand | `name: On demand`, `type: On demand` |
| Scheduled | `event: Schedule`, `schedule: {time_cycle: "0 */6 * * *", tz: Etc/UTC}` |
**Trigger parameters** (Preview of the first 4,000 characters. Read full instructions →
Referenced files: 8 — file references are metadata, not package contents.
Publisher declarations from the archived package. These are separate from our research and the live service's terms.
Package observed Nov 21, 2026.
plugins_6a8f6d7f7fac819191e3eba5a7a2e0df
Download plugin data (JSON)Plugin details: served from cache. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.