Appcrane

MCP开发工具

提供方 gitayg

开发工具 未标注 API Key 社区 / 第三方 ClaudeCursorCodexZed

AppCrane is the self-hosted home for the apps your AI builds and your AI deploys. It exposes 35 appcrane_* MCP tools so any MCP client (Claude Code, Cursor, Codex) can run the full deploy lifecycle — create app, deploy to sandbox/production, manage secrets, stream logs, list rele

一句话选型结论

按资料字段整理

Appcrane 属于开发工具类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude、Cursor、Codex 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式未标注 鉴权API Key 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

self hosted deployment paas mcp docker devops sso agent native

支持客户端

适用场景

self hosteddeploymentpaas

安装与配置

未标注 API Key
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude、Cursor、Codex,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Appcrane当前 未标注 未标注 未标注 无 未标注
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方gitayg上游标注的维护方 gitayg
分类开发工具本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

171.0 KB
来自项目仓库与上游目录的原文,未做删改

AppCrane

Self-hosted PaaS where the agent is the operator and the platform keeps the receipts.

appcrane.dev · How it compares · Deploy from Claude · MCP connector · Changelog

AppCrane runs the internal apps your team builds with Claude Code or Cursor, on a server you own. An agent creates the app, deploys it, reads the logs and rolls it back through 68 MCP tools — no browser, no curl — while the platform enforces SSO and per-app roles, records every action against the actor that took it (tagged agent or human), and keeps app secrets out of reach of the person administering the box.

It is for teams that have to self-host — data residency, a customer contract, an internal-only network — and still have to answer who deployed this, what was in it, and can we undo it?

What is actually uncommon here

Self-hosted PaaS caught up on governance during 2026. Coolify shipped structured audit logging and first-class OIDC; Dokploy shipped SSO, SCIM, custom roles and audit logs. Komodo has had granular per-resource permissions and a full audit trail for longer than either. Most of what used to be a differentiator here no longer is, and the claims below are the ones that survived checking their docs. Four things still stand out:

1. Governance is in the open-source build, not behind a license key. SAML 2.0, OIDC, SCIM provisioning, per-app roles and the audit log are all in the AGPL-3.0 build with nothing to activate. Dokploy ships the same category of capability as Enterprise, gated on a license key. Coolify's are free, but its changelog lists OIDC and audit logging without SAML or SCIM. Komodo's are free too — GPL-3.0, with per-resource permissions and an audit trail in the box — but its documented sign-on is username/password and OAuth (GitHub, Google, generic OIDC), with no SAML or SCIM in the docs. So the free-versus-paid line is really only Dokploy's; against Coolify and Komodo the difference is which enterprise-directory protocols are covered, not what you have to pay to turn them on.

2. The built-in agent interface can change things. Coolify's instance-level MCP server is deliberately read-only — ten list/get tools. AppCrane's 59 include appcrane_deploy, appcrane_rollback, appcrane_promote, appcrane_set_secret and appcrane_grant_app_access. Dokploy's official MCP package is write-capable too, and far larger (508 tools across 49 categories) — AppCrane's surface is smaller by choice, not by capability, and is paired with appcrane_get_guide(topic="onboarding"|"operations"), which serves the current playbook from the server so the agent reads the procedure instead of inferring it from a tool list. Komodo ships no MCP server of its own; neither its repo nor its docs contain one, and the several that exist are third-party wrappers over its REST API.

3. The audit log tells an agent from a person. Every row carries actor_kind, so "what did the agents do on this box last week" is one query. The others record a user identity — Komodo's trail records "who made it and when" (intro) — but none of their docs describe separating automated actors from humans.

4. The operator is locked out of app secrets. Env-var access follows app assignment, and that holds for platform_admin as well — the role that installs and updates the platform cannot read the plaintext of an app it is not assigned to. Reveals are throttled and audited across both doors, HTTP and MCP, so switching transport does not buy a fresh allowance. Komodo documents the opposite arrangement explicitly: marking a variable secret prevents access to the value for non-admin users, which is to say an admin can read it.

Four more that are unusual but worth measuring against your own requirements rather than reading as headlines: per-tenant data isolation for deployed apps; repo-less uploads identified by a server-side SHA-256 over the received bytes instead of a self-reported commit SHA; a daily vulnerability digest mailed per recipient — fleet-wide to a platform admin, own-apps-only to an app owner, so the digest cannot leak which other apps are exposed; and managed repos, so an agent can create and ship an app for someone who has no GitHub account at all.

