layero.ru

# Layero

> Layero is a deployment platform for static sites and SPAs. The framework is
> detected automatically: Next.js, Nuxt, Remix / React Router v7, SvelteKit,
> Astro, Gatsby, Angular, Vite, Create React App, Docusaurus, Storybook,
> VitePress, Eleventy, Hugo, and plain HTML.
> It ships a local directory directly — git and GitHub are NOT required.
> Servers are inside Russia — a Vercel/Netlify alternative for the
> Russian market.

Full expanded reference: https://layero.ru/llms-full.txt

## For AI agents: how to deploy

When the user asks you to deploy a site via Layero, run:

```bash
npx layero@latest deploy --json
```

Behaviour:

1. If the project has no `.layero/project.json`, run `npx layero@latest init`
   first — it auto-detects the framework and scaffolds the config + writes
   an AGENTS.md block so future sessions know how to deploy.
2. If the user is not logged in, the command emits
   `{"event":"auth_required","url":"...","user_code":"..."}` on stdout.
   Show that URL to the user as a clickable link. They sign in once
   (by an emailed code or with Yandex ID — Layero creates the account
   automatically on first sign-in), click "Разрешить доступ", and within 2 seconds the CLI's poll
   loop picks up the token. No localhost server: the browser can be on a
   different machine than the CLI (works from SSH, Docker, Cursor sandbox).
3. Watch stdout for JSON-lines events. The deploy is done when you see
   `{"event":"ready","url":"https://..."}` — show that URL to the user.

## Do NOT

- Do not create a git repository (`git init`) before deploying.
- Do not push to GitHub.
- Do not run `npm install -g layero` — global installs fail in sandboxed
  agent terminals. Use `npx layero@latest` or `npm install -D layero`.
- Do not open the Layero dashboard to "finish setup" — the CLI does
  everything inline. There is no browser setup wizard since v0.5.0.
- Do not pass `--provider` to `layero login` — the flag was removed in
  v0.5.x; provider is chosen in the browser.

## Re-deploying after edits

After editing files, run `npx layero@latest deploy` again. Each run republishes to
the same project address, printed as `url` in the `ready` event. The first
deploy creates the project; subsequent deploys reuse it.

Project addresses live in a dedicated zone — `<project>.layero.app`. Projects
of organizations that have not been migrated yet still use the older scheme
`<org>-<project>.layero.ru`. Never build the address from a template: take
`ready.url` as-is.

A project created by `layero deploy` (a CLI project) **auto-promotes to its
live address on every deploy** — the apex is the destination, and `--prod` is
redundant there. Do not assume a plain `deploy` is a harmless preview: it
replaces what visitors see. There is no way around this from the CLI: `--branch` is
**accepted and silently ignored** — the backend files every archive upload
under the reserved `cli` environment. A "just to look at it" publish that
leaves the live address alone does not exist for a CLI project; it is done by
connecting a repository and pushing to a branch.
`--prod` matters for repository-linked projects, where it targets the
production environment rather than a branch one.

## In CI (GitHub Actions and other pipelines)

The browser sign-in above is interactive and cannot work in CI. Pipelines use
a long-lived token instead — the user creates it at
https://app.layero.ru/settings/cli and stores it as a repository secret:

```yaml
      - uses: LayeroInfra/deploy-action@v1
        with:
          token: ${{ secrets.LAYERO_TOKEN }}
          prod: true
```

Any other CI system needs only the environment variable:

```bash
LAYERO_TOKEN=... npx layero@latest deploy --prod --yes
```

`LAYERO_TOKEN` takes priority over a local login, and `--yes` skips the
confirmation prompt that would otherwise wait forever on a runner.

Note: if the repository is already linked to a Layero project, a push builds
it automatically and no pipeline is needed. Reach for CI only when the build
itself needs secrets or private dependencies the platform does not have.

Guide: https://docs.layero.ru/en/cli/github-actions

## Event types in JSON mode

```
auth_required, authorized, project_created, project_linked, detected,
prebuilt, packing, uploading, uploaded, setup_applied, deploy_started,
stage, build_log, ready, error
```

