Bragproof

← Reports

@shipeasy/mcp

Starts with no setup2.16.0npm

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 5 tools tried
Contacts while installing and starting: nothing

180tools listed
0hosts contacted
1file written
0.4 sto start
98dependencies

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 @shipeasy/mcp@2.16.0

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

5 tools that take no input and look read-only were called once with nothing. 0 returned a result.

errors_listNo usable answer tool reported an error: AUTH_REQUIRED: no valid Shipeasy credentials found for this MCP server. Cause: no /tmp/.config/shipeasy/config.json Fix: 1. Run in a
metrics_events_listNo usable answer tool reported an error: AUTH_REQUIRED: no valid Shipeasy credentials found for this MCP server. Cause: no /tmp/.config/shipeasy/config.json Fix: 1. Run in a
metrics_listNo usable answer tool reported an error: AUTH_REQUIRED: no valid Shipeasy credentials found for this MCP server. Cause: no /tmp/.config/shipeasy/config.json Fix: 1. Run in a
ops_activity_listNo usable answer tool reported an error: AUTH_REQUIRED: no valid Shipeasy credentials found for this MCP server. Cause: no /tmp/.config/shipeasy/config.json Fix: 1. Run in a
ops_agents_listNo usable answer tool reported an error: AUTH_REQUIRED: no valid Shipeasy credentials found for this MCP server. Cause: no /tmp/.config/shipeasy/config.json Fix: 1. Run in a

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.

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