Versus vendor-hosted governed platforms (Replit, Lovable, Retool, Superblocks), the trade is the usual one: their governance is more mature, and your app data, database connections and API keys live on their infrastructure.

Against self-hosted PaaS

AppCrane Coolify Dokploy Komodo CapRover / Dokku
Multi-host / fleet deploys no — single host yes (experimental) yes, remote servers yes, agent per host Swarm cluster (CapRover)
Built-in MCP that can deploy 62 tools, incl. rollback 10 tools, read-only 508 tools (official package), incl. rollback community projects only community projects only
SAML 2.0 yes not in changelog Enterprise not documented no
OIDC yes yes (v4.4-rc.1) Enterprise yes, generic OIDC no
SCIM provisioning yes not in changelog Enterprise not documented no
Audit log yes, agent vs human attributed yes, structured (v4.1.0) Enterprise yes, full change trail no
Governance behind a paid tier no no yes no n/a
Operator cannot read app secrets yes not documented not documented no — admins can no
Per-tenant data isolation for apps yes not documented not documented not documented no
Deploy identity for repo-less uploads server-side SHA-256 not documented not documented not documented no
Core license AGPL-3.0 Apache-2.0 Apache-2.0 + paid Enterprise GPL-3.0 open source

The first row is the one AppCrane loses outright. Komodo is built around fleet management: a Core web server plus a stateless Periphery agent on every connected machine, with "no limit to the number of servers you can connect", Docker Swarm management, and declarative resource sync from a git repo. AppCrane has no agent, no host registry and no remote-execution path — it deploys containers on the machine it is installed on, and that is the whole design. Coolify and Dokploy both reach other servers too, and CapRover joins nodes through Docker Swarm.

CapRover and Dokku are in one column because their access model is the same shape: a single admin account (CapRover) or SSH keys where the word admin in a key name grants key-management rights (Dokku), with multi-user access an explicitly out-of-scope request in one and an unaudited community plugin in the other. That is a reasonable design for a one-operator box; it is not something to put an IdP in front of.

> Checked against each project's own documentation and changelog in September 2026. "not documented" means the capability does not appear in their docs — that is not proof it is absent, and a vendor page is a claim, not a test. Verify anything load-bearing on your own install.

Honest scope. Coolify has a far larger template marketplace, a much bigger community, and multi-server orchestration; if you want one-click Postgres and hundreds of app templates, use Coolify. Dokploy's API surface is broader than AppCrane's and it sells support with an SLA. Komodo is the better choice the moment the answer involves more than one machine — a fleet of hosts, a Swarm, builds farmed out to spot instances, configuration synced declaratively from git; AppCrane deploys to the box it runs on and nowhere else, so a multi-host estate is not a smaller version of this, it is a different product. Dokku and CapRover are simpler and lighter if one person operates the box. Choose AppCrane when the apps are agent-built, the agent should do the deploying, everything lands on one server you own, and someone will later ask you to prove who did what.

Why it matters now. Three things changed in 2026:

  • The bottleneck moved from writing software to operating it. In Anthropic's Claude Code study (~400k sessions), "operating software" — deploying, configuring, running pipelines — grew from 14% to 21% of sessions while fixing broken code fell from 33% to 19%. Non-engineers now ship deployable code within 7 points of professional engineers. The scarce thing isn't the app any more; it's somewhere safe to run it.
  • Shadow AI became measurable. The 2026 Verizon DBIR reports shadow-AI detections up 4×, AI use on corporate devices rising 15% → 45% in a year with 67% through non-corporate accounts — and source code as the most commonly submitted data type. Bans make it worse; a sanctioned platform is the answer that works.
  • Governance-by-console is the failure mode. Platforms that gate every app behind a human clicking through an approval UI stall once there are hundreds of apps. AppCrane's answer is different in kind: the agent drives the governed lifecycle over MCP, and the platform records and constrains it — rather than a person mediating each step.

