@featureflip/mcp
Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.
Needs to start: nothing
Returns a result when called with no setup: 0 of 2 tools tried
Contacts while installing and starting: nothing
Its tool definitions changed since version 0.10.0. If you approved the earlier ones, read them again.
What it contacted
Nothing besides the npm registry it was installed from. Watched from outside its sandbox while it was installed and started with no input. Its tools may still contact things when called.
Starting it
npx -y @featureflip/mcp@0.10.1
Installing a package runs its code. Use a sandbox for anything you have not read.
Calling its tools
2 tools that take no input and look read-only were called once with nothing. 0 returned a result.
list_projects | No usable answer tool reported an error: Error: FEATUREFLIP_TOKEN is required. Create one in the Featureflip dashboard — Settings → API Tokens (personal token, ffp_...) or Organ |
list_webhooks | No usable answer tool reported an error: Error: FEATUREFLIP_TOKEN is required. Create one in the Featureflip dashboard — Settings → API Tokens (personal token, ffp_...) or Organ |
During the calls it contacted nothing it had not already contacted.
Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.
What its tools tell an agent
In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.
1 tool with commands in capitals or very long text
- Gives the agent orders in
manage_webhook:ventTypes. create and rotate_secret return a secret that is NEVER shown again: relay it to the user verbatim so they can store it (for a GenericHttp subscription onl
Common and usually harmless: it is how many makers stress how a tool should be used.
Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.
Tools
list_projects limit, cursor
List projects in the Featureflip organization. Paginated: pass cursor from next_cursor to continue.
manage_project action, project, key, name, description
Create a project, or change its name/description. action=create needs key + name; action=update needs project and changes only the fields you pass (description: "" clears it). The key is immutable. Projects cannot be deleted from here.
set_default_flag_lifetime project, days, preview
Set how many days a temporary flag with no expiry date of its own lives before it counts as expired, or pass days: null to remove the default. Advisory only: evaluation never changes. Pass preview: true first to see how many flags would newly be, or stop being, past expiry without changing anything. Setting a value is refused with FEATURE_NOT_ENABLED when the organization's plan lacks it; removal is always allowed. The current value is defaultFlagLifetimeDays in list_projects.
list_environments project, limit, cursor
List the environments of a project (e.g. development, staging, production).
manage_environment action, project, environment, key, name, color, sortOrder, require_change_reason, require_confirmation, reason
Create an environment in a project, or change its name, color or sort order. action=create needs key + name; action=update needs environment and changes only the fields you pass. The key is immutable. Environments cannot be deleted from here. require_change_reason makes every write to the environment need a reason, and require_confirmation makes the dashboard ask for confirmation first; omit either on update to leave it unchanged. Turning either off needs an Admin or Owner token and a reason. A new environment needs an SDK key before apps can use it (manage_sdk_key).
36 more tools
list_sdk_keys project, environment, limit, cursor
List the SDK keys of one environment: id, name, type, last four characters, and whether each is active. The full key is never listed; it is shown once, when manage_sdk_key creates it.
manage_sdk_key action, project, environment, sdkKey, name, description, type, reason
Manage an environment's SDK keys. action=create needs name + type and returns the full key ONCE (ServerSide for backend SDKs, ClientSide for browser/mobile). action=rename needs sdkKey and changes only the fields you pass. action=revoke needs sdkKey and stops the key working immediately; apps still using it lose flag updates; revoking a critical environment's key needs a reason. To rotate: create a new key, deploy it, then revoke the old one.
list_segments project, limit, cursor
List reusable user segments in a project. Segments are referenced from targeting rules via userSegmentId.
get_segment project, segment
Get one user segment (its conditions, id, and metadata) by key or id.
manage_segment action, project, segment, key, name, description, conditions, ifMatch, reason
Manage reusable user segments, which targeting rules reference by userSegmentId. action=create needs key + name (+ conditions); action=update needs segment and changes only the fields you pass (conditions replaces the whole list; description: "" clears it); action=delete needs segment. On update, pass ifMatch (the etag from get_segment) so a change someone made since you read it is not overwritten. ifMatch is rejected on create and delete: the API cannot make those conditional.
list_flags project, search, tag, type, archived, owner, limit, cursor
List feature flags in a project. Filter with search (key/name substring), tag, type, archived, owner. Each flag carries its owner ({id, email, name}, or null when unowned). Paginated via cursor.get_flag project, flag
Get one feature flag with its variations and metadata, including its owner (null when unowned). Address by flag key or id.
create_flag project, key, name, type, description, tags, clientSideVisible, initialVariations, expiresAtUtc, ownerEmail, isPermanent, idempotency_key
Create a feature flag. type is one of Boolean|String|Number|Json. Boolean flags get true/false variations automatically; for other types pass initialVariations. The flag is created in every environment of the project (disabled).
update_flag project, flag, name, description, tags, clientSideVisible, ifMatch, reason
Update flag name/description/tags/clientSideVisible. Changes only the fields you pass and keeps the rest; changing clientSideVisible needs a reason when any environment of the project is critical. pass description: "" to clear it. Key and type are immutable. Use toggle_flag / update_targeting for behavior changes. Pass ifMatch (the etag from get_flag) to refuse the write if the flag changed since you read it.
set_flag_expiry project, flag, expiresAtUtc
Set the date a flag is expected to be removed by, or pass expiresAtUtc: null to clear it. Expiry is advisory: evaluation never changes. Once the date passes, find_stale_flags reports the flag as expired. expiresAtUtc takes a date (2026-12-31), which means the end of that day in UTC, the same as picking it in the dashboard, or a full ISO-8601 timestamp, which is stored exactly. Refused with EXPIRY_IN_PAST for a time that has already passed (today's date is allowed), with FEATURE_NOT_ENABLED while flag expiration is not enabled for the organization, and with PERMANENT_FLAG_HAS_EXPIRY on a permanent flag (make it temporary first with set_flag_permanent). Clearing is always allowed.
set_flag_permanent project, flag, permanent
Mark a flag permanent (a kill switch, ops toggle or entitlement gate that is meant to stay), or pass permanent: false to make it temporary again. Permanent flags are never listed as removal candidates or by find_stale_flags; evaluation never changes. Marking is refused with PERMANENT_FLAG_HAS_EXPIRY while the flag has an expiry date (clear it first with set_flag_expiry and expiresAtUtc: null), with FEATURE_NOT_ENABLED while permanent flags are not enabled for the organization, and on an archived flag. Making a flag temporary is always allowed.
set_flag_owner project, flag, owner
Name the person responsible for a flag, or pass owner: null to leave it unowned. owner is the email of an active member of the organization, or "me" for the token's own user (needs a personal access token). The owner gets the flag's cleanup notices; evaluation never changes. Refused with OWNER_NOT_MEMBER for an email that is not an active member, and with PLAN_FEATURE_UNAVAILABLE below the Pro plan. Clearing is always allowed.
delete_flag project, flag, reason
PERMANENTLY delete a flag across all environments. Fails with FLAG_HAS_DEPENDENTS if other flags use it as a prerequisite. Prefer archive_flag unless the flag must be fully removed.
archive_flag project, flag, force, reason
Archive a flag (soft-hide, evaluation stops serving it). Reversible with restore_flag. Archive dependents first: refused with FLAG_HAS_DEPENDENTS while another live flag lists this one as a prerequisite, so archive those flags (blockedBy in find_stale_flags / list_removal_candidates) first. Refused with FLAG_RECENTLY_EVALUATED while live traffic is still evaluating the flag, because archiving makes every caller fall back to its own hardcoded default — normally that means the code removal has merged but not deployed yet, and the refusal clears itself once it has.
restore_flag project, flag, reason
Restore a previously archived flag.
toggle_flag project, flag, environment, enabled, reason
Enable or disable a flag in ONE environment. Affects live evaluation immediately — double-check the environment.
update_flag_environment_config project, flag, environment, defaultVariationId, strategy, prerequisites, reason
Update a flag's per-environment serving config: defaultVariationId (served on fallthrough, required), strategy (SingleVariation | PercentageRollout | TargetedRollout — only SingleVariation is currently supported at the environment level), and prerequisites. Percentage rollouts are configured on targeting rules via update_targeting.
flag_status project, flag
Compact cross-environment view of one flag: enabled state, strategy, default variation, and prerequisites per environment.
flag_evaluations project, flag, environment, days
What a flag actually served in ONE environment over the last 7, 30 or 90 days: total evaluations, the split by variation, and which rule (or fallthrough, off, prerequisite, error) served what. Percentage-rollout rules include their configured weights and a sample-ratio check; rollout.flagged=true means the served split is statistically off the configured weights. A live rollout rule is always listed, with count 0 and no variations when it served nothing. rollout.unreached is set when a live rollout rule got no evaluations while the flag's rules got 100 or more: usually the context lacks rollout.bucketBy, or an earlier rule or the conditions catch the traffic. These are evaluation counts, NOT unique users. Counts come from SDK-reported events, so zero means no evaluations were reported, not necessarily no traffic.
list_flag_triggers project, flag, environment, trigger, limit, cursor
List a flag's triggers in one environment, or get one by passing trigger: id, name, action (Enable or Disable), whether each is enabled, the last four characters of its secret, and when it last fired. A trigger is a secret URL that a monitoring tool (a Grafana alert, a Datadog monitor) calls to turn the flag on or off. The URL is never listed; it is shown once, when manage_flag_trigger creates or rotates it.
manage_flag_trigger action, project, flag, environment, trigger, name, triggerAction, description, enabled, reason, idempotency_key
Manage a flag's triggers in one environment. A trigger is a secret URL a monitoring tool POSTs to (no body) to turn the flag on (Enable) or off (Disable); calling it when the flag is already in that state changes nothing. action=create needs name + triggerAction and returns the URL ONCE. action=update needs trigger and changes only the fields you pass (name, description, enabled; enabled=false stops the URL working until re-enabled). action=rotate needs trigger: the old URL stops working at once and the new one is returned ONCE. action=delete needs trigger. The action (Enable/Disable) is fixed at creation. Creating, re-enabling and rotating need the Team plan or above; every write needs a Member token; at most 10 per flag per environment. To change the flag yourself, use toggle_flag instead.
list_rollout_ramps project, flag, environment, ramp, limit, cursor
List a flag's rollout ramps in one environment (the active ones, newest first, then the ten most recently finished), or get one by passing ramp. A ramp raises a percentage rollout one step at a time on a timer. Each ramp shows its status (Running, Paused, Completed, Aborted), its steps, currentStepIndex, nextStepAt, and why it paused. A single ramp comes with an etag to pass as ifMatch to manage_rollout_ramp.
manage_rollout_ramp action, project, flag, environment, rule, steps, variation, bucketBy, ramp, expectedStepIndex, percent, ifMatch, reason, idempotency_key
Manage a rollout ramp on a flag in one environment. A ramp raises a percentage rollout step by step: it applies the first step at once, then each next step when the previous hold runs out. Every step is an audited rule change that reaches SDKs over the stream. action=start needs rule + steps: rule is a targeting rule id (from get_targeting) whose rule serves a percentage rollout, or "default" for the default rule. Steps (1 to 20) must rise, the first not below the rule's current rollout. A default-rule ramp may name the variation to ramp to (variation id; needed when the default rule has no rollout yet) and bucketBy, and on reaching 100% makes that variation the default. The flag must be on in the environment. action=pause keeps the rest of the hold; action=resume continues from the rule as it stands now; action=advance applies the next step now and needs expectedStepIndex (the currentStepIndex you last saw); action=abort stops the ramp and leaves the rule at percent (0-100, at or below the current one). pause, resume, advance and abort need ramp and accept ifMatch. Editing the rule by hand or turning the flag off pauses a ramp. Starting needs the Team plan or above; every write needs a Member token.
compare_environments project, base, other, different_only, tag, owner, limit, cursor
Compare flag configuration between two environments: which flags differ and in which sections (state, defaultVariation, strategy, rules, prerequisites). Returns only differing flags unless different_only is false. To see exactly what would change for one flag, preview copy_flag_config (Team plan and above, Member role).
copy_flag_config project, flag, source, target, include_state, dry_run, source_etag, target_etag, reason
Copy one flag's targeting (default variation, strategy, rules, prerequisites) from one environment into another. On/off is copied only with include_state: true. Previews by default (dry_run: true) and changes nothing; review `before`/`after`, `changedSections` and `warnings`, then call again with dry_run: false plus the preview's sourceETag and targetETag as source_etag/target_etag to apply. If the apply is refused with 412, something changed since the preview: preview again. Applying needs both ETags, and the same `source` and `include_state` as the preview (the ETags record environment state, not the request). Team plan and above.
get_targeting project, flag, environment
Get a flag's current targeting configuration (enabled flag + ordered rules) in one environment.
update_targeting project, flag, environment, rules, ifMatch, reason
REPLACE all targeting rules of a flag in one environment (full PUT — rules not included are removed). Rules are evaluated in order. Get the current rules first with get_targeting. Pass ifMatch (the etag from get_targeting) so rules someone else changed meanwhile are not overwritten.
manage_targeting_rule action, project, flag, environment, ruleId, rule, ruleIds, reason
Edit a single targeting rule instead of replacing them all with update_targeting. action=add needs rule (appended last); action=update needs ruleId + rule and changes only the fields you pass (conditionGroups replaces the rule's groups; to clear rolloutPercentage or userSegmentId use update_targeting); action=remove needs ruleId; action=reorder needs ruleIds, every existing rule id exactly once, in the new order. Rule ids come from get_targeting.
manage_variation project, flag, action, variationId, key, name, value, description, reason
Manage a flag's variations. action=add requires key + value; action=update/remove require variationId (get ids via get_flag). Removing a variation fails with VARIATION_HAS_DEPENDENTS if other flags depend on it.
list_webhooks limit, cursor
List the organization's outbound webhook subscriptions (url, event/project/environment filters, enabled state, failure count, signing secret ids — never secret values), plus availableEventTypes: the event types a subscription can filter on. Empty filter lists mean "all". Paginated via cursor. Requires an Admin token. A 404 on every webhook call means webhooks are not enabled for the organization.
list_webhook_deliveries id, limit, cursor
List one subscription's delivery attempts, most recent first. status is Pending (awaiting an attempt, backing off, or in flight), Succeeded or DeadLettered; lastResponseStatusCode and lastError explain a failure. Paginated via cursor. Requires an Admin token. A 404 on every webhook call means webhooks are not enabled for the organization.
manage_webhook action, id, name, url, provider, credential, eventTypes, projects, environments, enabled, secretId, idempotency_key
action=create requires name + url and returns the signing secret. action=update/delete/rotate_secret/retire_secret require id. provider (create only, default GenericHttp) is the destination type: a Slack incoming webhook URL (https://hooks.slack.com/services/...) needs provider: "Slack", which posts readable channel messages; provider: "Datadog" sends Events API change events (url is your site's https://event-management-intake.<site>/api/v2/events) and provider: "Grafana" creates annotations (url is https://<your grafana>/api/annotations). Datadog and Grafana require credential (a Datadog API key, or a Grafana service account token that can create annotations, e.g. Editor); GenericHttp and Slack refuse it. credential is write-only: stored encrypted, never returned, and never echoed in this tool's output. A subscription's provider can never change. update changes only the fields you pass and keeps the rest; pass an empty list to widen that filter back to "all". projects take project keys or ids; environments take "<project>/<environment>" keys (e.g. "web/production") or ids. eventTypes come from list_webhooks → availableEventTypes. create and rotate_secret return a secret that is NEVER shown again: relay it to the user verbatim so they can store it (for a GenericHttp subscription only: Slack, Datadog and Grafana never check it, so skip it there). Slack doesn't verify signatures, so a Slack subscription's secret is unused and rotate_secret is refused for one, and so are Datadog and Grafana ones, which authenticate with credential instead. On update, omit credential to keep the stored one; changing the url of a Datadog or Grafana subscription requires sending credential again. rotate_secret adds a new active secret while the old one keeps signing; retire_secret (secretId from list_webhooks) removes one and is refused for the last active secret. A project-restricted service token must list at least one project, all in its scope. Requires an Admin token. A 404 on every webhook call means webhooks are not enabled for the organization.
deliver_webhook action, id, deliveryId
action=test queues one synthetic flag.toggled event to this subscription alone; action=redeliver (deliveryId from list_webhook_deliveries) re-sends a finished delivery, restarting its retry schedule. Delivery is asynchronous: read list_webhook_deliveries for the outcome. Both are refused for a disabled subscription, and redeliver for a delivery that is still Pending. Requires an Admin token. A 404 on every webhook call means webhooks are not enabled for the organization.
find_stale_flags project, days, owner
Find flags that look ready for code cleanup: not updated in N days AND either enabled in every environment (verify rollout is complete before removing — per-rule percentage ramps are not inspected) or disabled in every environment (dead — remove flag and code path). A flag whose expiry date (set_flag_expiry) has passed is always a candidate, however recently it was edited; if it is on in some environments and off in others its reason is past-expiry, meaning the owner has to decide which way to fold it. A project can give its temporary flags a default lifetime, so a flag with no date of its own can still be past expiry. Every result carries expiresAtUtc (the date set on the flag), effectiveExpiresAtUtc (the date in effect, from the flag or its project default), expirySource (explicit, project-default, or null), expired and owner (null when unowned). Flags marked permanent (kill switches, ops toggles) are never listed. Pass owner to see one person's stale flags ("me" for your own) or "none" for the unowned ones. Every result also carries blockedBy: the live flags that still list it as a prerequisite, which have to be removed and archived before it ([] when none). blockedBy is null when the server did not classify the flag as a removal candidate, which means unknown, not unblocked. A flag that other live flags list as a prerequisite has to be removed LAST, dependents first: archiving it while a dependent still names it makes that dependent fail its prerequisite check and serve its off variation, so archive_flag refuses it with FLAG_HAS_DEPENDENTS. Checks at most 50 candidates per call, expired flags first.list_removal_candidates project, staleness, limit, cursor
List the flags the server is confident can be removed from code, the same list the Featureflip flag cleanup GitHub Action works from. Each item has key, reason, status (Dead or Stale), treatment (true = keep the on-branch, false = keep the off-branch) and blockedBy: the live flags that still list it as a prerequisite. Only remove a flag whose blockedBy is empty. A flag that other live flags list as a prerequisite has to be removed LAST, dependents first: archiving it while a dependent still names it makes that dependent fail its prerequisite check and serve its off variation, so archive_flag refuses it with FLAG_HAS_DEPENDENTS. staleness "dead" (the default) returns only dead flags, "stale" adds stale ones. Paginated via cursor.
wrap_feature project, key, name, description, tags, language, idempotency_key
Create a Boolean feature flag and get back the SDK code snippet to guard the new code path with it. Returns the snippet only — apply the edit yourself. The flag starts DISABLED in every environment; enable it with toggle_flag when ready.
Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.
Install facts
| License | Apache-2.0 |
|---|---|
| Needs | node >=20.19.0 |
| Source | github.com/canopy-labs/featureflip-mcp |
| Install scripts | None declared by it or anything installed with it. |
| Tarball | sha512-Bui42B1yTTL05/I/lyqAMaYXZyBZsh6YqErXqoXdqQeN2wSdF9X0s6Cy+gxi3Pw9SzQop59yOafoJFDzXMFlCw== |
Versions reported
| Version | Run | Result | Tools |
|---|---|---|---|
| 0.10.1 | 2026-11-16 | Starts with no setup | 41 |
| 0.10.0 | 2026-11-12 | Starts with no setup | 41 |
Check this report yourself
This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.
Report as JSONExact text and tokenHow to verify it
Show it on your README
[](https://bragproof.smaverk.com/r/%40featureflip/mcp)
New version out? Ask for a fresh report.