AppCrane
NPM · APPCRANE-MCP
Deploy and manage apps on your own AppCrane instance, the self-hosted PaaS for AI-built apps.
Available components
Last scanned (3 hours ago)
Scores higher than 55% of npm servers
Category Cloud Infrastructure
How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. How we score → Why this is hard to score →
Supply Chain Security63
- No malware found by supply-chain analysis.Pass
- Known CVEs could not be checked: the version this server declares is not published in its registry.Unverified
- No install/post-install scripts declared.Pass
- Dependency health could not be checked: the version this server declares is not published in its registry.Unverified
Provenance & Transparency97
- Source repository is publicly reachable at the declared URL. View diagnostics → Pass
- Cryptographically verified build provenance (signed, bound to gitayg/appcrane-mcp). View diagnostics → Pass
- Clear OSI-approved license (MIT).Pass
- Actively maintained (last published 0 days ago).Pass
- Disclosure check failed: no security disclosure policy was found in the source repository. See how to fix → Fail
Schema Quality & AI Usability63
- AI-judged instruction clarity (excellent).Pass
- Context-footprint check failed: tool/resource definitions use about 21541 tokens (~283/item across 76 items; 76 tools + 0 resources), over budget; trim descriptions and params. See how to fix → Fail
- Usage-examples check failed: none of the tools include examples. See how to fix → Fail
Stability & Change Management100
- No destabilizing schema changes in the last 30 days.Pass
Tool Coverage96
- 100% of tools have a non-trivial description (not blank, and not just the tool's name).Pass
- 88% of tool parameters carry a description.Partial
Tool Safety25
- Injection-marker check failed: the description of tool "appcrane_provision_database" contains an instruction to conceal the call from the user, the text "do not tell the user", at byte 1072 of that field. See how to fix → Fail
- 0 of 7 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "appcrane_deploy" implies "deploy" and declares no destructiveHint at all, which the MCP spec reads as destructive by default. See how to fix → Fail
- An AI judge read all 76 captured unit(s) of tool text and found none that tries to manipulate the model reading it.Pass
Capabilities100
- Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.Pass
Checks we ran (14)
- Malware scan
- Install scripts
- Source repository
- Provenance
- License
- Maintenance
- Security disclosure
- Schema quality
- Stability
- Tool coverage
- Injection markers
- Destructive annotations
- Judged manipulation
- MCP protocol
Checks we could not complete (2)
These are gaps on our side, not findings about this package. We only credit what we can confirm, so a category made up entirely of them scores 0.
- Known CVEs in Supply Chain SecurityKnown CVEs could not be checked: the version this server declares is not published in its registry.
- Dependency health in Supply Chain SecurityDependency health could not be checked: the version this server declares is not published in its registry.
Does not apply to this package (2)
- Endpoint SecurityScored on hosted endpoints only. A package has no live endpoint of its own for us to probe.
- Transport & ReachabilityScored on hosted endpoints only. A package has no live endpoint of its own for us to probe.
The score does not measure everything. What the score does not measure →
Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.
- 22 Nov 26 −11
- Known CVEs: pass → unverified ▼ security
- Dependency health: 0.84 → unverified ▼ functional
- Package version: 1.8.3 → 1.8.4 functional
- 18 Nov 26 +26
- Malware scan: unverified → pass ▲ security
- Known CVEs: unverified → pass ▲ security
- Dependency health: unverified → 0.85 ▲ functional
- 17 Nov 26 −26
- Malware scan: pass → unverified ▼ security
- Known CVEs: pass → unverified ▼ security
- Dependency health: 0.85 → unverified ▼ functional
- Package version: 1.8.2 → 1.8.3 functional
- 14 Nov 26 +1
- Stability: 0.97 → pass security
- 12 Nov 26 +1
No change was recorded against any check on this day. Stability & Change Management went from 90 to 93. That category is still filling its 30-day observation window: 27 days of observed history at the previous scan, 28 at this one. The score rises as the window fills, whether or not the server changes.
- 10 Nov 26 +1
- Package version: 1.5.1 → 1.8.2 functional
- 9 Nov 26 0
- Security disclosure: unverified → fail ▼ functional
- 8 Nov 26 −3
- Security disclosure: fail → unverified ▼ functional
- Stability: pass → 0.80 functional
- Package version: 1.8.1 → 1.8.2 functional
Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.
Captured 22 Nov 2026 · Analysed npm/appcrane-mcp@1.8.4
Provenance Verified
A signed build attestation was found and verified, binding this exact artifact to the source repository it claims to come from.
| Result | Verified |
|---|---|
| Ecosystem | npm |
| Reason | Verified |
| Discovered via | Registry attestation endpoint |
| Source repo | gitayg/appcrane-mcp |
| Certificate issuer | https://token.actions.githubusercontent.com |
| Certificate SAN | https://github.com/gitayg/appcrane-mcp/.github/workflows/publish.yml@refs/tags/v1.8.4 |
| Rekor log index | 4040513748 |
| Predicate type | SLSA build provenance https://slsa.dev/provenance/v1 |
| Subject digest | sha512:0dc300a598824721c7e71ba6dda3efcdd4bbd4c8214719181bc658eb1d05069d292dbbd26d25653a993b93a3020da64d0310309348bf22ed8f25d93fd |
Background: How many MCP packages publish verified provenance →
The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →
appcrane_push_to_managed_app ~595
Push a batch of files to a managed app's AMC_<slug> repo, authenticated server-side via AppCrane's service-account credential. Use this — NOT github_push_files — for managed apps, because github_* tools authenticate with the caller's personal PAT, which has zero access to the service account's repos. Multiple files become a single commit. files: [{ path, content, encoding? }] where encoding defaults to "utf-8" (use "base64" for binaries like icons). Requires the app to already exist via appcrane_create_managed_app. v2.7.22: response now includes per-file `sha256` (hex) and decoded `bytes` length so you can verify integrity — compute the SHA-256 of the bytes you sent, compare to the server's echo, and fail loudly if they differ. Essential for binary files where inline-string truncation or trailing-byte issues would otherwise produce a silently-broken commit. v2.10.7: for a large CODE file, do NOT inline it — upload the bytes over HTTP and commit by token. (1) `curl -F file=@big.js -H "X-API-Key: <your dhk_mcp_ key>" https://<host>/api/files/staged` returns { token, sha256, size_bytes }. (2) Pass that file as { path, staged_token } instead of { path, content }. The server reads the staged bytes and commits them verbatim, so 100+ KB sources push reliably without the model having to emit the content (which is where inline truncation comes from). Per file, provide exactly one of content or staged_token. Staged tokens are owner-scoped and expiring. DELETIONS: pass `deletions: ["old/path.js", ...]` to remove files in the SAME commit as the writes. Crane-hosted apps only (a GitHub-backed managed app is refused — GitHub's contents API cannot express a deletion). For a pure deletion send files: []. Every deleted path must already exist on the branch (a typo is refused by name, never a silent no-op), no path may appear in both files and deletions, and a push that would leave the repository with no files at all is refused. The response echoes what was removed as `deleted`.
| Name | Type | Req | Description |
|---|---|---|---|
| branch | string | – | Target branch. Defaults to the repo's default branch (usually "main"). |
| deletions | array | – | Paths to remove in this same commit. Crane-hosted (repo_backend=local) apps only. Combine with files, or send files: [] for a pure deletion. |
| files | array | yes | – |
| message | string | – | Commit message. Defaults to "chore: scaffolding for <slug>". |
| slug | string | yes | Managed app slug. Repo name resolved as AMC_<slug>. |
No output schema declared.
No examples provided.
appcrane_rename_app ~261
Rename an app's slug. The slug is its URL, its container name and its data directory, so this changes all three — but it is NOT destructive: deploy history, env vars, ports, per-app roles and grants are keyed on the app id, not the slug, and survive untouched. The old slug is kept as a redirect unless redirect=false. The app's owner or a platform admin; only a platform admin may pass redirect=false, and an owner may rename an app at most 3 times in 24 hours. Use this instead of recreating an app under a new name, which is what loses the history. To free a slug held by an app you no longer want, rename THAT app out of the way with redirect=false rather than deleting it — deleting clears the database rows but leaves data/apps/<slug> on disk, and the rename then refuses because the directory is still there.
| Name | Type | Req | Description |
|---|---|---|---|
| new_slug | string | yes | New slug: lowercase letters, digits and dashes, starting with a letter or digit. |
| redirect | boolean | – | Keep the old slug redirecting to the new one. Pass false when you are freeing the old slug for another app to take. |
| slug | string | yes | Current app slug. |
No output schema declared.
No examples provided.
appcrane_request_capability ~363
Ask a platform admin to approve a sensitive capability for an app: a managed database, sign-in bypass paths, headless mode, public visibility, a raw TCP/UDP host port, a custom domain without AppCrane sign-in, outbound e-mail, an external secret store connection, the LLM gateway, outbound internet hosts (egress) or a platform API connection (connection:<name>). Owner or app admin of the app. Give a reason and the narrowest scope that works; the admin may narrow it further and set an expiry. One open request per app and capability: asking again returns the open one. This only files the request: a platform admin decides it in the dashboard, and an agent can never approve one. Scope by capability (examples): managed_database {"engines":["postgres"]}; auth_bypass_paths {"paths":["/webhooks"]}; headless {}; public_visibility {}; tcp_ports {"ingress_type":"tcp","public_port":null}; outbound_email {"recipient_domains":["example.test"]}; external_secret_connections {"providers":["vault"]}; custom_domain_unprotected {"domains":["app.example.test"]}; llm_gateway {}; egress {"hosts":["api.example.test"]}.
| Name | Type | Req | Description |
|---|---|---|---|
| capability | string | yes | One of managed_database, auth_bypass_paths, headless, public_visibility, tcp_ports, outbound_email, external_secret_connections, custom_domain_unprotected, llm_gateway, egress, or connection:<name> f… |
| reason | string | yes | Why the app needs it (required, up to 1000 characters). |
| scope | object | – | What exactly is needed, in the shape shown for the capability. |
| slug | string | yes | App slug. |
No output schema declared.
No examples provided.
appcrane_reveal_secret ~266
Reveal the PLAINTEXT of ONE secret by key. Use ONLY when the user explicitly needs the actual value — it will appear in this conversation transcript, so treat the transcript as sensitive afterward (and consider rotating the secret if the transcript may be stored/shared). For checking whether a var is set, comparing values, or seeing what exists, use appcrane_get_secret (masked) instead — do NOT reveal just to inspect config. Single key only — it never dumps the whole env. Every reveal is audit-logged. For a Secrets Manager reference this returns the reference text with source="secrets_manager" and never fetches the value from AWS. Defaults to sandbox; env="production" only when the user explicitly asks. App admins can reveal sandbox values; a PRODUCTION value needs the app owner or a platform admin, and a person's recent confirmation: a call refused with STEP_UP_REQUIRED names a link for the user to open and confirm, then retry within the minutes it states.
| Name | Type | Req | Description |
|---|---|---|---|
| key | string | yes | Exact env var name to reveal (e.g. "RESEND_API_KEY"). One key per call. |
| slug | string | yes | App slug, e.g. "mysite" |
| stage | string | – | Target stage (legacy alias: env). |
No output schema declared.
No examples provided.
appcrane_revoke_app_access ~90
Remove a user's access from an app entirely. Idempotent: returns ok even if the user had no access. App-admin or owner of the app required (or platform admin); only an owner or platform admin can remove an owner. Refuses to remove the only remaining owner.
| Name | Type | Req | Description |
|---|---|---|---|
| slug | string | yes | – |
| user | string | yes | User id, email, or username |
No output schema declared.
No examples provided.
appcrane_rollback ~190
Roll an env back to a prior release. Pass deployment_id (from appcrane_list_releases) to target a specific release, or omit it to roll back to the immediately previous one. Re-runs that release from its recorded build and health-checks it. A rollback to the IMMEDIATELY PREVIOUS release restarts the cached per-commit image without rebuilding, because image_retention defaults to 1 (the running image plus the one behind it); rolling back further, or on an app whose image_retention is 0, rebuilds that commit first. Records a NEW deployment and marks the previous live one rolled_back. Owner-only (or platform admin).
| Name | Type | Req | Description |
|---|---|---|---|
| deployment_id | integer | – | Target release id. Omit to roll back to the previous release. |
| slug | string | yes | – |
| stage | string | – | Target stage (legacy alias: env). |
No output schema declared.
No examples provided.
appcrane_run_backup_now ~157
Run the off-site backup immediately and report what was uploaded. Use this to PROVE a new configuration works instead of waiting for the nightly run to fail quietly — it exercises the real credentials, the real bucket and the real upload path, and records the result in last_run / last_error exactly as the scheduled job does. Works whether or not the schedule is enabled, so a configuration can be verified before turning it on. Uploads a verified backup set: the database, .env, icons, per-app /data and volumes, managed-database dumps and every managed-app git repository, plus a SHA-256 manifest (`key` is the manifest key, `size` the total bytes of the set). PLATFORM ADMIN ONLY.
Input schema present but exposes no named parameters.
No output schema declared.
No examples provided.
appcrane_run_cron_now ~195
Trigger a scheduled cron job RIGHT NOW, regardless of its schedule. Useful for "I want to test my daily rebuild without waiting until midnight" or "rerun yesterday's failed job." Runs the same `docker exec` the tick loop would against the app's container, or for a job from vercel.json the same GET of its path; updates last_run_at / last_exit_code / last_log just like a scheduled run. Returns the exit code and last-log tail. App-admin or owner. Idempotent: if the job is already running (mutex held), reports it and skips rather than overlapping.
| Name | Type | Req | Description |
|---|---|---|---|
| name | string | yes | Job name from deployhub.json `cron[].name`, or the vercel:<path> name appcrane_list_cron shows for a vercel.json cron. |
| slug | string | yes | – |
| stage | string | – | Target stage (legacy alias: env). |
No output schema declared.
No examples provided.
appcrane_scan_app ~275
Scan one app's dependencies against OSV right now and record the result, instead of waiting for its next deploy or the nightly run. Use it after fixing a lockfile to confirm a finding is gone, or on an app whose last result was `skipped` or `error` to find out what it actually contains. REPORT ONLY — it records a row and feeds the daily digest; it never blocks, fails or rolls back anything, and running it cannot disturb the app. It does not throw on a failed scan either: an unreachable OSV or a missing lockfile comes back as `ok: false` with status `error` or `skipped`, meaning the app was NOT scanned and is NOT known to be clean. `ok: true` with status `findings` is the opposite case — the scan worked and found something. Reads the LIVE release through the same `current` symlink the running container was built from. Defaults to the PRODUCTION stage: most AppCrane tools default to sandbox, but the code an advisory applies to is the code that is serving. ADMIN ONLY.
| Name | Type | Req | Description |
|---|---|---|---|
| slug | string | yes | App to scan. |
| stage | string | – | Stage to scan. Defaults to production — that is the deployed code an advisory applies to. Target stage (legacy alias: env). |
No output schema declared.
No examples provided.
appcrane_scan_report ~655
Which hosted apps have known-vulnerable dependencies? Reports the recorded CVE scan state for the whole fleet, or for one app with `slug`. REPORT ONLY: this scan has never blocked a deploy and cannot — the apps belong to other teams who did not choose the control, so findings are recorded and mailed and the deploy proceeds either way. Never relay a finding as a deploy failure. READ `status` BEFORE READING COUNTS. It is four-valued: `ok` (scanned, nothing found) and `findings` (scanned, something found) are results; `skipped` (no lockfile AppCrane can read) and `error` (OSV unreachable, unparseable lockfile) mean the app was NOT SCANNED, as does having no scan row at all. Those two carry no findings for the same reason an unopened box is empty, and an agent that reports such an app as clean has stated the opposite of what is known — "no vulnerabilities found" is only ever true of an app whose status is `ok`. READ `coverage` BEFORE THE FINDINGS AND BEFORE `assurance`. It is the explicit arithmetic — `{ rows, covered, not_covered, skipped, errored, never_scanned, percent }` — where `percent` is covered/rows floored, and it is the only field that says how much of the fleet these numbers describe. `assurance` is still none / partial / complete and still means exactly that, but `partial` spans 1% to 99%: 30 covered rows out of 99 is `partial` and so is 98 out of 99, so NEVER relay `partial` as "mostly covered" or relay it without the counts beside it (`assurance_note` states this too). `skip_reasons` and `error_reasons` name WHY rows are uncovered, counted and most-common first, from the reason each row recorded — quote them instead of reporting a bare "67 skipped". `unscanned_count` and `unscanned_by_status` are unchanged. EVERY FINDING CARRIES `ecosystem` AND `fixed` beside `name`, `version` and `ids`. `fixed` is the version that resolves those advisories, or null when OSV PUBLISHED NO FIXED VERSION — a null means there is nothing to upgrade to yet, NEVER that no fix i…
| Name | Type | Req | Description |
|---|---|---|---|
| slug | string | – | Report one app (both stages) instead of the whole fleet. |
No output schema declared.
No examples provided.
appcrane_set_app_context ~114
REPLACE an app's entire agent context. Destructive: whatever a human or another agent wrote is gone. Prefer appcrane_append_app_context unless you are deliberately rewriting the whole document — and read it first with appcrane_get_app_context so you know what you are discarding. Pass an empty string to clear it. App admin or owner required.
| Name | Type | Req | Description |
|---|---|---|---|
| content | string | yes | The full new content. Replaces everything. Empty string clears the context. |
| slug | string | yes | App slug. |
No output schema declared.
No examples provided.
appcrane_set_app_icon ~196
Set the tile icon for an app (shown on the Dashboard, the Launcher cards, the Manage table, and the frame topbar). Accepts a base64-encoded image in PNG / SVG / WEBP / JPEG / GIF. For repo-tracked icons prefer committing public/icon.png to the repo — AppCrane picks it up automatically on each deploy. Use this MCP tool when the icon needs to change without a redeploy, or when the source isn't in the repo. Replaces any existing icon. App-admin or owner required (or platform admin).
| Name | Type | Req | Description |
|---|---|---|---|
| base64 | string | yes | Base64-encoded image payload. May or may not include the data URL prefix (data:image/png;base64,…) — both work. Max 500 KB decoded. |
| format | string | yes | Image format. Determines the on-disk file extension (icon.<format>). |
| slug | string | yes | App slug. |
No output schema declared.
No examples provided.
appcrane_set_app_ingress ~1,343
Switch an app between HTTP ingress, raw TCP ingress and dual (both), and choose its public host port. PLATFORM ADMIN ONLY — this is not an owner self-service field like auth_mode. ingress_type=`tcp` publishes 0.0.0.0:<public_port> -> the container in ADDITION to the loopback publish every app has, so clients connect straight to the host and Caddy never sees the traffic: no forward_auth/SSO, no identity headers, no per-request audit, no rate limiting, no security headers, no TLS from AppCrane. Every control AppCrane has assumes Caddy is the only door; this adds a second one the platform does not control, and the app then owns authentication completely. Do NOT reach for this to make an app reachable without login — that is auth_mode=`headless`, which still goes through Caddy and keeps TLS, security headers and logging. Use `tcp` ONLY when the app does not speak HTTP at all (a forward/CONNECT proxy tunnels raw bytes; no reverse proxy can express that). ingress_type=`dual` (v2.45.0) is for an app that is BOTH: its HTTP control plane keeps being served through Caddy on container port 3000 with every control intact (and stays the plane its health check probes), while a SECOND listener inside the same container — data_plane_port, which is REQUIRED and must not be 3000 — is published raw at 0.0.0.0:<public_port> with none of them. Setting data_plane_port to 3000 is refused: that would republish the ordinary HTTP origin Caddy fronts, unauthenticated and unaudited, which is the exact surface Caddy is in the path to protect. Omit public_port to keep the existing allocation, or to have the lowest free port in 31000-31999 allocated — a dedicated band so the operator firewalls one predictable block; an explicitly NAMED port may be anything in 1024-65535, because clients are configured with a port by hand or by MDM and a number like 8080 is often not the platform's to choose. Naming a port outside the auto band is legal and safe — the guards that matter (the WHATWG blocked list,…
| Name | Type | Req | Description |
|---|---|---|---|
| data_plane_port | integer|null | – | CONTAINER port the raw publish targets, 1024-65535. REQUIRED with ingress_type='dual'. On any other type the only accepted value is null, which DROPS a data plane the app still has pinned — required… |
| data_plane_protocol | string | – | Transport of the raw data plane. Only valid with ingress_type='dual' (a pure-tcp app's published port is its HTTP port, which the health probe reaches over TCP). Default tcp. Use udp for UDP-only pro… |
| ingress_type | string | yes | http = through Caddy (default). tcp = the container port is published on the host, with no AppCrane authentication in front of it. dual = both — the HTTP control plane stays behind Caddy on container… |
| public_port | integer | – | HOST port to publish. Only valid with ingress_type='tcp' or 'dual'. Omit to keep the port the app already holds, or to have one allocated from 31000-31999; name one explicitly and it may be anything… |
| sandbox_public_port | integer|null | – | HOST port to publish for the SANDBOX container, so a raw data plane can be exercised before it goes live. Opt-in and independent of public_port — omit it and sandbox publishes nothing, exactly as bef… |
| slug | string | yes | App slug. |
No output schema declared.
No examples provided.
appcrane_set_app_meta ~736
Set an app's category, visibility, auth_mode, and/or auth_bypass_paths — the owner self-service fields (same controls the dashboard Launcher exposes to owners). Owner of the app (or platform admin) required. visibility is one of public / private / hidden. auth_mode is `authenticated` (default — all routes go through AppCrane SSO) or `headless` (the app bypasses forward_auth ENTIRELY and is reachable without identity — right tool for telemetry ingest, public webhooks, status pages; the app's own server is responsible for any payload-level authn). A headless app is still served BY CADDY over HTTP — TLS, security headers and access logging all still apply; it is not a raw port. An app that does not speak HTTP at all needs ingress_type='tcp', and an app that speaks HTTP AND needs a second raw port for non-HTTP clients needs ingress_type='dual' (both via appcrane_set_app_ingress, platform admin only) — different and far more exposed things. auth_bypass_paths (v2.7.27+) is an array of path prefixes (e.g. ["/ws/local-runner"]) that bypass SSO on this app only — narrower than headless mode; the app authenticates those paths itself (e.g. token in query string). The platform strips incoming X-AppCrane-* headers on bypass paths (forgery defense intact) and suppresses access logging for them (token-in-query never sits in log storage). Owners may only assign an EXISTING category; creating a brand-new category is reserved for platform admins. For powerful fields (github_url, branch, token, source_type, resource limits) use appcrane_update_app (admin only).
| Name | Type | Req | Description |
|---|---|---|---|
| auth_bypass_paths | array | – | v2.7.27: array of path prefixes (e.g. ["/ws/local-runner"]) that bypass SSO forward_auth on this app. Requests under these prefixes reach the container with NO X-AppCrane-* identity headers — the app… |
| auth_mode | string | – | authenticated = AppCrane SSO + per-app role checks; headless = NO auth at the proxy (the entire app is reachable by anyone on the internet). |
| category | string | – | Category/tag. Owners must pick one already in use; pass empty string to clear. |
| custom_domain_auth | boolean | – | true = put the app's normal AppCrane sign-in in front of its custom domain too (visitors are signed in by a one-time handoff from the platform host; production roles apply). false (default) = the cus… |
| domain | string | – | v2.10.0: custom domain (e.g. "app.example.com") that serves this app at the ROOT of that domain with NO AppCrane SSO and NO topbar — the app does its own auth (unless custom_domain_auth is on). Maps… |
| slug | string | yes | App slug. |
| visibility | string | – | public = anyone; private = assigned users; hidden = not discoverable. |
No output schema declared.
No examples provided.
appcrane_set_backup_config ~401
Configure the scheduled off-site (S3 / S3-compatible, e.g. Cloudflare R2) backup. Every field is optional — only what you pass is changed. Enabling is REFUSED unless bucket, access_key_id and a stored secret are all present, because an enabled-but-unconfigured backup fails silently every night while every status surface reads "enabled", which is worse than being plainly off. SECURITY: `secret_access_key` is write-only — AppCrane encrypts it and never returns it — but passing it here means the plaintext value travels through this conversation and whatever logs it. Prefer Settings → Backup in the dashboard for the secret itself, and use this tool for the rest. PLATFORM ADMIN ONLY: this names the destination a copy of every secret on the platform is written to, so pointing it at the wrong bucket is an exfiltration path, not a misconfiguration.
| Name | Type | Req | Description |
|---|---|---|---|
| access_key_id | string | – | Access key id. Not a secret on its own; stored in the clear. |
| bucket | string | – | Destination bucket name. |
| enabled | boolean | – | Turn the nightly schedule on or off. Refused with enabled=true unless bucket, access_key_id and a stored secret all exist. |
| endpoint | string | – | Custom S3 endpoint for a non-AWS provider (Cloudflare R2, MinIO). Leave empty for AWS. |
| hour | integer | – | Hour of day (server local time) to run. Default 3. |
| prefix | string | – | Key prefix inside the bucket, e.g. "appcrane/". Optional. |
| region | string | – | Region, e.g. us-east-1. Defaults to us-east-1. |
| secret_access_key | string | – | Secret access key. Write-only: encrypted at rest, never returned by any read surface. NOTE: passing it here puts the plaintext in this conversation — the dashboard is the better place for it. |
No output schema declared.
No examples provided.
appcrane_set_request_status ~178
Move a request through the lifecycle: triage → in_progress → shipped → validated. Use this when the user says "I'll take #42" (set to in_progress), after merging a PR (set to shipped), or after confirming a fix works (set to validated). Validated requests are considered closed. Requires app-admin or AppCrane admin role.
| Name | Type | Req | Description |
|---|---|---|---|
| bucket | string | yes | Target bucket. |
| id | number | yes | Request id (the # column). |
| note | string | – | Optional, used with bucket=shipped. A short plain-language summary, for the person who filed the request, of what you changed and how it affects them. It is emailed to them and shown in their My Requ… |
No output schema declared.
No examples provided.
appcrane_set_secret ~319
Set or update a secret (an encrypted environment variable injected into the app). Encrypted at rest; only the running app process can read the plaintext. With store="secrets_manager" (needs a secrets provider on this AppCrane) the value goes to AWS Secrets Manager under this app and env's own path, and AppCrane keeps only the reference secretsmanager:<KEY>; do not call it more than once every 10 minutes per key. You can also set a reference directly as the value: secretsmanager:<NAME> or secretsmanager:<NAME>#<jsonField>, where NAME holds only letters, digits, _ and - and always resolves under this app and env, never an ARN or a path. A reference is resolved at every deploy and restart, and one that cannot be read fails that deploy or restart. Removing the env var, or the app, does not delete the AWS secret. Defaults to sandbox; require explicit stage="production" only when the user asks. App-admin or AppCrane admin only. Respects the caller's mcp_app_scope.
| Name | Type | Req | Description |
|---|---|---|---|
| key | string | yes | Env var name. Letters, digits, underscores; must not start with a digit. |
| slug | string | yes | – |
| stage | string | – | Target stage (legacy alias: env). |
| store | string | – | Keep the value in AWS Secrets Manager instead of AppCrane's database. Omit for an ordinary encrypted env var. |
| value | string | yes | The value to store (will be encrypted server-side). |
No output schema declared.
No examples provided.
appcrane_set_user_app_roles ~230
Set which app-defined roles a user holds on one app. Replaces their whole set: keys omitted from the list are removed, and keys: [] clears every role they hold. This changes only what the app itself enforces — it does NOT change the user's AppCrane per-app tier, so it can neither grant nor remove deploy / env / delete power. Use appcrane_grant_app_access for that. Every key must already be defined on this app (appcrane_create_app_role) and the user must already have access to the app (appcrane_grant_app_access) — a role on a non-member is unenforceable, since the app never sees them. The result is what the app receives in X-AppCrane-App-Roles on the user's next request. Owner or admin of the app required.
| Name | Type | Req | Description |
|---|---|---|---|
| keys | array | yes | The COMPLETE set of app-defined role keys this user should hold. [] removes all of them. |
| slug | string | yes | – |
| user | string | yes | User id (numeric string), email, or username |
No output schema declared.
No examples provided.
appcrane_stage_assemble ~172
Join the parts pushed with appcrane_stage_chunk into one staged file and return its token. Hand that token to appcrane_deploy_artifact to deploy it — that pair is a complete, MCP-native deploy for an app with no repo, and it does not touch GitHub. Pass sha256 of the WHOLE original file to have the reassembled bytes verified before the token is issued; without it you are trusting that every part arrived intact.
| Name | Type | Req | Description |
|---|---|---|---|
| filename | string | yes | Name for the assembled file. For a deploy it must end in .zip, .tar.gz or .tgz. |
| session | string | yes | The session id used for the parts. |
| sha256 | string | – | Optional hex SHA-256 of the whole original file, verified before the token is issued. |
No output schema declared.
No examples provided.
appcrane_stage_chunk ~277
Upload one part of a SMALL file to AppCrane over MCP. For anything bigger than a few KB use appcrane_stage_from_url instead — the bytes here are emitted by the model, so they cost output tokens per character and fail on a single typo. Capped at 8 parts for that reason. Split the file into parts small enough for a tool call (~256KB of base64 each is comfortable), send each with the same `session` and `of`, then call appcrane_stage_assemble. Parts may be sent in any order and re-sent to replace a corrupted one; the reply lists which parts are still missing. Use encoding="base64" for anything binary. Pass sha256 of THIS part to have it verified on arrival.
| Name | Type | Req | Description |
|---|---|---|---|
| content | string | yes | This part's bytes, encoded per `encoding`. |
| encoding | string | – | Defaults to utf-8. Use base64 for binary. |
| of | integer | yes | Total number of parts. Identical across every part of a session. |
| part | integer | yes | 1-based part number. |
| session | string | yes | Opaque id grouping the parts of one file. Any unique string; reuse it for every part. |
| sha256 | string | – | Optional hex SHA-256 of this part, verified on arrival. |
No output schema declared.
No examples provided.
appcrane_stage_from_url ~245
Stage a file by having AppCrane DOWNLOAD it, and return its token. THE CHEAPEST WAY to get a large artifact in: the bytes go host-to-host and never pass through your context, so a 600KB bundle costs the same handful of tokens as a 6KB one. Prefer this over appcrane_stage_chunk for anything bigger than a small text file. Give it a URL your build already produces — a GitHub release asset, an S3/R2 presigned URL, any https link the server can reach. Pass sha256 to have the downloaded bytes verified before a token is issued. Then deploy with appcrane_deploy_artifact. https only; redirects are not followed; private and link-local addresses are refused.
| Name | Type | Req | Description |
|---|---|---|---|
| filename | string | – | Name to stage it under. For a deploy it must end in .zip, .tar.gz or .tgz. Defaults to the last path segment. |
| sha256 | string | – | Optional hex SHA-256 of the file, verified before the token is issued. |
| url | string | yes | Direct https URL to the file. Must not redirect — give the final URL. |
No output schema declared.
No examples provided.
appcrane_submit_feedback ~287
Send feedback (a bug, an idea, anything else) about an app or about AppCrane itself, when the user asks you to report something, for example "send AppCrane feedback that the deploy error did not name the missing env var". Put the user's point in message in plain words; attach what you know in context (the appcrane_* tool you were using, what the user asked for, the deploy id, the error text, your client name and version) without asking the user for it. With slug set, it goes to that app's request queue (you need access to the app); with slug omitted, it goes to the AppCrane platform admins. Secrets and e-mail addresses are removed before it is stored. Limit 20 an hour per user. Returns { id, target, where }: tell the user where to see it.
| Name | Type | Req | Description |
|---|---|---|---|
| context | object | – | What you know about the situation. Only these fields are accepted. |
| kind | string | – | bug, feature or other. |
| message | string | yes | The feedback in plain language, in the user's words. |
| slug | string | – | The app the feedback is about. Omit (or "appcrane") for feedback about AppCrane itself. |
| stage | string | – | The environment it happened in, if any. Target stage (legacy alias: env). |
No output schema declared.
No examples provided.
appcrane_top_apps ~118
Top apps by distinct active users in a lookback window. Useful for "which apps are getting the most use this week" or "what should I deprecate" type questions. Sourced from app_visits which is recorded on every Caddy forward_auth (one row per user/app/day). Returns rows ordered by user count descending. Admin only.
| Name | Type | Req | Description |
|---|---|---|---|
| days | integer | – | Lookback window. Default 7, max 90. |
| top | integer | – | How many rows. Default 10, max 50. |
No output schema declared.
No examples provided.
appcrane_top_users ~112
Top users by distinct apps opened in a lookback window. Surfaces who the heaviest cross-app users are — handy for finding power users to interview, or spotting churn risk (a user who used 10 apps last month and 0 this week). Sourced from app_visits. Active users only. Admin only.
| Name | Type | Req | Description |
|---|---|---|---|
| days | integer | – | Lookback window. Default 7, max 90. |
| top | integer | – | How many rows. Default 10, max 50. |
No output schema declared.
No examples provided.
appcrane_update_app ~960
Patch fields on an existing app. Use this to fix a missing github_url after the fact, change branch, rotate the github_token, retag with category/visibility, point an image app at a new image_ref, or adjust resource limits — anything you would otherwise need direct DB access for. Only includes fields you pass; omitted fields are left alone. To clear a string field pass an empty string. Returns the same shape as appcrane_get_app.
| Name | Type | Req | Description |
|---|---|---|---|
| auth_bypass_paths | array | – | v2.7.27: array of path prefixes (e.g. ["/ws/local-runner"]) that bypass SSO forward_auth on this app. Requests under these prefixes reach the container with NO X-AppCrane-* identity headers — the app… |
| branch | string | – | – |
| category | string | – | – |
| container_port | integer | – | Port the image listens on inside the container. Omit only if the image really listens on 3000 (what an AppCrane-built image does); a third-party image usually does not — odoo is 8069, nginx is 80. Ge… |
| description | string | – | – |
| domain | string | – | – |
| frame_ancestors | string | – | – |
| github_token | string | – | PAT for private clones. Stored encrypted (AES-256-GCM). Omit to leave the existing token alone; pass empty string to clear it; pass a value to rotate. |
| github_url | string | – | github.com URL of the source repo. Pass empty string to clear. |
| health_path | string | – | HTTP path AppCrane health-checks. Omit only if the image serves /api/health (the AppCrane-built default). A stock image will not, and a health check against a 404 marks a working app unhealthy. Pass… |
| image_ref | string | – | Prebuilt container image to run instead of building from source, e.g. "odoo:19" or "ghcr.io/owner/app@sha256:<64 hex>". Sets source_type='image'. The reference MUST name a version: a bare name ("odoo… |
| image_retention | integer | – | How many PREVIOUS per-commit images to keep per environment, on top of the running one. Default 1: the previous release's image stays on disk, so rolling back to it restarts instead of rebuilding. Ra… |
| max_cpu_percent | number | – | Per-container CPU cap (0-100). |
| max_ram_mb | number | – | Per-container memory cap. |
| name | string | – | – |
| public_access | integer | – | – |
| separate_sandbox_db | boolean | – | Catalogue apps only (a database declared in deployhub.json is always separate per stage): give the sandbox its own managed database instead of sharing production's (default false). true: the next san… |
| show_sandbox | boolean | – | Offer the Sandbox deployment to members and viewers on the launch surfaces (default true). false hides it from them; owners, app admins and platform admins still see it, and the sandbox URL keeps wor… |
| slug | string | yes | App slug to update. |
| source_type | string | – | – |
| visibility | string | – | – |
No output schema declared.
No examples provided.
appcrane_wait_deploy ~140
Block until a deployment reaches a terminal state (live / failed / rolled_back), then return its final status. Use after appcrane_deploy instead of polling appcrane_get_logs in a loop. Returns immediately if the deployment is already terminal. Defaults to 180s timeout, hard-capped at 600s. On timeout, returns { status: "pending", timed_out: true } so the caller can decide whether to keep waiting.
| Name | Type | Req | Description |
|---|---|---|---|
| deployment_id | number | yes | Deployment id from appcrane_deploy |
| timeout_sec | number | – | How long to wait. Default 180s, max 600s. |
No output schema declared.
No examples provided.
How do I install the AppCrane MCP server?
AppCrane runs locally as an npm package, launched with npx -y appcrane-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.
npm · appcrane-mcp
claude mcp add gitayg-appcrane -- npx -y appcrane-mcp
What is the AppCrane MCP server?
AppCrane is an MCP server listed in the public MCP registry as io.github.gitayg/appcrane. Deploy and manage apps on your own AppCrane instance, the self-hosted PaaS for AI-built apps. This page covers its npm package (appcrane-mcp).
Is the AppCrane MCP server safe to use?
AppCrane scores 77 out of 100 on VerifyMCP. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.
What tools does the AppCrane MCP server expose?
AppCrane exposes 76 tools: appcrane_list_apps, appcrane_get_app, appcrane_top_apps, appcrane_top_users, appcrane_get_health, and 71 more. Their descriptions and schemas cost roughly 21,541 tokens of context every time the server is loaded.
Is the AppCrane MCP server still maintained?
AppCrane is still listed as active in the MCP registry. We last reached this channel on 22 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.
What licence is the AppCrane MCP server under?
AppCrane declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.
What did VerifyMCP test on the AppCrane MCP server?
VerifyMCP ran 14 checks on AppCrane, covering Malware scan, Install scripts, Source repository, Provenance and 10 more. 2 items could not be completed, a gap on our side rather than a finding about AppCrane: Known CVEs and Dependency health. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.