projects_upsert domain, name, path, bind
Find-or-create a Shipeasy project by domain (idempotent) and bind the cwd to it via .shipeasy. Use this on fresh installs BEFORE any other write tool — every other write tool refuses to run until .shipeasy exists. Re-running with the same domain returns the existing project unchanged.
auth_check
Report whether ~/.config/shipeasy/config.json holds a valid CLI token. Returns { authenticated, project_id, base_url, user_email }.
auth_login
Launch the PKCE device-auth flow via `shipeasy login`. Opens a browser; blocks up to 5 minutes. Caller should render a 'waiting for browser…' spinner.
auth_logout confirm
Delete ~/.config/shipeasy/config.json — the ONE session shared by the `shipeasy` CLI and every MCP client on this machine. No network call. **This is not restorable from MCP**: re-authenticating needs a browser sign-in in a terminal (`shipeasy login`), which this transport cannot perform, so calling this strands the current task and every other tool until a human signs in again. Do NOT call it to 'reset' or troubleshoot a failing call — a 401/403 is fixed by signing in, not by deleting the credential first. Only call it when the user explicitly asked to sign out, and pass confirm: true to acknowledge that.
api_keys_create type, name, scopes, expiresInDays, env
Create an API key. Mints a new API key and returns the plaintext token **once** — it is stored hashed and can never be retrieved again, so capture it on creation.
175 more tools
errors_get id
Get a tracked error. Returns a single tracked error by its id, including the latest occurrence's stack, extras, and consequence, plus `occurrences` — the sampled per-instance detail rows behind the issue (newest first; exhaustive while the issue is small, thinned at volume, capped at 100). Returns…
errors_list status, q, limit
List tracked errors. Returns a single page of tracked production errors as a **bare JSON array** (no pagination envelope), ordered by `lastSeenAt desc`. Filter with `status`, free-text-search with `q`, and cap the page with `limit`.
errors_resolve id
Resolve a tracked error. Marks one tracked error `resolved` — the single-purpose "close out" action. Takes no body; it is `PATCH /api/admin/errors/{id}` pinned to `{ "status": "resolved" }`, exposed so tooling can close an error without being handed the full open/resolved/ignored status machine. A res…
errors_series id, from, to, bucket
Get an error's occurrence series. Returns a bucketed occurrence timeseries for one tracked error (by its fingerprint), read from the `shipeasy_errors` Analytics Engine dataset (near-real-time; ingest lag is seconds). The window bounds are epoch **seconds**; `to` must be strictly greater than `from`. The respon…
i18n_drafts_create name, profile_id, source_profile_id, listToken
Create a translation draft. Stage a new translation draft against a target profile, optionally seeding its keys from a source profile.
i18n_drafts_list
List translation drafts. List staged translation drafts awaiting review/publish.
i18n_drafts_update draftId, status
Update a translation draft. Transition a draft's lifecycle state (`open` / `merged` / `abandoned`).
i18n_keys_list profile_id, prefix, q, limit, offset
List i18n keys. List keys for a profile, optionally filtered to a name `prefix`.
i18n_keys_push profile_id, keys, force
Push i18n keys (insert-only, or `force` to overwrite). Add NEW keys to a profile. Insert-only by default — existing keys are left untouched and reported back as `skipped`.
i18n_keys_set key, value, profile, description
Set a key's value and publish it live. Upsert a single key's value into a profile and immediately publish the whole profile (KV rebuild + CDN purge) so the new value is live in one call. The key is inserted when new and overwritten when it already exists. `profile` is a profile name — omit it to target the project'…
i18n_keys_update id, value, description, variables, experimentId
Update one i18n key. Overwrite a single existing key's value — the only overwrite path.
i18n_profiles_create name, listToken
Create an i18n profile. Create a locale profile. `name` is the stable handle (e.g. `fr:prod`).
i18n_profiles_list
List i18n profiles. Returns every locale profile in the project (e.g. `en:prod`, `fr:prod`).
i18n_profiles_publish profileId
Publish a profile live. Publish a profile to the CDN — rebuild its KV snapshot + purge the edge. Publishing is PROFILE-WIDE: the whole profile is snapshotted into one KV blob, so the body takes no options.
metrics_archive id
Archive a metric. Soft-deletes (archives) the metric. Returns `409` if it is attached to a running experiment — stop those experiments first.
metrics_create name, display_name, folder, event_name, query, winsorize_pct, default_min_effect_of_interest, direction, unit, display, query_ir, listToken
Create a metric. Creates an event-backed metric. Pass the query as the DSL string (`query`) **or** the typed IR (`query_ir`) — exactly one. `event_name` must equal the event the query references.
metrics_events_approve id, folder, description, properties
Approve a pending event. Promotes a pending (auto-discovered) event to usable so metrics can query it (`pending` → `0`).
metrics_events_archive id
Archive an event. Soft-deletes (archives) the event. Returns `409` if any metric still references it — delete those metrics first.
metrics_events_create name, folder, description, properties, listToken
Register an event. Registers a new event name and (optionally) its typed properties. Only `name` is required.
metrics_events_get id
Get an event. Returns one event's full detail. Resolves by exact id, unique id-prefix, or exact (unique) name.
metrics_events_list q
List events. Returns every catalogued event in the project, including pending auto-discovered names. Each row carries its own `pending` flag, so the unapproved queue can be filtered client-side.
metrics_events_update id, folder, description, properties
Update an event. Partial update of an event's folder, description, or properties. `name` is immutable.
metrics_experiments id
List experiments using a metric. Returns every experiment that attaches this metric — as `goal`, `guardrail`, or `secondary` — ordered with running experiments first, then by role weight (goal > guardrail > secondary).
metrics_list q
List metrics. Returns every metric in the project (not paginated) — name, folder, source event, the typed `queryIr`, and the rendered query.
metrics_series id, from, to, bucket
Get a metric's time series. Compiles the metric's typed IR into Analytics Engine SQL and returns the bucketed series over the requested window (near-real-time; ingest lag is seconds). The window bounds are epoch **seconds**; `to` must be strictly greater than `from`. The response echoes the SQL that prod…
metrics_show id
Get a metric. Fetch one metric by its id or name, including the rendered DSL query and the typed IR.
metrics_unarchive id
Unarchive a metric. Reverses a soft-delete (archive), making the metric live again. Idempotent — unarchiving a metric that is already live succeeds with no effect.
metrics_update id, display_name, folder, event_name, query, winsorize_pct, default_min_effect_of_interest, direction, unit, display, query_ir
Update a metric. Update a metric's definition — folder, source event, query (`query` DSL or typed `query_ir`), winsorisation, minimum detectable effect, or direction. `name` is immutable. Provide at most one of `query` / `query_ir`.
ops_ack handle, agent, sessionId, launch, runId, takeover
Ack an item (start a run). Acknowledge a queue item — a person or an AI agent declaring "I'm on this now". Opens a run: stamps who picked the item up and when, assigns them as owner, and moves the item into the matching working status (`investigating_by_ai` for an AI ack, `in_progress` for a human one).…
ops_activity_list item, field, since, until, limit
List queue activity. The activity feed of the project's queue items, newest first: every status, priority, owner, tag and content change, every comment, every alert acknowledgement, and every pull-request event (`linked`, `unlinked`, `merged`, `closed` unmerged). Each entry names the item it belon…
ops_agents_list
List connected AI agents. The project's connected AI agents — one per authenticated trigger connector (Claude / Cursor / Copilot / Jules). These are the agent types `ops ack` accepts and the agents a queue item can be assigned to.
ops_alerts_archive id
Delete an alert rule. Deletes the alert rule. The cron stops evaluating it immediately. Use this (then create a new rule) to repoint alerting at a different metric, since `metricId` is immutable.
ops_alerts_channels
List Slack channels. List the project's connected Slack channels — used to resolve an alert rule's notification target.
ops_alerts_create name, metricId, kind, comparator, threshold, rangeMin, rangeMax, sigma, direction, sustained, windowHours, bucketMinutes, requiredBuckets, warnThreshold, recoveryThreshold, groupAlerts, maxGroups, noDataMinutes, delayMinutes, autoResolveMinutes, composite, severity, enabled, notify, listToken
Create an alert rule. Creates a metric-threshold alert rule. `name`, `metricId`, `comparator`, and `threshold` are required; `windowHours` defaults to `24`, `severity` to `warn`, and `enabled` to `true`.
ops_alerts_list q
List alert rules. Returns every alert rule in the project (not paginated). Each rule carries its bound `metricId`, the denormalised `metricName` (or `null` if the metric was removed), the comparator/threshold/window, severity, enabled flag, and delivery target.
ops_alerts_update id, name, kind, comparator, threshold, rangeMin, rangeMax, sigma, direction, sustained, warnThreshold, recoveryThreshold, groupAlerts, maxGroups, noDataMinutes, delayMinutes, autoResolveMinutes, composite, windowHours, bucketMinutes, requiredBuckets, severity, enabled, notify
Update an alert rule. Partial update of a rule's tunable knobs. `metricId` is immutable — the metric also pins the aggregation, so a body carrying `metricId` is rejected with `409 IMMUTABLE_FIELD`; create a new rule bound to the other metric instead (rule deletion is dashboard-only).
ops_attachments_create handle, contentBase64, url, filename, mimeType, kind
Attach a screenshot to an item. Attach a screenshot, screen recording, or file to a bug or feature request, so the fixer sees what QA saw instead of reconstructing it from measurements. Send the bytes as `contentBase64` (a bare base64 string or a `data:` URI) or give a public https `url` for the server to fe…
ops_bug title, stepsToReproduce, actualResult, expectedResult, priority, status, assigneeId, delegateConnectorId, subscribers, tags, reporterEmail, pageUrl, userAgent, viewport, context, notify, trail, listToken
File a bug report.. Files one queue item — a bug report or a feature request — and fires the project's connectors (GitHub issue / Slack). `type` selects which; only the two user-fileable types are accepted (`error`/`alert` tickets are auto-filed by the platform). Returns the new id and per-projec…
ops_comments_create handle, body, parentId, listToken
Comment on an item. Append a comment to a queue item's thread. The body is markdown (mentions like `@teammate` notify that person; `@shipeasy` asks Jarvis, the AI agent, to reply). Pass `parentId` to reply under an existing top-level comment (one level of threading — a reply to a reply attaches t…
ops_comments_list handle
List an item's comments. List the comment thread on a queue item, oldest first. Each comment carries its author (a teammate email, or `system` for a comment authored by Jarvis — the AI agent), its markdown body, and `parentId` for the single level of threaded replies. Removed comments are omitted.
ops_comments_upload_media handle, contentBase64, url, filename, mimeType, kind
Upload an image to embed in a comment. Upload an image to embed in a comment on a queue item. Takes the same body as the attachment upload (`contentBase64` or `url`). The response carries a relative `url` — reference it from the comment body as a markdown image (`![caption](url)`) in `ops comments create`, so an ev…
ops_create type, title, stepsToReproduce, actualResult, expectedResult, priority, status, assigneeId, delegateConnectorId, subscribers, tags, reporterEmail, pageUrl, userAgent, viewport, context, notify, trail, description, useCase, listToken
File a queue item (bug or feature request) — pass --type.. Files one queue item — a bug report or a feature request — and fires the project's connectors (GitHub issue / Slack). `type` selects which; only the two user-fileable types are accepted (`error`/`alert` tickets are auto-filed by the platform). Returns the new id and per-projec…
ops_feature title, description, useCase, priority, status, assigneeId, delegateConnectorId, subscribers, tags, reporterEmail, pageUrl, userAgent, context, notify, trail, listToken
File a feature request.. Files one queue item — a bug report or a feature request — and fires the project's connectors (GitHub issue / Slack). `type` selects which; only the two user-fileable types are accepted (`error`/`alert` tickets are auto-filed by the platform). Returns the new id and per-projec…
ops_fired_alerts_list status
List fired alerts. Returns the project's FIRED alerts as a **bare JSON array** (no pagination envelope), ordered by `createdAt desc`. Defaults to the currently-firing ones (`status=active`); pass a `status` to widen to resolved/dismissed history or `all`.
ops_fired_alerts_update id, status, assigneeId, agent
Update a fired alert. Triage writes on one fired alert — the only mutations this surface allows. All body fields are optional (at least one required); only the fields present are changed.
ops_get handle, include
Get one queue item. Fetch a single queue item by its per-project `number` or full id.
ops_group handle, status, priority
Update a linked group. Applies `status` and/or `priority` to every item in this item's link group — the items tied to it, directly or through a chain, by blocked-by / blocking / duplicate-of links (see `group` on `ops get`). Each member goes through the normal item update, so activity, audit, run cl…
ops_investigations_create handle, kind, summary, findings, question, qaNotes, agent, model, connectorId, prNumber, prUrl, sources, confidence, tokensUsed, durationMs, visibility, startedAt, completedAt, sessionId, listToken
Record an investigation. Append one structured investigation record to a queue item — the AI-write seam the cockpit's detail panel renders read-only. Post your findings (`kind: investigated`), a blocking question for the team (`kind: question`), or how to verify the fix (`kind: ready_for_qa` with `qaN…
ops_investigations_list handle
List an item's investigation records. The structured, read-only investigation records on a queue item — the findings / blocking questions / QA notes an AI agent posted while working it, plus its `working` run rows. Returns `published` records only, newest first (max 50).
ops_investigations_update handle, investigationId, kind, summary, findings, question, qaNotes, model, prNumber, prUrl, sources, confidence, tokensUsed, durationMs, visibility, completedAt, sessionId
Update an investigation record. Update one existing investigation record in place — the write-back seam for the `working` run record you were handed when a run was launched. Fill in the `summary`/`findings`, attach the fixing PR, record your `confidence` and the `sources` you inspected, or flip its `kind` of…
ops_link_pr handle, prNumber, prUrl, unlink
Link a fixing PR. Record a pull request that fixes a queue item. An item can carry several PRs: each call ADDS one (re-linking a linked PR is a no-op), `unlink: true` removes one, and `prNumber: null` clears them all. `connectorData.github.prs` lists them; `github.pr` is the primary one (newest…
ops_links handle, addBlockedBy, removeBlockedBy, addBlocking, removeBlocking, duplicateOf
Link related items. Edits how this queue item relates to others: which items block it ("blocked by"), which items it blocks ("blocking"), and which item it duplicates ("duplicate of"). The blocker lists are incremental — already-linked or never-linked items are no-ops and every other relation is …
ops_list type, status, priority, scope, qaQuestions, limit, offset, owner, reporter, closedSince
List the operational queue (bugs, feature requests, errors, alerts, measurement plans) in work order — highest priority first, oldest first within a priority. PAGING: `limit` (page size, 1–500) is REQUIRED — the call fails without it. Start at `offset: 0` and add `limit` to `offset` for the next page; a page shorter than `limit` is the last one. FILTERS (all optional, combined with AND, applied before paging): `type` = bug | feature_request | error | alert | measure_plan; `status` = open | in_progress | investigating_by_ai | blocked | ready_for_qa | resolved | wont_fix | pending_approval | unresolved | all — DEFAULTS TO `unresolved` (omitted = items still being worked: open, in_progress, blocked, ready_for_qa…; no resolved or wont_fix ones). Pass `status: "all"` to include resolved and wont_fix too (pending_approval is only returned when asked for exactly); `priority` = critical | high | medium | nice_to_have; `owner` = a person (id, email or name) or an agent (connector id, name or handle, e.g. "Claude"); `scope: "ready"` = what to work on now — open items nobody is working (no open run) that are unowned or were reopened after an earlier run. Use `scope: "ready"` to pick the next item, then `ops_ack` it.
ops_memory_search q, paths, item, trail, kind, limit
Search project memory. What the project already learned from the tickets it shipped — the decisions the team made in answered questions, what QA found, which files a feature lives in, the PR that shipped it, and the requests that were turned down. Every entry is derived from the item's own records (…
ops_notify title, summary, steps, href, dedupeKey
Raise an attention notification. Raise a 'needs your attention' bell notification. Create-only and idempotent on `dedupeKey` — re-raising with the same key updates the one card instead of stacking duplicates. It never reads, marks read, or deletes the feed, so it is safe for restricted ops keys.
ops_qa_notes_create handle, kind, body, verdict, agent, listToken
Add a QA note to an item. Append one typed QA note to a queue item. `kind` is `narrowing` (what now passes vs what still fails), `clarification` (what "fixed" now means), `verification` (requires a `verdict` of `pass` or `fail`, and `body` says what was checked) or `correction` (withdraws an earlier fr…
ops_qa_notes_list handle, kind
List an item's QA notes. The typed QA notes on a queue item, newest first (max 200) — narrowing, clarification, verification and correction notes, each with its author and time. They are separate from the comment thread: read these to learn the CURRENT QA state of a ticket (what remains failing, what …
ops_qa_questions_answer handle, questionId, answer, agent
Answer a QA question. Answer one open QA question. The question moves to `answered` and the answer shows on the item. An answered question cannot be answered again (409); ask a new one to follow up. The answerer is the caller's identity; pass `agent` to record it as answered by that agent type's QA…
ops_qa_questions_ask handle, question, agent
Ask QA a question about an item. Put a question to QA on a queue item — use it when you do not know the answer yourself and QA's decision unblocks the work. The question is open until QA answers it; it surfaces on the item (`ops get` → `qaQuestions`) and in the project-wide QA backlog (`ops list --qa-question…
ops_qa_questions_list handle, status
List an item's QA questions. The questions put to QA on a queue item, newest first (max 100), each with QA's answer once given. `ops get` returns the same list as `qaQuestions`.
ops_questions_answer handle, questionId, selected, other
Answer a question. Answer one open question on a queue item — pick option labels in `selected` (exactly one unless the question is `multiSelect`) and/or write a free-text `other`. The question moves to `completed`. When it was the last open question of a `resume` run, that agent is re-fired on t…
ops_questions_ask handle, questions, runId, agent, delivery
Ask the team questions about an item. Ask 1–4 structured questions about a queue item — the way to get a decision from a person when the implementation needs one. Each question is the `AskUserQuestion` shape: a short `header` chip, the full `question`, 2–4 `options` (`label` + `description`), and `multiSelect` (ch…
ops_questions_cancel handle, questionId
Withdraw a question. Withdraw one open question you asked — it no longer needs an answer (you found it out yourself, or the item moved on). The question moves to `cancelled` and leaves the detail panel. Withdrawing the last open question of a run delivers nothing.
ops_questions_list handle, status
List an item's questions. The structured questions asked on a queue item, with their answers — newest first (max 100). Pull this to read the answers to questions you asked: an answered question reads `status: completed` and carries `answer.selected` (the option labels picked) and `answer.other` (the fr…
ops_review_agents_archive agentId
Archive a review agent. Archive a review agent: it stops running and its key is free to reuse. Evals it already submitted stay on their trails.
ops_review_agents_create preset, key, name, description, instructions, valueType, polarity, threshold, blocking, trigger, connectorId, enabled, listToken
Add a review agent. Add a review agent, from a preset (`preset: security`) or custom (`key`, `name`, `instructions`, and how to read its value). A `push` agent runs on every push to a linked PR through the project's coding-agent trigger (or the one named by `connectorId`) and spends that agent's …
ops_review_agents_list
List review agents. The project's review agents — the evals that score every push to a trail's changes — and the presets that can be added in one call.
ops_review_agents_update agentId, name, description, instructions, valueType, polarity, threshold, blocking, trigger, connectorId, enabled
Change a review agent. Change a review agent's instructions, threshold, polarity, trigger, the connector that runs it, whether it blocks, or switch it off. Its `key` is fixed. Earlier evals keep the verdict they were given.
ops_routing_rules_create tags, types, enabled, user, connector, agentPrompt, status, priority, subscribers, skipApproval, listToken
Create a tag automation rule. Appends one rule after the existing ones; existing rules are untouched. The rule fires on a newly filed item carrying any of `tags` (or whose type is in `types`) and applies its actions: `user` assigns a person, `connector` hands the item to a connected coding agent (launching…
ops_routing_rules_list
List tag automation rules. The project's tag automation rules in evaluation order. Each rule matches newly filed queue items by tag (or ticket type) and applies its actions — assign a person, launch a connected coding agent, set status or priority, subscribe emails.
ops_trail_gates_get
Show the merge gates. The project's merge gates for trail changes — branch freshness, human review, agent findings, blocking evals and CI checks — each with whether it is evaluated and whether it blocks.
ops_trail_gates_set upToDate, humanReview, agentReview, evals, checks, discovered, shipsDark, rollback, measured, guarded, copy, plan, requirePlan, fixRounds, goalWindowDays, maxGoalReplans, maxParallelRuns, attributionWindowHours, rollout, autopilot, intakeMatching, repos
Set the merge gates. Replace the project's merge gates. Send the whole object (read it with `ops trail-gates get` first).
ops_trigger_create_claude name, events, config, token, enabled
Register a Claude Code scheduled routine as the trigger connector. Creates (or idempotently updates) a coding-agent **trigger** connector — the recurring, unattended run that burns down the ops queue in `--pr` mode. Discriminated on `provider`; only the four Shipeasy-fireable providers are accepted (`claude_trigger`, `cursor_trigger`, `copilo…
ops_trigger_create_copilot name, events, config, token, enabled
Register a GitHub Copilot cloud-agent trigger. Creates (or idempotently updates) a coding-agent **trigger** connector — the recurring, unattended run that burns down the ops queue in `--pr` mode. Discriminated on `provider`; only the four Shipeasy-fireable providers are accepted (`claude_trigger`, `cursor_trigger`, `copilo…
ops_trigger_create_cursor name, events, config, apiKey, opsKey, enabled
Register a Cursor cloud-agent trigger (cold-fire; Shipeasy launches the run). Creates (or idempotently updates) a coding-agent **trigger** connector — the recurring, unattended run that burns down the ops queue in `--pr` mode. Discriminated on `provider`; only the four Shipeasy-fireable providers are accepted (`claude_trigger`, `cursor_trigger`, `copilo…
ops_trigger_create_jules name, events, config, apiKey, opsKey, enabled
Register a Google Jules (Gemini) trigger. Creates (or idempotently updates) a coding-agent **trigger** connector — the recurring, unattended run that burns down the ops queue in `--pr` mode. Discriminated on `provider`; only the four Shipeasy-fireable providers are accepted (`claude_trigger`, `cursor_trigger`, `copilo…
ops_update handle, title, stepsToReproduce, actualResult, expectedResult, status, priority, githubPrNumber, notify, description, useCase
Update a queue item. Update a queue item. The body is validated against the item's stored type: a `bug` accepts its content fields (title, steps-to-reproduce, actual/expected result) plus `status`/`priority`/`notify` and a GitHub PR link; a `feature_request` its content (title, description, use-ca…
projects_current
Show the current project. Returns the project the caller's auth header resolves to — plan, status, billing, and which modules are enabled. The server reads the project from the credential, so there is no id parameter. Powers `whoami`.
projects_update id, name, domain, slug, defaultEnv, timezone, statMethod, sigThreshold, autoRollback, minSampleDays, moduleTranslations, moduleConfigs, moduleGates, moduleExperiments, moduleFeedback, moduleUser, moduleEvents, minSampleSize, minRuntimeDays, defaultPower, ciConfidence, defaultAllocationPct, defaultHoldout, defaultWinsorizePct, defaultMei, cupedBaselineDays, cupedMinOverlap, cupedMinBaselineUsers, msprtTauMeiFactor, msprtTauSdFactor, srmThreshold, errorAutocloseDays, errorTicketMinOccurrences
Update the current project. Update the current project's settings — name, domain, slug, default environment, timezone, experiment-analysis knobs (statistical method, significance threshold, auto-rollback, minimum sample days), and the per-module enable flags. Partial: only the fields you send change.
release_configs_archive id
Delete a dynamic config. Soft-deletes the config and rebuilds the project's flags KV blob.
release_configs_create name, description, folder, schema, value, dev, staging, prod, listToken
Create a dynamic config. Creates a new config with the given `schema`. The initial `value` (or an empty object) is published as version 1 on **every** env.
release_configs_get id
Get one config. Returns config metadata plus the latest published values per env and any active draft values. Use this to fetch the JSON the editor renders.
release_configs_list limit, cursor, q
List dynamic configs. Returns a single page of configs ordered by `updated_at desc, id desc`. Each row includes the latest published `version` per env and any active drafts.
release_configs_update id, schema, value, dev, staging, prod, folder
Update a dynamic config. Partial update. When `value` is supplied it is **republished on every env** (new version per env). A per-env key (`dev`/`staging`/`prod`) publishes a new version to **only that env**, immediately, overriding `value` for it. When `schema` is supplied it replaces the current sch…
release_configs_update_schema id, schema
Update a config schema. Replaces a config's JSON Schema in place. Every existing published value is re-validated against the new schema before it lands; the update fails if any value no longer validates.
release_experiments_archive id
Delete an experiment. Archives the experiment (soft-delete via status transition). Returns `409` if the experiment is still `running` — stop it first.
release_experiments_create name, description, hypothesis, tag, owner_email, audience, bucket_by, folder, universe, targeting_gate, holdout_gate, allocation_pct, allocation_percent, reserved_headroom, salt, params, groups, significance_threshold, min_runtime_days, min_sample_size, sequential_testing, goal_metric, guardrail_metrics, listToken
Create an experiment. Creates a new experiment in `draft` status. `name`, `universe`, and `groups` are required; everything else has sensible defaults.
release_experiments_get id
Get one experiment. Returns the full experiment row including groups, params, allocation, and lifecycle timestamps.
release_experiments_list limit, cursor, status, q
List experiments. Returns a single page of non-archived experiments ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.
release_experiments_readout_create id, kind, acknowledgedCaveatIds, requireAllAcknowledged
Mint a readout snapshot. Freezes the current results view into an immutable, dated readout snapshot — verdict, headline, per-metric numbers, the caveat list with its acknowledgment state, enrollment, and a hash of the assignment-relevant config. Ship/stop flows mint one automatically; "Share readout" …
release_experiments_readout_get id, readoutId
Get a readout snapshot. Returns one immutable readout snapshot — the frozen results view (verdict, headline, per-metric numbers, caveats, enrollment) captured when it was minted, plus the `configHash` that tells you whether it is still comparable to the live view.
release_experiments_reanalyze id
Re-queue analysis. Requeues the daily analysis pass for this experiment outside the normal cron cadence. Useful after attaching a new metric or correcting an event taxonomy. The job runs asynchronously.
release_experiments_restore id
Restore an archived experiment (→ draft). Drives the experiment lifecycle. Allowed transitions:
release_experiments_results id
Get analysis results. Returns the latest analysis output for the experiment — one row per metric/group/day, including sample size, mean, % delta vs. control, p-value, and a sample-ratio mismatch flag.
release_experiments_set_metrics id, metrics
Attach metrics. Replaces the experiment's metric attachments wholesale. Each entry pairs an existing `metric_id` with a `role` (`goal` / `guardrail` / `secondary`).
release_experiments_start id
Start an experiment (draft → running). Drives the experiment lifecycle. Allowed transitions:
release_experiments_stop id
Stop a running experiment. Drives the experiment lifecycle. Allowed transitions:
release_experiments_timeseries id, metric
Get analysis timeseries. Same row shape as `/results`, but returns every daily slice rather than the latest. Filter to a single metric with the `metric` query parameter.
release_experiments_universes_archive id
Delete a universe. Soft-deletes the universe. Returns `409` if any non-archived experiment still references it — archive those experiments first.
release_experiments_universes_create name, folder, description, unit_type, holdout_range, recommended_headroom, param_schema, listToken
Create a universe. Creates a new universe. Only `name` is required — `unit_type` defaults to `user_id` and `holdout_range` defaults to `null` (no holdout).
release_experiments_universes_list limit, cursor, q
List universes. Returns a single page of universes ordered by `created_at desc, id desc`. The universes table has no `updated_at`, so this list is keyed on creation time.
release_experiments_universes_update id, folder, description, holdout_range, recommended_headroom, param_schema
Update a universe. Partial update. Only `holdout_range` is mutable — `name` and `unit_type` are immutable after create.
release_experiments_update id, name, description, hypothesis, tag, owner_email, audience, bucket_by, folder, targeting_gate, holdout_gate, allocation_pct, reserved_headroom, allocation_percent, salt, universe, params, groups, significance_threshold, min_runtime_days, min_sample_size, sequential_testing, goal_metric, guardrail_metrics
Update an experiment. Partial update. `allocation_pct`, `groups`, `salt`, `universe`, `params` are **immutable while running** — returns `409` if you try. Stop the experiment first.
release_flags_activity id, limit
List gate activity. Returns recent audit rows for one gate (create, update, enable, disable, delete) ordered newest first. Use the `limit` query parameter to cap the result (1–100, default 20).
release_flags_archive id
Delete a feature gate. Soft-deletes the gate. Returns 409 if the gate is still referenced by a running experiment as a targeting gate — stop the experiment first.
release_flags_attributes_archive id
Archive a targeting attribute. Soft-deletes (archives) a targeting attribute.
release_flags_attributes_create name, type, enum_values, required, description, sdk_path, listToken
Declare a targeting attribute. Declare a targeting attribute the SDK reports and gates/experiments can target. `type: enum` requires `enum_values`.
release_flags_attributes_get id
Get a targeting attribute. Fetch one targeting attribute by id.
release_flags_attributes_list q
List targeting attributes. Returns every auto-inferred targeting attribute in the project — the `name` and (when known) the value `type` — for building gate/experiment targeting rules.
release_flags_attributes_update id, type, enum_values, required, description, sdk_path
Update a targeting attribute. Update a targeting attribute's type, allowed values, required flag, description, or SDK path. `name` is immutable.
release_flags_create name, type, enabled, rollout_pct, rollout_percent, rules, salt, stack, title, description, folder, group, owner_email, listToken
Create a feature gate. Creates a new gate. Default `enabled: true` at the supplied `rollout_pct` (`0` = fully dark).
release_flags_disable id
Disable a gate. Sets `enabled: false` so the gate evaluates to `false` for every caller, regardless of `rollout_pct` or `rules`. Use as a quick kill switch.
release_flags_enable id
Enable a gate. Sets `enabled: true`. The current `rollout_pct` is preserved.
release_flags_get id
Get one gate. Returns the full gate row — including the gatekeeper `stack`, resolved creator/last-editor emails, and the edit `version` — for one gate, addressed by id or `name`.
release_flags_list limit, cursor, q
List feature gates. Returns a single page of gates ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.
release_flags_templates_archive id
Delete a gate template. Soft-deletes (archives) a **customer** template. Returns `409` if `id` names a read-only built-in template.
release_flags_templates_create name, description, category, icon_key, auto, rules, listToken
Create a gate template. Creates a per-project (customer) targeting-rule template. Built-ins are read-only and cannot be created here. Returns `409` if a template with this `name` already exists in the project.
release_flags_templates_get id
Get one gate template. Returns a single template by its `id` — a built-in slug (`country`) or a customer `gtpl_…` id.
release_flags_templates_list q, query
List gate templates. Returns the merged targeting-rule template catalog — read-only **built-ins first** (the `@team`/`@owner` audience aliases, country, email-domain, region presets, …), then this project's **customer** templates. Each item carries a `rules: [{ attr, op, value }]` definition; the …
release_flags_templates_update id, name, description, category, icon_key, auto, rules
Update a gate template. Partial update of a **customer** template. `rules` replaces the list wholesale. Returns `409` if `id` names a read-only built-in template.
release_flags_update id, type, rollout_pct, rollout_percent, rules, enabled, stack, title, description, folder, group, owner_email
Update a feature gate. Partial update — only supplied fields change. Array fields (`rules`, `stack`) **replace** wholesale; there is no merge or append.
release_flags_whitelist id
Read a gate's whitelist. Returns the gate's whitelist — the always-first allowlist that admits the listed identities before any targeting rule or percentage rollout is evaluated.
release_flags_whitelist_add id, attr, entries
Add entries to a gate's whitelist. Adds identities to the gate's whitelist, creating the block if the gate doesn't have one yet. Entries already on the list are skipped, so the call is idempotent and safe to retry.
release_flags_whitelist_remove id, entries
Remove entries from a gate's whitelist. Removes identities from the gate's whitelist. Entries that aren't on the list are skipped, so the call is idempotent.
release_flags_whitelist_set id, attr, entries
Replace a gate's whitelist. Replaces the gate's whole whitelist with `entries`, creating the block if the gate didn't have one. Idempotent — the same call twice leaves the same list.
release_killswitch_archive id
Delete a killswitch. Soft-deletes the killswitch and rebuilds the project's flags KV blob so SDKs stop seeing it.
release_killswitch_create name, description, folder, value, switches, listToken
Create a killswitch. Creates a new killswitch with `value` (default `false`) applied to **every** env at version 1.
release_killswitch_get id
Get one killswitch. Returns the killswitch metadata plus the latest published `value`/`switches`/`version` per env.
release_killswitch_list limit, cursor, q
List killswitches. Returns a single page of killswitches ordered by `updated_at desc, id desc`. Each row includes the latest published `value`/`switches`/`version` per env.
release_killswitch_set id, env, switchKey, value
Set one switch entry. Sets or updates a single `switchKey` on a single `env`. Publishes one new version on that env only — other envs untouched.
release_killswitch_set_value id, env, value
Set the flat value on one env. Sets the flat `value` on a single `env`, publishing one new version on that env only. `switches` and other envs are untouched.
release_killswitch_toggle id, switchKey, value, env
Toggle a killswitch or one of its switches. Flips a killswitch on one environment and publishes a new version there. This is the one-call incident verb: it reads the current value, flips it, and publishes, so you don't have to fetch the killswitch first.
release_killswitch_unset id, env, switchKey
Remove one switch entry. Removes a single `switchKey` from the `switches` map on a single `env`. Publishes a new version on that env.
release_killswitch_update id, description, folder, value, switches
Update a killswitch. Partial update applied to **every** env. Setting `value`/`switches` publishes a new version per env. Description-only patches don't bump versions.
tags_get entityType, entityId
Read an item's tags. Returns the tags attached to one item. The item is addressed by kind (`entityType`) plus its handle, so the same call reads tags off a queue item, a flag, a config, a kill switch, a metric, a tracked error, an alert rule, or an experiment.
tags_list q
List the project's tags. Returns every tag in the project — the shared roster any item (queue items, flags, configs, kill switches, metrics, tracked errors, alert rules, experiments) can carry. Sorted by name.
tags_set entityType, entityId, tags
Replace an item's tags. Replaces the item's whole tag set with `tags`: names not yet in the project are created, attached names not in the list are detached, and `[]` clears every tag. Names are deduped case-insensitively, reusing an existing tag's casing (sending `iOS` when `ios` exists attaches `io…
tags_update entityType, entityId, add, remove
Add or remove tags on an item. Edits an item's tags incrementally: attaches every name in `add` (creating project tags as needed) and detaches every name in `remove`, leaving the item's other tags untouched. Matching is case-insensitive; a name in both lists ends up removed.
trails_attribute handle, item, confidence, evidence
Attribute an item to a trail. Record that an error, alert or bug was caused by the trail after it merged. Errors carry no release or commit SHA, so attribution is a judgement: compare the stack frames and the error's subject against each candidate trail's changed files (`trails get --files`) and resources,…
trails_close handle, reason
Close a trail. Close a trail by hand — abandoned, superseded, or shipped with discovered items still open. A trail also closes on its own once it is `shipped` with no discovered item open at `high` priority or above. Closing never merges or closes pull requests. A trail closed with nothing m…
trails_confirm_suspect handle, suspectId
Confirm a suspected regression. Confirm a suspect: the item goes onto the trail with source `post_merge` and the suspect's evidence is kept. A person's call — the restricted ops key cannot confirm.
trails_create title, body, type, priority, ownerId, ownerConnectorId, repos, originItem, startDate, targetDate, health, goal, intake, autopilot, listToken
Create a trail. Creates a trail in `planning`. A trail is created on purpose — nothing makes one implicitly. Create one from scratch with a `title` and a `body` (the outcome and the acceptance criteria), or press **Ship this** on a queue item with `originItem`: the item's description seeds th…
trails_get handle, files
Show a trail. A trail followed from intent to release: its phase, every change (each a pull request) with its latest push, merge gates, CI checks, each review agent's eval next to its last five, every finding (open first, worst first, `stale` when raised on an earlier push), approvals and p…
trails_items_add handle, item, milestoneId
Put an existing item on a trail. Attach an existing queue item to the trail, recorded with source `attached`, optionally into a milestone (`milestoneId`). An item is on at most one trail; one already on another trail is refused with `409`. To file a *new* item on a trail, use `ops bug --trail` or `ops feature…
trails_items_move handle, itemHandle, milestoneId
Move an item to a milestone. Move an item on the trail into a milestone, or out of every milestone with `milestoneId: null`. The item stays on the trail and keeps its discovery record; only the milestone it counts toward changes. An item that is not on the trail is `404`, and so is a milestone of another …
trails_items_remove handle, itemHandle
Take an item off a trail. Detach a queue item from the trail. The item stays in the queue; only its link to the trail and its discovery record go. The trail's origin item cannot be detached.
trails_link_pr handle, prUrl, item
Link a pull request to a trail. Link a pull request to the trail as one of its *changes*. From then on the GitHub webhook records its pushes, the project's review agents score each push, and the merge gates read it. Linking a pull request the trail already has is a no-op; a pull request that belongs to a dif…
trails_list view, scope, phase, type, health, owner, q, mergedSince, touches, f, sort, cursor, limit
List the project's trails — the unit of shipping (an outcome with its items, milestones, pull requests and release tools; each row carries its lead, start and target dates, health and progress). LIST BEFORE YOU CREATE: check no trail already ships this. PAGING: `limit` (1–200) is REQUIRED; pass the previous `next_cursor` as `cursor` for the next page. FILTERS (optional, ANDed, applied in SQL): `scope` = mine | reviewing | ready | releasing | shipped | closed | all (default all); `phase` = planning | building | reviewing | ready | releasing | shipped | closed; `type` = feature | bug | task; `health` = on_track | at_risk | off_track; `owner` = a person or agent (the lead); `q` = substring of title or body. SORT (optional): `sort` = number | title | phase | priority | owner | health | progress | target | changes | findings | items | released | updated | created, `-` prefixed for descending (default `-updated`). ATTRIBUTION: `mergedSince` (ISO-8601) with `touches` (a file path or a resource key) lists the trails that merged in a window and changed a path or link a resource — the candidates for an error or alert that started after a release.
trails_milestones_add handle, name, description, targetDate, position
Add a milestone to a trail. Add a named stage to the trail, with an optional description and target date. Milestones are ordered: omit `position` to add it last, or pass one to insert it there and move the rest down. Progress is counted per milestone, and the build works the trail milestone by milestone …
trails_milestones_remove handle, milestoneId
Remove a milestone from a trail. Remove a milestone. Its items stay on the trail, in no milestone; the milestones after it move up one. Nothing else on the trail changes.
trails_milestones_update handle, milestoneId, name, description, targetDate, position
Change a milestone. Rename a milestone, change its description or target date, or move it in the trail's order with `position` (the others shift to make room). Pass at least one field; the rest are left as they are.
trails_pause_autopilot handle, reason
Pause a trail's autopilot. Stop autopilot on a trail: it answers no more plan questions, approves no plan and merges nothing until a person resumes it. Whatever it already merged or ramped stays; the release controller keeps its own breach policy. Safe to call at any time, and for anyone who can write t…
trails_pause_rollout handle, reason, resource
Pause a trail's rollout. Pause the release controller on a trail: it stops stepping the flag and watching the guards until the rollout is resumed. The flag stays wherever it is. A trail that ships behind several flags has a rollout per flag; pass `resource` (the flag's trail-resource id or its key) to…
trails_plan_revisions handle
List a trail's plan revisions. Every approved revision of the trail's plan, newest first: the plan as it was approved, who approved it and when, and what changed since the revision before. A plan is revised by a `replan` run, which re-reads the goal metric, the items' outcomes and project memory and drafts …
trails_promote_finding handle, findingId, type, reason, title
Promote a finding to a queue item. Move a finding that is real but out of scope onto the queue. It creates a bug (or a feature request, with `type`) whose description quotes the finding, its path and line, and its push. The new item lands on the trail with source `finding`, and the finding is dismissed as `move…
trails_reject_suspect handle, suspectId
Reject a suspected regression. Reject a suspect: the item stays where it is, off the trail, and the suspect leaves the trail's suspected regressions. A person's call — the restricted ops key cannot reject.
trails_release_facts handle, proxy
Read a trail's release facts. What the numbers say about how the trail can ship, before anyone picks an approach: the traffic reaching the surface (distinct units a day over the last 28 days), its tier, whether a 50/50 experiment would reach significance within 28 days at the lift the goal asks for (or 5%)…
trails_reopen handle
Reopen a trail. Reopen a closed trail so its changes can be reviewed and merged again. Its phase is recomputed from its changes and resources.
trails_resources_add handle, kind, resourceKey, role
Link a resource to a trail. Link a product entity to the trail with a *role* — what it is for: `ships_behind` (the flag the code ships behind), `rollback` (the kill switch that undoes it), `measures` (the experiment or metric that judges it), `guards` (an alert rule that watches it), `copy` (an i18n key)…
trails_resources_list handle
List a trail's resources. The flags, configs, kill switches, experiments, metrics, alert rules, events and i18n keys the trail ships or depends on, each with its role and its live state (a flag's prod rollout, an experiment's status and decision, a kill switch's position, an alert's firing state, wheth…
trails_resources_remove handle, id
Unlink a resource from a trail. Remove a resource from the trail. The entity itself is untouched; only the trail's link to it goes, and the release gates stop counting it.
trails_review handle, prUrl, agentKeys
Run the review agents. Launch the project's review agents on a change's latest push now, instead of waiting for the next push. Each agent's eval reads `pending` until its run submits. Agents sharing a coding-agent trigger are reviewed in one run. Review runs spend your own agent quota, not Shipeasy …
trails_start handle, agent, connectorId, kind, prompt
Start an agent on a trail. Fire the project's coding-agent trigger on the trail. While the trail has no approved plan, this fires a read-only **plan** run: it reads the trail, asks the person how it should ship (straight to main, behind a flag, flag and experiment, kill switch, flag and kill switch) and…
trails_submit_eval handle, agentKey, value, rationale, findings, prUrl, headSha, agent, sessionId, resources
Submit a review agent's eval. Record one review agent's result on one push of a change: a `value` (0–100 for a score agent, 1/0 for a boolean one), a short `rationale`, and any `findings`. The verdict (pass / warn / fail) is computed from the agent's threshold and polarity. Submitting again for the same pu…
trails_submit_plan handle, plan, release, breakdown, marketing, sources, summary
Submit a trail's plan. A plan run submits what it worked out: the plan in markdown, the `release` block (how the trail ships, why, and the exact flags, kill switches, experiments and tracking — events, metrics, alert rules — the build will create; no release tool for `straight_to_main`), the `breakd…
trails_timeline handle, before, limit, decisions
Read a trail's timeline. Everything that happened on the trail, newest first: created, plans approved, questions asked and answered (on the trail and on its items), runs, items filed and done, pull requests opened, approved and merged, every rollout step, pull-back and autopilot action, the goal watch…
trails_unlink_pr handle, prUrl
Unlink a pull request from a trail. Detach a pull request from the trail. Its recorded pushes, evals, findings and approvals stay in history but no longer count toward the trail's gates. A merged change cannot be unlinked.
trails_update handle, title, body, type, priority, ownerId, ownerConnectorId, repos, startDate, targetDate, health, goal, autopilot
Change a trail. Change a trail's title, intent, type, priority, owner (the lead), repo scope, start and target dates, health, goal or autopilot. Pass at least one field; the rest are left as they are. Changing the type changes which release gates apply.
trails_update_finding handle, findingId, status, reason, agent
Resolve or dismiss a finding. Set a finding's status — `resolved` (it was fixed; say how in `reason`), `dismissed` (it is not a problem; say why), or back to `open`. A finding that is real but out of scope is not dismissed: promote it with `trails promote-finding`.
trails_update_plan handle, plan, release, breakdown, marketing
Edit a trail's plan. A person edits the plan text, the release block (strategy, reason, the resources to create) or the breakdown (milestones and items). Pass at least one field. Any edit puts the plan back to `drafted`, so it needs approving again; a trail with no plan yet gets one this way. Not …
whoami
Show the current project. Returns the project the caller's auth header resolves to — plan, status, billing, and which modules are enabled. The server reads the project from the credential, so there is no id parameter. Powers `whoami`.
metrics_grammar
Print the metric query DSL grammar. Print the full metric query DSL reference — grammar, aggregation semantics, filter/group-by/ratio rules, and glossed examples — used to author `metrics create --query`.
docs_list sdk
List an SDK's documentation tree. Fetch an SDK's `/docs/manifest.json` and return the doc tree — feature pages, nested snippet groups, the optional setup-topic map, and whether an installable skill exists.
docs_get sdk, path, framework, name
Fetch one SDK doc page or snippet. Fetch one feature page (`flags`, `experiments`, …) or nested snippet (`release/experiments`, …), substituting declared {{placeholders}} from caller args.
docs_skill sdk, install
Fetch an SDK's installable LLM skill. Fetch the SDK's `skill/SKILL.md` (frontmatter intact) so an agent can install it verbatim. The CLI `--install` writes it locally (a consumer fs side-effect).

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Files it wrote

Paths inside its sandbox, where its home folder is /tmp and its own folder cannot be written to.

Install facts

LicenseMIT
Needsnode >=20
Sourcegithub.com/shipeasy-ai/shipeasy
Install scriptsNone declared by it or anything installed with it.
Tarballsha512-w2z2hZhU+HC+NjQ1qVtoxtNSQOLeWKG4pZZMsVPnzHoSDXcAEyjvRgILTYvnA1+hsNNsgbST/g0BErE+CUliAA==

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.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/@shipeasy/mcp.svg)](https://bragproof.smaverk.com/r/%40shipeasy/mcp)

New version out? Ask for a fresh report.