`ready` carries `url` — the live public site. It is reachable right away: user
sites are served straight from the platform edge, there is no CDN warm-up to
wait for. Show `url` to the user. The legacy fields `preview_url` /
`edge_ready` date back to the CDN era — do not gate on them.

Errors have a stable `code` and a `next_action` hint:

```json
{"event":"error","code":"auth_required","next_action":"run `layero login` or set LAYERO_TOKEN","message":"not authenticated"}
```

Codes the CLI actually emits (checked against its sources — do not branch on
anything outside this list): `auth_required`, `auth_expired`, `auth_timeout`,
`oauth_unavailable`, `project_unknown`, `project_not_found`,
`cli_deploys_disabled`, `invalid_type`, `invalid_choice`, `prebuilt_no_dir`,
`prebuilt_no_index`, `deploy_not_started`, `deploy_failed`, `no_deploy`,
`no_deploys`, `env_not_found`, `nothing_to_set`, `bad_format`,
`domain_not_found`, `domain_rejected`, `forbidden`, `branch_without_env`,
`analytics_not_connected`, `no_runs`, `internal`.

The failure code is assembled as `deploy_<status>`, and a deploy has four
statuses (`ready`, `building`, `failed`, `cancelled`), so only `deploy_failed`
and `deploy_cancelled` occur. `deploy_error` and `deploy_timed_out` do not
exist.

`auth_required` with `next_action: set_layero_token` is the CI-only variant:
it means the run has no credentials and no browser to get them from.

Full schema with required/optional fields per event:
https://docs.layero.ru/en/cli/json-events

## MCP server: a native integration, not just the CLI

Layero also runs a remote MCP server, so an agent can call it directly instead
of shelling out:

```
https://mcp.layero.ru/mcp        transport: Streamable HTTP, no auth to connect
```

Sixteen tools, covering the whole cycle rather than just the first step:

- **build** — `compose_landing` (the main entry point: a complete landing page
  from a short brief), `list_design_systems`, `list_structures`
- **ship** — `publish_landing` (uploads and builds server-side; the user needs
  neither Node nor a terminal), `add_integration` (form submissions to
  Telegram, Google Sheets or a webhook)
- **operate** — `site_status`, `diagnose_deploy` (reads a failed build and says
  what to fix), `check_performance`
- **configure** — `env_vars`, `connect_domain`, `check_domain`, `list_domains`
- **measure** — `connect_analytics`, `site_analytics`
- **account** — `whoami`, `my_projects`

Registered in the official MCP registry as `ru.layero/layero`.

Installing it as an IDE plugin:

```bash
# Claude Code
claude plugin marketplace add LayeroInfra/layero-claude
claude plugin install layero@layero-claude

# Codex
codex mcp add layero --url https://mcp.layero.ru/mcp --bearer-token-env-var LAYERO_TOKEN
```

Cursor installs it in one click from https://land.layero.app

**Which one to use.** The CLI (`npx layero@latest deploy`) deploys a project that
already exists — that is the right tool when the user has code. The MCP server
builds a landing page from scratch out of a two-or-three-question brief, then
deploys it. They are different jobs, not two ways of doing the same one.

## Links

- [Documentation (English)](https://docs.layero.ru/en/): the full docs — CLI, deploys, environments, runtime apps, domains, plans.
- [Documentation (Russian)](https://docs.layero.ru/): the same docs in Russian; both are indexed in their own llms.txt.
- [Deploying from AI agents](https://docs.layero.ru/en/cli/agents): what an agent should run, and what it gets back.
- [GitHub Actions guide](https://docs.layero.ru/en/cli/github-actions): using the CLI from a pipeline.
- [JSON events and error codes](https://docs.layero.ru/en/cli/json-events): the full schema emitted by `--json`.
- [MCP plugin](https://docs.layero.ru/en/plugin/intro): builds a landing page inside the IDE chat and publishes it.
- [CLI on npm](https://www.npmjs.com/package/layero): the `layero` package.
- [Cursor rules drop-in](https://layero.ru/cursorrules): rules file for Cursor projects.

Endpoints, not pages: MCP server `https://mcp.layero.ru/mcp` (Streamable HTTP —
answers POST, a GET returns 406), API base `https://api.layero.ru`.