beam.page

Static-site hosting via MCP — ask your AI client to build a site (lands at .beam.page or your custom domain), then update it anytime, from anywhere, just by…

От сообществаРаботаетБез входаГлобальныйБесплатноМожет изменять данные

Что умеет

Guide: Fetch the platform's capabilities brief — the orient guide. When to use: `topic="orient"` once at the start of a session to load the capabilities map. Day-to-day shape and runbook detail — bill
Whoami: Look up the current caller's profile — tenant, email, name, account type (guest or Google), limits, usage, and terms-acceptance status. When to use: call before any capability-gated decision s
Project: Create / update / delete / list / get projects (each project is a microsite on `<slug>.beam.page`). When to use: for every project-scoped lifecycle action. `op=list` to answer "what sites do

Какие данные видит

Нужен ли аккаунт

Не нужен: сервер работает без входа

Static-site hosting via MCP — ask your AI client to build a site (lands at .beam.page or your custom domain), then update it anytime, from anywhere, just by asking again.

Список инструментов сервера (20)

Технические названия из tools/list. Нужны только разработчикам.

guide	Fetch the platform's capabilities brief — the orient guide. When to use: `topic="orient"` once at the start of a session to load the capabilities map. Day-to-day shape and runbook detail — billing state, contact-form worked example, custom-domain attach flow, error recovery — lives in the live API responses' `brief.next`, `_comment`, and `capabilities.actions` blocks. Call the relevant endpoint and read the response. How: pass `topic="orient"`. The orient guide is served by the apex site at `llm.txt`. Limitations: read-only, idempotent; returns isError=true on network failure. The only allowed topic is `orient`; anything else returns a validation error. See §The API teaches you as you go in guide(topic="orient").
whoami	Look up the current caller's profile — tenant, email, name, account type (guest or Google), limits, usage, and terms-acceptance status. When to use: call before any capability-gated decision so you read `limits` and `accountType` from the live response rather than assuming. How: dispatches to `GET /me` with no parameters. Limitations: read-only, idempotent; surfaces upstream auth errors unchanged. See §Check what exists in guide(topic="orient").
project	Create / update / delete / list / get projects (each project is a microsite on `<slug>.beam.page`). When to use: for every project-scoped lifecycle action. `op=list` to answer "what sites do I own?"; `op=get` for depth on one; `op=create` to mint a new subdomain; `op=update` to edit the context; `op=delete` to tear it all down. How: pick `op` from the enum; each op lists its required/optional params in the oneOf description. Slug is globally unique, lowercase, 2–63 chars, [a-z0-9-]. `context` is free text shown in the management UI and returned by `op=get`. Limitations: `op=delete` is destructive and irreversible. The per-account project cap is enforced server-side — read it from `whoami().limits.maxProjects` before offering to create. Responses carry `views` (lifetime / 7d / 30d) per project and per page; on `op=get` the response always surfaces a `views.setup` hint with the `<script src="/assets/beacon.js" data-project="<slug>" data-api-host="https://api.beam.page" defer></script>` snippet — paste that line into the <head> of every page you want counted (the default templates already include it). See §Building projects in guide(topic="orient") for the project shape and slug rules.
page	Create / update / delete / read sub-pages within a project. When to use: for every page-level lifecycle action. `op=create` for a new sub-page (`/about`, `/menu`, `/app`); `op=update` to edit notes or replace the structured metadata object; `op=delete` to remove a sub-page and its files; `op=get` to inspect one page. How: pick `op` from the enum. `op=update` with only `notes` edits notes via `PUT /pages/<slug>`; with only `metadata` replaces the metadata via `PUT /pages/<slug>/metadata`; with both it does both and returns a combined result. Limitations: `metadata` replaces (does not merge) the existing object, capped at 200 KB. `op=delete` on `_root` is rejected by the platform. `op=update` with neither `notes` nor `metadata` fails validation. Responses on `op=get` carry `views` (lifetime / 7d / 30d) for the page; the page response also carries a top-level `_comment` enumerating every operation available on the page. See §Building projects in guide(topic="orient") for notes vs. metadata, the `_root` alias, and the <base href="/<slug>/"> rule for sub-pages.
upload_text	Upload a text file (HTML, CSS, JS, JSON, XML, SVG, TXT) to a page or to the project's shared `/assets/` bucket, inline or via URL-fetch. When to use: when you already have the bytes as UTF-8 text (HTML you generated, JSON you built, an SVG you composed) — pass `content`. When the bytes already live at a public HTTPS URL the platform should fetch — pass `url`. Overwrites an existing file of the same name without prompting — the response confirms the upload. How: `scope=page` with `slug` + `filename` + one of `content` / `url` → `PUT /projects/<id>/pages/<slug>/files/<filename>`. `scope=asset` with `filename` + one of `content` / `url` → `PUT /projects/<id>/assets/<filename>`. Limitations: `content` caps at 4 MB and is raw UTF-8 — do NOT pass base64 binary; it won't be decoded. URL-fetch is HTTPS only, 4 MB, 10 s timeout, no redirects, private IPs rejected. `content` and `url` are mutually exclusive; one of them is required. For binary bytes in hand (images, PDFs, fonts) use `upload_binary`; for a multi-file folder tree use `upload_zip`. See §Building projects → Files in guide(topic="orient") for the full upload-method table.
upload_binary	Request a presigned S3 PUT URL for a binary file (image, PDF, font, video) on a page or as a shared asset. The client then PUTs the bytes directly to the returned URL. When to use: when you have the binary bytes in hand and the runtime can execute outbound HTTPS PUTs. If the runtime cannot drive an outbound PUT, this tool returns a URL the caller cannot use — for already-public HTTPS bytes use `upload_text` with `url=...`; for the case where the user has the bytes on a device you cannot reach (laptop, phone, tablet, borrowed machine) use `drop_zone` to issue a browser link. How: `scope=page` with `slug` + `filename` → `POST /projects/<id>/pages/<slug>/files/<filename>/upload-url`. `scope=asset` with `filename` → `POST /projects/<id>/assets/<filename>/upload-url`. Response is `{uploadUrl, expiresIn, headers, publicUrl, curlCommand, brief}`; echo every header in `headers` exactly on the PUT — mismatch fails with `SignatureDoesNotMatch`. `publicUrl` is where the file will be served once the projection catches up; `curlCommand` is a paste-ready PUT line. Limitations: URL expires in 15 minutes. Returns an envelope, not the uploaded bytes — the actual PUT happens client-side. See §Building projects → Files in guide(topic="orient") for the full upload-method table.
upload_zip	Request a presigned S3 PUT URL for a ZIP archive that the platform extracts entry-by-entry onto a page. When to use: when you have a multi-file folder tree to ship — SPA builds, photo galleries, multi-page HTML trees. Anything more than a handful of files. For a single binary file use `upload_binary`; for text bytes you already have use `upload_text`. How: `POST /projects/<id>/pages/<slug>/upload-zip-url` returns `{uploadUrl, expiresIn, headers, publicUrl, curlCommand, brief}`; then PUT the ZIP bytes to `uploadUrl` echoing every response header exactly. `publicUrl` is the page URL where the extracted site will be served; `curlCommand` is a paste-ready PUT line. Extraction is asynchronous: the S3 200 from PUTting the bytes lands before the archive is extracted. After PUTting, poll the page — page(op="get") or GET /projects/<id>/pages/<slug> — to confirm: a successful extract shows the new file set; a failed extract surfaces a lastZipFailure object (machine-readable reason + human-readable summary) on the page response. Limitations: ZIP upload REPLACES the page's full file set — anything on the page not in the archive is deleted, same shape as Netlify / Vercel / GitHub Pages. 500 MB decompressed cap; 100× compression-ratio guard; `index.html` required at the ZIP root; URL expires in 15 minutes. Requires a runtime that can execute outbound HTTPS PUTs. See §Building projects → ZIP in guide(topic="orient") for the allowlist and failure modes.
read_content	Read a page-scoped file or a project-scoped asset's full contents. When to use: before an `edit` batch (copy exact bytes into the `old` field), or to verify what was deployed. How: `scope=page` with `slug` + `filename` → `GET /projects/<id>/pages/<slug>/files/<filename>`. `scope=asset` with `filename` → `GET /projects/<id>/assets/<filename>`. Limitations: text files return as `{content, contentType}`; binary files return as `{base64, contentType}`. Read-only, idempotent. See §Search and edit in guide(topic="orient").
search	Find every text file in a project that matches a literal substring or regex pattern, with line numbers and surrounding context. When to use: before a multi-page edit, to enumerate every page that mentions a phone number / email / URL / brand name; before deleting an asset, to confirm no page references it; for backlink, broken-link, and 'pages without an og:image' audits. How: pass `projectId` and `query`. Defaults: `mode="literal"`, `caseSensitive=false`, `scope="all"`. Switch `mode` to `"regex"` for structural patterns (Python `re` syntax). Restrict with `scope` to `"pages"` or `"assets"`. Dispatches to `POST /projects/<id>/search`. Limitations: content-only — to find files by name, use the project or page index. Binary files (PNG, JPG, PDF, WebP, ICO, HEIC) are skipped silently; only the text content types HTML/CSS/JS/JSON/XML/SVG/TXT are scanned. Per-call cap: 200 occurrences total, 50 per file; matching lines are trimmed to 200 chars centred on the first match. Per-user rate limit: 60 calls/minute (visible on GET /me as `searchCallsPerMinute`). Read-only — never mutates state. Cross-project search, fuzzy / typo-tolerant search, and fielded search are out of scope. See §Search and edit in guide(topic="orient").
delete_content	Delete a page-scoped file or a project-scoped asset. When to use: when the file is actually unwanted — prefer `upload_text` overwrite or `edit` for corrections. How: `scope=page` with `slug` + `filename` → `DELETE /projects/<id>/pages/<slug>/files/<filename>`. `scope=asset` with `filename` → `DELETE /projects/<id>/assets/<filename>`. Limitations: destructive. The main page's `index.html` cannot be deleted — overwrite it with `upload_text` instead. Deleting a shared asset removes it from every page that references `/assets/<filename>`. See §Building projects → Files in guide(topic="orient").
compress	Resize / transcode / quality-tune an image already in the project. Reads bytes from one slot, writes a sized variant to another (or back to the same slot for in-place compression). When to use: after any image upload, before referencing it in HTML — drop-zone bytes especially since modern cameras (phone, mirrorless, tablet) all produce full-resolution sources; HEIC photos always (HEIC won't render in most desktop browsers, so the default auto-format pick transcodes HEIC → WebP). Call repeatedly with different `target.filename` values to produce responsive thumbnail / medium / desktop triples from one source. How: pass `projectId`, `source`, and `target`. Both refs use the {scope, slug?, filename} triple already established by `read_content` and `delete_content` (slug required when scope=page; '_root' for the main page). The optional `maxDimension`, `format`, and `quality` dials override the defaults. Dispatches to `POST /projects/<id>/compress`. Defaults: `maxDimension: 2048` (longest side; aspect preserved; smaller sources are not up-scaled), `format: 'auto'` (HEIC/HEIF → WebP; JPEG → WebP; PNG → PNG; GIF → GIF; WebP → WebP), `quality: 85`. EXIF orientation is baked into the output pixels and EXIF metadata is stripped (privacy + bytes). Limitations: compress operates only on bytes already in the project — passing `url` / `content` / `base64` in `source` is rejected with a pointer at the two-step `upload_text({url:...}) → compress(...)` pattern. Inputs must be JPEG, PNG, GIF, WebP, HEIC, or HEIF; SVG is rejected with vector guidance; video MIMEs are rejected with the same shape. Source must decode to ≤64MP. Output respects `maxFileSizeBytes` (4MB); too-large outputs return 413 with a hint to lower `quality` or `maxDimension`. Each variant counts against the existing per-page or per-project file cap (no new physical limit). Per-user rate limit: 60 calls/minute (visible on GET /me as `compressCallsPerMinute`). Animated WebP / AVIF / video are out of scope. See §Building projects → Images / compressing in guide(topic="orient").
edit	Find-and-replace inside existing files — preferred over re-uploading the whole file for small changes (saves ~25,000 output tokens per edit vs. re-upload). When to use: surgical edits to a page file or an asset. Run `search` first when the change spans multiple files so every match is enumerated before you compose `targets`. How: pass `projectId`, `edits` (non-empty array of `{old, new}` applied in order), and a target. - Single-target, page file: `{page: "<slug>", file: "<filename>"}`. Use `page: "_root"` to address the main page (the API form of the `/` slug used in URLs). - Single-target, asset: `{asset: "<filename>"}`. - Multi-target: `targets: [{page, file} \| {asset}, ...]` — same edit set applied across many files in one call. Dispatches to `POST /projects/<id>/edit`. Atomicity: validation is fully transactional; the commit pass is best-effort per-target. Phase 1 reads every target and applies each edit in memory, checking that each `old` matches exactly once. Phase 2 only runs if Phase 1 succeeded for every target — then the per-target S3 PUT + `FILE_UPLOADED` / `ASSET_UPLOADED` event pair fires in order. If Phase 2 hits a transient error on target K (1 ≤ K ≤ N), targets 1..K-1 are committed and K..N are not; the response is 503 with `committed[]` / `uncommitted[]` arrays and a `brief.next` pointing the agent at a retry scoped to the uncommitted targets only. Validation failures (no `old` match, etc.) remain all-or-nothing — no writes land. Matching is byte-exact UTF-8. Typographic mismatches silently fail — curly quotes (`“”‘’`) vs straight (`"'`); `—` vs `—`; non-breaking space (`\u00A0`) vs regular space. On a no-match error, GET the file and copy the bytes verbatim into `old` — don't retype. See §Search and edit in guide(topic="orient").
redirect	List / create / delete 301 redirects on a project. When to use: rename a page and keep inbound links working, point the bare subdomain at `/app/`, or clean up obsolete mappings. How: pick `op` from the enum. Both `from` and `to` are relative paths starting with `/` — cross-domain redirects (absolute `https://` URLs) are rejected 400 by the API. Limitations: self-loops (`from == to`) rejected 400. Conflicts are symmetric — creating a redirect that shadows an existing file or page fails 409, and creating a file or page where a redirect lives fails the same way. Chains (`/a → /b → /c`) are allowed; redirects count against the owning page's `maxFilesPerPage` quota. See §General app stuff → Redirects in guide(topic="orient").
custom_domain	Attach / detach / read a custom domain on a project — Lone Creator feature, up to 3 custom domains per subscription, one per project. When to use: `op=attach` once the user has added a CNAME at their DNS host pointing at the `dnsTarget` (read it from a previous `op=get` or from `whoami().customDomains[].dnsTarget`); `op=get` to poll an in-flight attach (status advances `attach_requested → provisioning → live` over ~5 min) or to surface health on a live row; `op=detach` to free the hostname so the user can move it elsewhere. How: pick `op` from the enum. `attach` requires `projectId` + `hostname` (lowercased FQDN like `www.mybiz.com`); `get` and `detach` require only `projectId`. Limitations: Lone Creator subscription only; free / guest cannot attach. Up to 3 custom domains per subscription, one per project (a subscriber with three projects can put a unique hostname on each). Apex domains rejected 400 (use `www.` and a registrar redirect); reserved beam.page suffixes rejected 400; per-project 409 if this project already has one; per-subscription 409 if at the 3-domain cap; attach blocked on archived projects (409). Detach is final — re-attach issues a fresh ACM cert. Read the live `GET /projects/<id>/custom-domain` response for the full attach state, the `subPhase` polling enum, canonical-URL advice on the live response, and the `failureReason` / `failureMessage` fields when an attach lands in `status: failed`.
snapshot	List / take / restore point-in-time snapshots of a project. When to use: `op=take` before a risky refactor or large edit; `op=list` to see what's available (nightly, initial, manual); `op=restore` to roll back after a bad change. Call `op=list` first to pick a valid `snapshot_id` before `op=restore`. How: pick `op` from the enum; every op requires `projectId`. Limitations: snapshots are Google-only — guest-owned projects have none. `op=take` is rate-limited to 1/project/min; `op=restore` to 1/project/5min. Restore is a full state replacement with three rules: (1) files in S3 but not in the snapshot are deleted; (2) pages that existed at snapshot time are re-created if absent and updated if present, with their snapshot-time notes and metadata; (3) pages created after the snapshot are removed, and pages deleted before the snapshot stay deleted. 30-day retention. See §Snapshots in guide(topic="orient"); the snapshot list response carries a top-level `_comment` enumerating every operation.
regenerate_sitemap	Force a rebuild of the project's `sitemap.xml` and `cross_page_metadata.json` from the current page projection, then invalidate CloudFront for both files. When to use: only when out-of-band writes (direct `aws s3 sync`, an archive restore that drifted, an in-flight projection bug) have left the served sitemap ahead of or behind the current page set. Day-to-day page create / delete / restore already triggers regeneration automatically — you do not need this tool on the happy path. How: `regenerate_sitemap({projectId})` → `POST /projects/<id>/sitemap/regenerate`. The handler emits `SITE_REGEN_REQUESTED` and the site projection picks it up asynchronously. Limitations: rate-limited to 1 call per project per 5 minutes (429 on the second). Slugs whose page row has no `index.html` are filtered out of the sitemap (they 404 on the live site). Archived projects are blocked with 409. Cross-tenant calls 404 the same as any other tenant-isolated endpoint. See §General app stuff → Sitemap in guide(topic="orient").
drop_zone	Open a short-lived browser drop-zone so a non-technical user can ship photos into this conversation. The drop-zone is just a browser link — it loads on any device the user has to hand. When to use: when the user has the photos on a device you cannot reach and you need the bytes themselves rather than a public URL. Examples: a laptop's download folder, a phone's camera roll, a tablet, files on a borrowed desktop, a Dropbox they have not shared. `op=issue` mints the browser link; share the `message` field verbatim with the user. Then `op=pickup` to read the photos (idempotent — call again to see new arrivals). `op=cancel` shuts the door early. How: `op=issue` with `projectId` (and optional `ttlSeconds`) → `POST /projects/<id>/dropzones`; `op=pickup` with `projectId` and `dropZoneId` (URL + metadata only by default; pass `preview: true` for inline thumbnails + `image` content blocks) → `GET /projects/<id>/dropzones/<dropZoneId>`; `op=cancel` → `DELETE /projects/<id>/dropzones/<dropZoneId>`. Limitations: bearer-by-URL — anyone with the link can upload; warn the user not to forward it. Default TTL 10 min (max 600 s, min 60). Up to 10 photos per link, 4 MB each, JPG/PNG/GIF/WebP/HEIC. Pickup returns each photo as URL + metadata only by default (`filename`, `mimeType`, `size`, `uploadedAt`, `signedFetchUrl`, `urlExpiresAt`) — no inline preview bytes, no `image` content blocks. Pass `preview: true` for each photo's inline `base64_preview` + `previewMimeType` plus one MCP `image` content block per photo. Bytes are wiped ~30 min after expiry — pick up promptly. The drop-zone uploads do NOT land in the project's `/assets/` or page files; pick them up here, then place each photo on the live site. Each photo in the pickup response carries a short-lived opaque `signedFetchUrl` — pass that URL to `upload_text({url: signedFetchUrl})` and the platform fetches the bytes server-side onto your chosen page or asset slot in one call. For binary bytes already in hand use `upload_binary`. See §Building projects → Drop-zone in guide(topic="orient").
fetch_live	Fetch live content from a project's public CDN URL — the visitor's view, not the API. When to use: verify a deploy, debug what's rendering, or quote live content back to the user. Distinct from the `page` tool: `page` reads the API-side metadata, `fetch_live` reads the deployed HTML/CSS/JS/images. How: pass `projectId` (the slug). Optional `path` (default `/`), `limit` (default 8192 bytes), `offset` (default 0). Large pages are paginated — chunk with `limit`+`offset`. Limitations: for image content types the default response is URL + metadata only (`url`, `contentType`, `size`, debug headers) — no inline bytes flood the transcript. Pass `preview: true` to additionally receive one MCP `image` block with a server-resized JPEG thumbnail (max 800 px on the long edge). Text content returns the sliced body plus a JSON meta block carrying `status`, `contentType`, `finalUrl`, `headers` (Cache-Control / Age / ETag / X-Cache / Content-Length), and `{totalSize, truncated}`. A 3xx response surfaces as a typed envelope naming `status` and `location`; redirects are not followed — call fetch_live again with the new path if you want the target's body. Retries once on network error. Read-only, idempotent. See §The API teaches you as you go in guide(topic="orient").
feedback	Submit feedback to the platform team — a bug report, a feature suggestion, or a flag on something that's broken. When to use: when the user surfaces a platform-level problem (not a problem with their content) or has a suggestion worth passing back. How: pass `message`. Dispatches to `POST /feedback`. Limitations: `message` required and non-empty, max 5000 chars. Stored and read by the team. See §Feedback in guide(topic="orient").
api	WARNING: last-resort escape hatch. Prefer a dedicated tool whenever one exists — `guide, whoami, project, page, upload_text, upload_binary, upload_zip, read_content, delete_content, compress, edit, redirect, custom_domain, snapshot, regenerate_sitemap, fetch_live, feedback` — they have stronger intent matching, cleaner argument schemas, and client-side validation so a missing field is caught before a REST call is charged. When to use: only when the endpoint you need has no dedicated tool. The auth-flow endpoints (`/auth/guest`, `/auth/google`, `/auth/convert`, `/auth/refresh`, `/auth/accept-terms`) are the main legitimate callers — and Claude's MCP connector already covers those via its `authenticate` / `complete_authentication` tools, so even that case is rare. How: `api({method, path, body?})` with `method` in `{GET, POST, PUT, DELETE}` and `path` starting with `/`. Limitations: path rejected if it contains `@`, `//`, `\`, or `:`. Auth is forwarded from the MCP request. 25 s timeout. Marked destructive + openWorld because an arbitrary REST call can do anything. See §Access (REST vs MCP) in guide(topic="orient").