Features

  • Each app on its own address (app isolation) — every app used to be served at / on the platform's host, so every app and the dashboard shared one browser origin: one app's script could call any other app as the visitor (AppCrane's sign-in accepted the visitor's one session for every app), and could read the dashboard's session token from browser storage — a full AppCrane session, a platform admin's if an admin opened that app. A platform admin can now set an apps domain (Settings > Security > App isolation; PUT /api/settings/isolation). Each app then answers at https://./ and its sandbox at https://-sandbox./, and the visitor is signed in there by a one-time handoff from the platform host into a cookie that only that app and environment accept (__Host-cc_app); the platform API never accepts it, and signing out of AppCrane ends it. Old / links redirect (308) to the new address, and a path still starting with // has that prefix removed, so apps need no change and keep their APP_BASE_PATH. /api/me and /api/directory keep working from an app's own pages. With it on, the platform cookie becomes __Host-cc_token (everyone signs in again once). The domain can be the platform host itself (apps at .) or another name such as apps.. Needs a wildcard DNS record *. pointing at the server, and either a wildcard certificate (file paths in the same card) or Caddy's on-demand certificates, which AppCrane approves only for its own app addresses. Use a domain under the same registrable domain as the platform host, or apps opened inside the dashboard lose their sign-in (browsers block third-party cookies). Off (no domain) changes nothing. Custom domains can now use AppCrane sign-in too: per app, "Require AppCrane sign-in on the custom domain" (custom_domain_auth, also on appcrane_set_app_meta), off by default. App objects now carry url and sandbox_url. With it on, the dashboard's own policy allows frames from https://*., so app tabs keep working.
  • Dependency fixes: body-parser, multer, nodemailer — body-parser 2.4.0 (CVE-2026-111181, denial of service through bytes trailing a compressed request body), multer 2.5.0 (CVE-2026-113872, denial of service through a file filter still pending after the request ends) and nodemailer 10.2.1 (three advisories). The floors in package.json move with them. npm audit: 0 vulnerabilities.
  • Files uploaded into /data no longer leave root-owned folders — appcrane_cp writing into a folder that did not exist yet left that folder (and the file) owned by root, so an app running as node got EACCES on every later write there until the next deploy re-owned /data. New folders and the file now belong to whoever owns the app's /data (1000:1000 after a deploy), whether the write goes into the container with docker cp or onto the host. Folders that already exist are left exactly as they are, owner and mode included.
  • Node 22 is the default for generated Node builds — an app with no Dockerfile used to build on node:20-alpine, which is end of life and gets no fix for Node2Shell (CVE-2026-111497). The Node line is now node_version in deployhub.json, else engines.node in deployhub.json, else engines.node in package.json, else 22. When the stated range allows 22, 22 is used; otherwise the newest of 26, 24 and 22 that satisfies it, and Node 20 or 18 only when the range allows nothing newer (with a warning in the deploy log). A deployhub.json value no buildable line satisfies fails the build and names it; a package.json value that cannot be satisfied falls back to 22 with a warning. The deploy log says which line was chosen and why. App Studio's coding image moves to Node 22 as well.
  • Node2Shell (CVE-2026-111497) protection — AppCrane refuses request bodies compressed with Brotli before any parser reads them, and Caddy refuses them for every hosted app (Settings > Security > Brotli-compressed uploads, on by default). Self-update and safe-boot move a vulnerable Node 22/24/26 host to 22.23.4 / 24.22.1 / 26.12.1, the boot log and Job Health warn while it is unpatched, and runtime auto-patch rebuilds affected Node apps on a freshly pulled patched base. Blocking Brotli uploads does not cover responses AppCrane or an app fetches from other servers; only a patched Node fixes that. Node 20, 23 and 25 get no fix: move to 22, 24 or 26. Without self-update, upgrade by hand: curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - && sudo apt-get install -y nodejs && sudo systemctl restart appcrane, then check node -v.
  • Immediate vulnerability e-mail — when any scan (deploy, scheduled or manual; sandbox or production; lockfile or image) finds a vulnerable package not reported before, the app's owners and every platform admin get one e-mail per scan. It lists each new finding (package@version, advisory with link, fixed version or "no fix yet", severity and remote-code-execution flag when known), the request that was opened, whether RCE auto-patch will try the fix or a person needs to act, and whether the release check will block production. Each finding is mailed once (again only if it is fixed and later comes back); findings already present at upgrade are not mailed. Platform setting vuln_alerts_immediate (Settings > Security, on by default) turns it off. The daily digest is unchanged. Each batch is recorded as a vuln.alert event.
  • Runtime patching (PHP2Shell and similar) — every build pulls a fresh copy of its base image (generated Dockerfiles always; app Dockerfiles unless a platform admin turns it off in Settings > Security), falling back to the cached copy with a deploy-log warning when the registry cannot be reached. Each image records the base and digest it was built on. An hourly sweep finds apps whose running PHP is affected by a remote-code-execution advisory (OSV Bitnami/php plus a bundled list; PHP2Shell CVE-2026-109618/109619 is fixed in 8.5.12, 8.4.27, 8.3.36 and 8.2.35). For hosted-repository and GitHub apps, under the RCE auto-patch policy (same switch and per-app opt-out), it rebuilds the same commit on the newer base: sandbox, health check, a check that the new PHP is fixed, release check, production, health check, with automatic rollback. The run is audited as change.auto_approved (actor "AppCrane runtime patch"), owners are e-mailed and a request is recorded. Prebuilt-image apps, uploads, PHP branches with no fix (8.1 and older) and non-Docker Hub bases are listed in Job Health for a person, and platform admins get one e-mail per advisory.
  • Managed MongoDB checks the server's kernel — MongoDB 8.0 stops at startup on Linux 6.19 through 7.0.13, Docker images included. AppCrane reads the kernel Docker runs on and refuses a MongoDB database at once with "MongoDB 8.0 can't run on this server's kernel (X); upgrade to Linux 7.0.14 or later" (error code MONGO_KERNEL_INCOMPATIBLE). Settings > Job Health ("Managed MongoDB kernel check") and the managed-database status show the same warning. A database server that stops while starting is now reported within seconds with its exit code and last log lines, instead of after a 2-minute wait. MANAGED_DB_MONGO_SKIP_KERNEL_CHECK=1 turns AppCrane's own pre-check off; MongoDB still runs its own.
  • RCE auto-patch (on by default) — when the dependency scan finds a remote-code-execution advisory (CWE-77/78/94/95/502/917/1336, or advisory text that says code execution) with a published fix on an app whose repository AppCrane hosts, AppCrane bumps only that npm package in package-lock.json using npm in a confined container, once the fixed version has been on the registry for 24 hours and has no advisory of its own. It then deploys to sandbox, runs the release check and promotes to production without a person, rolling production back if its health check fails. Every run is audited as change.auto_approved (actor: AppCrane auto-patch) and owners are e-mailed. It runs only when the branch tip is exactly the commit live in production, so changes a person has not promoted are never shipped with the bump, and it re-checks the switch, the app opt-out and any running restore right before promoting and before any rollback. Any guardrail that does not hold, and every non-RCE fix, stays with a person. A platform admin can turn it off or change the cooldown in Settings → Security; owners can opt an app out on its Manage page. Supported today: npm with a root package-lock.json; other ecosystems keep the human flow. The npm helper runs on an internal Docker network whose only exit is a proxy that allows a tunnel to registry.npmjs.org:443 and nothing else, from a node image pinned by digest; if that confinement cannot be set up, the fix goes to a person. When the lowest fixed version is deprecated on npm, AppCrane picks the lowest release in the same major version that is newer than it, not deprecated, has no advisory of its own on OSV and is past the cooldown, and bumps to that. It never follows the maintainer's suggested version on its own, and if no such release exists the fix goes to a person. An exact version pin stays exact. For auto-patch and runtime-patch runs only, the release check's dependency step passes when the target advisory is gone and every fixable finding left in the candidate is one the live production scan already has. Those findings are listed as unchanged in the release check record, the change.auto_approved audit row and the owner e-mail. A missing or failed production scan, or any new fixable finding, stops the run for a person. Every other release-check step, and every deploy or promote a person starts, is checked exactly as before. Auto-heal after a restart redeploys the exact commit that was live and is not re-checked, so an app with an older known issue still comes back.
  • Two-factor sign-in and session timeouts (SOC 2) — password sign-in supports TOTP authenticator apps (SHA-1 default, SHA-256 optional) with 10 single-use recovery codes, enrolled under Settings → Account. Settings → Security sets who must use it (off / platform admins only, the default / everyone); anyone required but not enrolled sets it up at their next password sign-in. Platform admins can reset a user's MFA (audited, user e-mailed). Single sign-on users get MFA from their identity provider and are not asked twice; API keys are unaffected. Sessions end at the earlier of an absolute lifetime and an idle timeout, enforced on the server for every session whatever issued it: platform admins 8 h / 30 min idle, everyone else 24 h / 8 h idle by default (configurable: lifetime 15 min-30 days, idle 5 min-24 h, changes audited), with a 2-minute warning in the dashboard.
  • Periodic access reviews (SOC 2) — campaigns on a set cadence (optionally per data classification). App owners keep, remove or change each person's access and platform admins review each other; Remove and Change apply at once and are audited, and access granted through SCIM groups is flagged as managed by the identity provider. Reminders, escalation of overdue campaigns to platform admins, and CSV/JSON reports. Pages: My reviews, and Access reviews for admins; API /api/access-reviews/*.
  • Tamper-evident audit (SOC 2) — audit log and event rows are sealed into a SHA-256 hash chain every 5 minutes with HMAC-signed checkpoints (key derived from ENCRYPTION_KEY). Verification every 6 hours and on demand (Audit integrity page, /api/audit-chain/*) names the first row that was modified, deleted or inserted out of order and catches forged checkpoints; platform admins get one critical e-mail per failure. Rows removed by event retention are told apart from rows deleted by hand, and checkpoints go into the event/SIEM stream so a third party can hold them. Limit: someone with both the database and ENCRYPTION_KEY can rebuild the chain; only checkpoints held outside AppCrane detect that.
  • Restore drills (SOC 2) — weekly by default, the newest local backup (and the newest off-site set, if configured) is restored into an isolated scratch area and checked: database integrity, row counts against live, decryption, repository bundles, managed database dump headers. It records RPO and RTO, cleans up, never touches live data, and e-mails admins on failure. Settings → Backup → Restore drills.
  • Compliance evidence pack (SOC 2) — a signed, downloadable .tar.gz of evidence mapped to SOC 2 CC6/CC7/CC8/A1/C1 for a chosen period (users and roles, sign-in and key policy, access reviews, audit log and chain verification, deploys and release checks, scans, backups and drills, encryption), scanned for secrets before it is written and verifiable later. Settings → Compliance. It supports an audit; it is not a SOC 2 report or a certification.
  • FIPS 140-3 mode — APPCRANE_FIPS=require refuses to start unless Node runs a FIPS provider and a startup self-check (known-answer tests, MD5 refused) passes. Passwords are PBKDF2-HMAC-SHA256 (600k iterations) and old scrypt hashes convert at each user's next sign-in. S3 DeleteObjects uses a SHA-256 checksum instead of MD5 (with a fallback for buckets that insist on MD5). APPCRANE_TDE_KDF=pbkdf2-sha256 moves the MariaDB key file off SHA-1 (needs MariaDB 12). Settings → Security → Cryptography shows the status and anything still on a legacy algorithm. The deployer provides the FIPS Node build, a FIPS Caddy, FIPS base images and host FIPS mode; see docs/FIPS.md.
  • App intake, data classification and release check — every new app answers a short intake (purpose, data classification, personal data, integrations, who needs access). Confidential and restricted apps stay sandbox-only until a platform admin approves the intake at /intake. Every production deploy and promote runs a release check (intake, dependency/image scan, secrets in code, required access rules, SSO gate not bypassed, sandbox health) that enforces for confidential/restricted and warns for public/internal by default. A vulnerable dependency with a published fix blocks production for every app by default (one with no fix warns); a platform admin can turn that off in Settings → Security, after which it blocks nowhere. Owners or platform admins record per-check exceptions with a reason and an expiry (90 days at most). Rollbacks are not re-checked; existing apps are grandfathered as approved and internal.
  • Adopt an app (/adopt, MCP appcrane_adopt_app) — bring a Lovable, Bolt, v0, Replit or Figma Make app (or any GitHub repo or zip) onto your server. AppCrane reads the code without running it, reports the framework, build and port, the env vars to fill, Supabase/Firebase/Clerk/Auth0 use and exposed keys, then creates a Crane-hosted app, adds a Dockerfile and health check if missing, stores the secrets encrypted, deploys to the sandbox only, records the intake and can open a request per needed change. Critical findings must be acknowledged first.
  • SIEM and log streaming — platform admins stream the event store (sign-ins, secret reveals, audit, deploys, scans, host and job alerts) to syslog (TCP+TLS with RFC 5424 and octet counting, or UDP), HTTPS (generic webhook, Splunk HEC, Datadog, Elastic/OpenSearch _bulk, Sumo Logic, Microsoft Sentinel) or a daily JSONL export to S3/R2, as ECS-style JSON or CEF. At-least-once delivery from a durable per-destination cursor with a stable event.id, filters by kind, severity and app, verified TLS (custom CA allowed), private addresses only by allowlist, encrypted credentials, and a Job Health job per destination. Settings → Security.
  • LLM gateway (no provider keys inside apps) — a platform admin stores the Anthropic / OpenAI (or OpenAI-compatible) keys once. An app that turns on the gateway gets ANTHROPIC_BASE_URL / OPENAI_BASE_URL pointing at /api/service/llm and a per-app, per-environment gateway token as ANTHROPIC_API_KEY / OPENAI_API_KEY, so the official SDKs work unchanged and the real key never enters the container. Internal-only, with a fixed path and model allowlist, per-app/env budgets, a per-minute rate limit and a max-tokens cap; usage shows tokens and cost per app, model and day, and prompts are never stored.
  • MCP front door for hosted apps — an app's own functionality becomes MCP tools agents call at /api/mcp/apps/ (or -sandbox), with OAuth sign-in (a token scoped to that one app) or an API key. Each call acts as the person connected: AppCrane checks their role on the app, the tool's roles and the app's access rules, then calls the app with that person's signed identity headers. Read-only keys see only GET tools; every call is rate limited, size and time capped, and audited without bodies. Declare tools under mcp.tools in deployhub.json (name, description, method, path with {param}s, input_schema, roles), or "mcp": { "path": "/mcp" } for an app that already speaks MCP.
  • Delete an app and read its audit trail over MCP — appcrane_delete_app runs the same teardown as the dashboard (containers, images, volume records, managed databases, rows, Caddy routes) and requires confirm_slug equal to the slug, the app owner or a platform admin, and app.delete in the role matrix; it is refused for read-only keys, the coder's connection and keys scoped away from the app. The audit trail, the app's data directory and a Crane-hosted repository at DATA_DIR/repos/.git are kept (so that slug cannot be reused for a new managed app until the repository is removed); GitHub repositories are never touched. appcrane_get_audit returns an app's audit trail, gated by app.audit.view (default: owner, app admins, platform admins), newest first, paginated with before/next_before, limit up to 200, with an optional action filter; credential fields are masked on the way out, including in rows written before audit redaction existed.
  • Chunked staged uploads — POST /api/files/staged/chunked {slug, filename}, then PUT /api/files/staged/?offset=N (raw application/octet-stream, resumable; a wrong offset answers 409 with the bytes received so far), then POST /api/files/staged//finalize {sha256}. Finalize checks the SHA-256 before anything is staged, and its token works with appcrane_push_staged_file, appcrane_push_to_managed_app (staged_token) and appcrane_deploy_artifact. Handles are owner-only, expire after STAGED_TTL_MIN (10 minutes), are capped at STAGED_MAX_BYTES (200 MB) and are swept every 5 minutes.
  • The coder reads request text safely — when the in-platform coder lists its app's requests, everything app users wrote arrives only inside a fenced block marked as untrusted data, with a fresh random marker each time; hidden and direction-changing characters are stripped (also in requests dispatched to the coder), fake fence markers are neutralised, and fields are length-capped. The coder sees only its own app's requests, never access requests or requester e-mail addresses, and is told to ignore instructions inside request text and report them.
  • Security fixes (third review) — MCP OAuth connections have an absolute lifetime equal to the API key window (default 90 days) and end on password change, key rotation or regeneration, demotion from platform admin and deactivation; approving one needs a sign-in from the last 10 minutes or your password, never an API key, and platform admins can list and revoke anyone's connections. The consent screen lists what the connection can really do and marks self-registered clients as unverified; client registration follows an allowlist by default (claude.ai, claude.com and localhost), and read-only connections and keys can no longer reveal secrets or read container files. Off-site backup manifests are signed: unsigned or forged sets are never restorable or counted by retention. Path role rules also hold against method-override headers, ?_method=, .json/.html suffixes and Next.js / SvelteKit / Nuxt data routes, and both old and new rules apply while a deploy starts.

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Appcrane 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Appcrane 怎么在 Claude、Cursor、Codex 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Appcrane 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Appcrane 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Appcrane 支持哪些客户端?

资料标注支持 Claude、Cursor、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Appcrane 能提供哪些能力?

资料显示能力标签包括 self hosted、deployment、paas、mcp、docker、devops。具体工具清单以官方文档为准。

Appcrane 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。