# MonstarX MCP server

> Connect Claude Code, Codex, Cursor, Grok, Lovable, Figma or any MCP client to MonstarX: push the app you built, run it live, publish it and keep building it by chat. Setup, prompts, tools and limits.

Server: https://uat.monstarx.app/mcp · Docs: https://uat.monstarx.app/docs/mcp · Updated 2026-09-21

## Why push your app to MonstarX

Coding agents are brilliant at writing an app and leave the rest to you: somewhere to run it, a link to show people, a domain, a database that survives, someone to test it, and a way for the people who are not developers to keep changing it. MonstarX is that rest. Connect your agent once and every app it builds is one sentence away from being live — and from being something your whole team can keep building.

- **Live in one sentence.** “Push this to MonstarX” gives you a running preview and a link to share in about a minute. No hosting account, no CI, no DNS.
- **Publish on your domain.** One call puts it on its own address with HTTPS, and on your custom domain. Every push is a version you can publish or roll back.
- **Anyone can keep building.** Founders, designers and PMs change the app by chatting with MonstarX or clicking on the page in Edit mode — no terminal, no pull request.
- **A real backend when you want one.** MonstarX apps come with a database, sign-ups, email, file storage, payments and AI. Ask for them; nothing to set up.
- **Tested like a customer would.** MonstarX clicks through the app in a real browser after big changes, fixes what fails and shows you the recording.
- **Both ways, never overwritten.** Pull what MonstarX changed back into your agent, push your work up again. A revision check stops either side overwriting the other.
- **Zero tokens for the files.** Whole projects move as one archive through your shell, never through the model, so a 300-file app costs the same few tokens as a small one.
- **Works with every tool.** Claude Code, Codex, Cursor, Grok, Gemini, VS Code, Windsurf, ChatGPT, the Claude app — and Lovable, Bolt, v0, Replit and Figma can send their work too.

## How it works

1. **Connect once.** Add https://uat.monstarx.app/mcp to your agent and sign in with your MonstarX account in the browser (or use an API key).
2. **Say it.** “Push this app to MonstarX.” The agent asks MonstarX for a one-time upload link and sends the folder with tar and curl — node_modules, build output and .env files stay on your machine.
3. **MonstarX takes it from there.** It checks what the app is (the same check as Projects → Import), runs it with its own packages, and answers with the project link, what it found and which keys the app still needs.
4. **Keep going, anywhere.** Chat with MonstarX in the workspace, or keep working in your agent and push again. Publish when you are ready.

No shell where you work (a chat app, Lovable, Bolt, v0, Figma)? The same connection imports the app from its GitHub repository, writes small changes directly, or has MonstarX build something new from a description and pictures.

## Quick start

The server lives at **https://uat.monstarx.app/mcp**. Add it to your agent (each one is below), sign in once in the browser, then ask:

```
Push this app to MonstarX and give me the link.
```

Or let the agent set itself up — paste this into it:

```
Connect yourself to MonstarX's MCP server: read https://uat.monstarx.app/docs/mcp.md and follow the setup for the agent you are. Then push this app to MonstarX and give me the project link.
```

## Instructions for AI agents

If you are an AI agent asked to connect to MonstarX or to send it an app, do this:

1. Work out which client you run in and use its setup from **Set up your agent**: Claude Code `claude mcp add --transport http --scope user monstarx https://uat.monstarx.app/mcp`; Codex `codex mcp add monstarx --url https://uat.monstarx.app/mcp` then `codex mcp login monstarx`; Grok Build `grok mcp add --transport http monstarx https://uat.monstarx.app/mcp`; Gemini CLI `gemini mcp add --transport http monstarx https://uat.monstarx.app/mcp`; Cursor, Windsurf and VS Code through their MCP config file. If the user gave you an API key (it starts with `bck_`), use the API-key variant instead of the browser sign-in.
2. The browser sign-in needs the user once: tell them a browser window will ask them to sign in to MonstarX and press **Allow** (in Claude Code they run `/mcp` → monstarx → Authenticate). New servers usually load in a new session: say so if the tools do not appear.
3. Check the connection with get_account.
4. To push the current app: call prepare_upload (with project_id to update an existing project), then run the returned `command` with your shell tool from the app's root folder, the one with package.json. The command's output is JSON: report `summary` and `projectUrl` to the user and keep `revision`.
5. Without a shell: import_from_github when the app is on GitHub, push_files for a few small files, create_project to have MonstarX build something new.
6. On later pushes pass expected_revision. If the push is refused because the project changed in MonstarX, run download_project into a scratch folder, merge the changes, and push with the new revision. Never pass force unless the user asks.
7. Never upload .env files or print secret values. Use set_secrets only with values the user gave you or asked you to copy from their local .env.
8. Publish (publish_project) and paid work (send_message, create_project, rebuilds) only when the user asks for them.

## Set up your agent

### Claude Code

The CLI, the desktop app’s Code tab and the IDE extensions share one setup.

**Sign in with the browser (OAuth):**

```bash
claude mcp add --transport http --scope user monstarx https://uat.monstarx.app/mcp
```

Then run `/mcp` in Claude Code, pick **monstarx** and choose **Authenticate** (or run `claude mcp login monstarx`). Your browser opens MonstarX: sign in and press **Allow**.

**With an API key:**

Make a key in [Settings → API & MCP](https://uat.monstarx.app/settings/api), then:

```bash
claude mcp add --transport http --scope user monstarx https://uat.monstarx.app/mcp \
  --header "Authorization: Bearer bck_your_key"
```

In a project’s `.mcp.json`, keep the key out of the file: `"headers": { "Authorization": "Bearer ${MONSTARX_API_KEY}" }` with `"type": "http"`.

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Push my changes to MonstarX."
- "Pull the latest version from MonstarX and merge it with my changes."
- "Ask MonstarX to add Stripe checkout, then pull its changes."
- "Publish it on MonstarX."

> `--scope user` makes MonstarX available in every folder; leave it out to add it to the current project only.

### Codex

OpenAI’s Codex CLI and IDE extension (both read ~/.codex/config.toml).

**Sign in with the browser (OAuth):**

```bash
codex mcp add monstarx --url https://uat.monstarx.app/mcp
codex mcp login monstarx
```

The login opens your browser: sign in to MonstarX and press **Allow**.

**With an API key:**

Make a key in [Settings → API & MCP](https://uat.monstarx.app/settings/api), keep it in your shell profile, and point Codex at it:

```bash
export MONSTARX_API_KEY=bck_your_key
codex mcp add monstarx --url https://uat.monstarx.app/mcp --bearer-token-env-var MONSTARX_API_KEY
```

Or in the config file:

`~/.codex/config.toml`:

```toml
[mcp_servers.monstarx]
url = "https://uat.monstarx.app/mcp"
bearer_token_env_var = "MONSTARX_API_KEY"
```

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Push my changes to MonstarX."
- "Pull the latest version from MonstarX and merge it with my changes."
- "Ask MonstarX to add Stripe checkout, then pull its changes."
- "Publish it on MonstarX."

> Codex runs commands in a sandbox without network access by default, and the upload and download commands need the network: approve them when Codex asks, or allow it for the session with `-c sandbox_workspace_write.network_access=true`.

### Cursor

The editor and its `agent` CLI read the same mcp.json.

**Sign in with the browser (OAuth):**

Click [Add to Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=monstarx&config=eyJ1cmwiOiJodHRwczovL3VhdC5tb25zdGFyeC5hcHAvbWNwIn0%3D), or add MonstarX to your MCP config:

`~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "monstarx": {
      "url": "https://uat.monstarx.app/mcp"
    }
  }
}
```

Cursor lists MonstarX under Settings → MCP with a sign-in button: sign in and press **Allow**. In the CLI: `agent mcp login monstarx`.

**With an API key:**

`~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "monstarx": {
      "url": "https://uat.monstarx.app/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MONSTARX_API_KEY}"
      }
    }
  }
}
```

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Push my changes to MonstarX."
- "Pull the latest version from MonstarX and merge it with my changes."
- "Ask MonstarX to add Stripe checkout, then pull its changes."
- "Publish it on MonstarX."

### Grok

xAI’s Grok Build CLI, Grok on grok.com, and the xAI API.

**Sign in with the browser (OAuth):**

**Grok Build (CLI):**

```bash
grok mcp add --transport http monstarx https://uat.monstarx.app/mcp
```

The first call opens a browser sign-in: press **Allow**. `grok mcp list` shows it connected.

**grok.com:** open grok.com/connectors → **New Connector** → **Custom**, paste the address below and sign in when asked. On Business and Enterprise, an admin adds connectors.

```
https://uat.monstarx.app/mcp
```

**With an API key:**

```bash
grok mcp add --transport http monstarx https://uat.monstarx.app/mcp \
  --header "Authorization: Bearer bck_your_key"
```

**xAI API:** give Grok MonstarX’s tools in a Responses API request:

`POST https://api.x.ai/v1/responses`:

```json
{
  "model": "grok-4.6",
  "input": [
    {
      "role": "user",
      "content": "List my MonstarX projects."
    }
  ],
  "tools": [
    {
      "type": "mcp",
      "server_url": "https://uat.monstarx.app/mcp",
      "server_label": "monstarx",
      "headers": {
        "Authorization": "Bearer bck_your_key"
      }
    }
  ]
}
```

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Push my changes to MonstarX."
- "Build me a booking app for my salon on MonstarX."

> grok.com and the xAI API have no shell: they use import_from_github, push_files and create_project instead of the upload command.

### VS Code

GitHub Copilot’s agent mode.

**Sign in with the browser (OAuth):**

Click [Install in VS Code](vscode:mcp/install?%7B%22name%22%3A%22monstarx%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fuat.monstarx.app%2Fmcp%22%7D), or run:

```bash
code --add-mcp '{"name":"monstarx","type":"http","url":"https://uat.monstarx.app/mcp"}'
```

VS Code asks you to sign in the first time a tool runs: sign in to MonstarX and press **Allow**.

**With an API key:**

VS Code asks for the key once and keeps it in its secret storage:

`.vscode/mcp.json`:

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "monstarx-key",
      "description": "MonstarX API key",
      "password": true
    }
  ],
  "servers": {
    "monstarx": {
      "type": "http",
      "url": "https://uat.monstarx.app/mcp",
      "headers": {
        "Authorization": "Bearer ${input:monstarx-key}"
      }
    }
  }
}
```

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Push my changes to MonstarX."
- "Pull the latest version from MonstarX and merge it with my changes."
- "Ask MonstarX to add Stripe checkout, then pull its changes."
- "Publish it on MonstarX."

### Gemini CLI

Google’s Gemini CLI.

**Sign in with the browser (OAuth):**

```bash
gemini mcp add --transport http monstarx https://uat.monstarx.app/mcp
```

Then run `/mcp auth monstarx` in Gemini CLI and press **Allow** in the browser.

**With an API key:**

```bash
gemini mcp add --transport http -H "Authorization: Bearer bck_your_key" monstarx https://uat.monstarx.app/mcp
```

In settings.json the key is `httpUrl` (plain `url` means the older SSE transport):

`~/.gemini/settings.json`:

```json
{
  "mcpServers": {
    "monstarx": {
      "httpUrl": "https://uat.monstarx.app/mcp",
      "headers": {
        "Authorization": "Bearer bck_your_key"
      }
    }
  }
}
```

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Push my changes to MonstarX."
- "Pull the latest version from MonstarX and merge it with my changes."
- "Ask MonstarX to add Stripe checkout, then pull its changes."
- "Publish it on MonstarX."

### Windsurf

Cascade’s MCP servers.

**Sign in with the browser (OAuth):**

Add the server; Cascade asks you to sign in the first time:

`~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "monstarx": {
      "serverUrl": "https://uat.monstarx.app/mcp"
    }
  }
}
```

**With an API key:**

`~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "monstarx": {
      "serverUrl": "https://uat.monstarx.app/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MONSTARX_API_KEY}"
      }
    }
  }
}
```

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Push my changes to MonstarX."
- "Pull the latest version from MonstarX and merge it with my changes."
- "Ask MonstarX to add Stripe checkout, then pull its changes."
- "Publish it on MonstarX."

### Claude app

Claude on the web, desktop and mobile, as a custom connector.

**Sign in with the browser (OAuth):**

On Free, Pro and Max: **Customize → Connectors → Add custom connector**, paste the address below, then **Connect**: sign in to MonstarX and press **Allow**. On Team and Enterprise, an Owner adds it under **Organization settings → Connectors**, and members press Connect.

```
https://uat.monstarx.app/mcp
```

**With an API key:**

Custom connectors sign in with the browser. Some organisations have a beta of request headers; there the value is the whole `Bearer bck_your_key`.

**Then say:**

- "Build me a booking app for my salon on MonstarX."
- "Import github.com/me/my-app into MonstarX."
- "What is MonstarX doing on my Harbour Watch project?"
- "Ask MonstarX to make the pricing page friendlier, then publish it."

> One connector works on the web, the desktop app and mobile. Claude chats have no shell, so whole apps come in with import_from_github; for a few files, push_files.

### ChatGPT

ChatGPT’s developer mode (Plus, Pro, Business, Enterprise and Education, on the web).

**Sign in with the browser (OAuth):**

Turn on **Developer mode** in ChatGPT’s settings (on Business and Enterprise an admin allows it first), then create a new app or connector with the address below and choose OAuth. ChatGPT asks before each tool that changes something.

```
https://uat.monstarx.app/mcp
```

**With an API key:**

ChatGPT signs in with OAuth only; there is no key to paste.

**Then say:**

- "Build me a booking app for my salon on MonstarX."
- "Import github.com/me/my-app into MonstarX."
- "What is MonstarX doing on my Harbour Watch project?"
- "Ask MonstarX to make the pricing page friendlier, then publish it."

### Lovable

Lovable’s chat connectors: its agent can call MonstarX while it builds.

**Sign in with the browser (OAuth):**

In Lovable: **Connectors → + → MCP server**, name it MonstarX, choose **Direct connection**, paste the address below and press **Add & authorize**.

```
https://uat.monstarx.app/mcp
```

**With an API key:**

Same steps, choosing **Bearer token / API key** and pasting `bck_your_key`.

**Then say:**

- "Import this project into MonstarX from GitHub (github.com/me/my-app)."
- "Ask MonstarX to build the admin dashboard for this app."
- "What does MonstarX say about the checkout bug?"

> Lovable’s agent has no shell. To send a whole app: connect the project to GitHub (Lovable syncs every change there), then ask it to import that repository into MonstarX, or do it yourself in MonstarX under Projects → Import.

### Bolt & v0

Both can call MCP servers while they generate.

**Sign in with the browser (OAuth):**

**Bolt.new:** Connectors (MCP) → **Custom MCP server** → name, the address below, transport **HTTP**, authentication **MCP OAuth** → Connect.

**v0:** the menu in the prompt box → **MCPs** (or the MCP Connections settings) → add the address below with **OAuth**.

```
https://uat.monstarx.app/mcp
```

**With an API key:**

Bolt: authentication **API key**. v0: **Bearer Token**. Paste `bck_your_key`.

**Then say:**

- "Import github.com/me/my-app into MonstarX."
- "Create this app on MonstarX as well, with the same pages."

> Bolt and v0 push to GitHub and export a zip. A GitHub repository comes in with import_from_github (or Projects → Import); a zip goes to Projects → Import → Upload a .zip.

### Replit

Replit Agent’s MCP servers, shared across your Repls.

**Sign in with the browser (OAuth):**

In Replit: **Integrations → MCP Servers → + Add MCP server**, name it MonstarX, paste the address below, then **Test & save** and sign in.

```
https://uat.monstarx.app/mcp
```

**With an API key:**

Same steps; under **Advanced settings** add the header `Authorization` with `Bearer bck_your_key`.

**Then say:**

- "Push this Repl’s app to MonstarX and give me the link."
- "Import github.com/me/my-app into MonstarX."

> If the agent cannot run the upload command, connect the Repl to GitHub and use import_from_github, or download the Repl as a zip and import it in MonstarX.

### Figma

Send designs to MonstarX to be built, from Figma or from an agent that reads Figma.

**Sign in with the browser (OAuth):**

**From Figma:** the Figma agent and Figma Make can use custom MCP connectors (paid plans, Full seat). Add a connector with the address below and sign in.

```
https://uat.monstarx.app/mcp
```

**From a coding agent:** connect Figma’s own MCP server and MonstarX to Claude Code, Cursor or Codex. The agent reads the frame with Figma’s tools and either builds it here and pushes it (prepare_upload), or hands it to MonstarX with create_project, describing the design and passing its images as image_urls when they are public links.

**With an API key:**

Figma’s connectors also take a custom header: `Authorization: Bearer bck_your_key`.

**Then say:**

- "Build this frame as an app on MonstarX (create_project with the design and its screenshot)."
- "Send this design to my MonstarX project and ask it to restyle the home page to match."

> Figma Make can also export its code to GitHub or a zip; bring that in with import_from_github or Projects → Import.

### Others

Anything that speaks MCP over Streamable HTTP, or only over stdio.

**Sign in with the browser (OAuth):**

Point the client at the server address. Clients that support MCP’s OAuth find the sign-in by themselves: the server answers 401 with its metadata.

```
https://uat.monstarx.app/mcp
```

**With an API key:**

Or send the key as a header: `Authorization: Bearer bck_your_key`. A client that only runs local (stdio) servers reaches MonstarX through mcp-remote:

```json
{
  "mcpServers": {
    "monstarx": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://uat.monstarx.app/mcp",
        "--header",
        "Authorization:${MONSTARX_AUTH}"
      ],
      "env": {
        "MONSTARX_AUTH": "Bearer bck_your_key"
      }
    }
  }
}
```

**Then say:**

- "Push this app to MonstarX and give me the link."
- "Build me a booking app for my salon on MonstarX."
- "Import github.com/me/my-app into MonstarX."

> The **More clients** section lists where Zed, JetBrains, Cline, Kiro, Amp, opencode, Perplexity and others keep their MCP servers.

## From other builders and design tools

MonstarX takes work from wherever it was made. Pick the road that fits the tool:

| Where the work is | How it gets to MonstarX | Tool |
| --- | --- | --- |
| A folder on your machine (Claude Code, Codex, Cursor, Grok Build, Gemini…) | The agent packs the folder and uploads it through a one-time link | prepare_upload |
| A GitHub repository (Lovable, Bolt, v0, Replit and Figma Make all sync there) | MonstarX reads the repository itself; nothing passes through the model | import_from_github |
| A zip (Bolt, v0, Replit, Figma Make downloads) | Projects → Import → Upload a .zip, or ask an agent to push the unzipped folder | Import dialog / prepare_upload |
| An idea, a spec or a design (a chat, Figma, a screenshot) | MonstarX builds a new app from the description and pictures | create_project |
| A few edits from a chat | Written straight into the project as a new version | push_files |

**Figma:** the Figma agent and Figma Make can call MonstarX directly as a custom connector; coding agents can read a frame with Figma’s own MCP server and hand it to MonstarX with create_project (image_urls for the frame’s pictures, when they are public links) or build it and push it.

## Workflows

**Push a new app.** prepare_upload without project_id returns a link and a command. From the app’s root folder the command runs:

```bash
COPYFILE_DISABLE=1 tar -czf - --exclude='node_modules' --exclude='.git' --exclude='.env' … . \
  | curl -sS --fail-with-body -X PUT -H 'Content-Type: application/gzip' --data-binary @- 'https://uat.monstarx.app/api/mcp/upload/bct_…'
```

The answer is JSON with the project’s address, what was found (framework, packages, keys the app reads), what was left out, and the revision. Windows gets the same as a PowerShell command using tar.exe and curl.exe.

**Push a new version.** prepare_upload with project_id and expected_revision. The project’s files are replaced by the upload as one new version (in Versions as “Pushed from Claude Code”, with a note in the chat so the owner and MonstarX’s builder know). The preview picks the changes up; new packages or pictures restart it.

**Bring MonstarX’s changes home.** download_project returns a link and `curl … | tar -xzf -`. A MonstarX app arrives as a standalone codebase (npm install && npm run dev); an imported app arrives as it is. Keep its revision for the next push.

**Keep building in MonstarX.** send_message with mode build (change the app), chat (questions, no changes) or plan (questions first), with pictures in image_urls if they help. Then get_messages with after_message_id and wait_seconds follows the reply until it is done.

**Publish.** publish_project builds and deploys the current version. Vite apps and MonstarX apps publish on MonstarX; Next.js, Remix, Astro, Nuxt and SvelteKit apps run in the preview but are published by the host they already have.

**Secrets.** Imported apps often read keys (VITE_SUPABASE_URL, STRIPE_SECRET_KEY…). The push result lists the ones the code cannot do without; set_secrets stores them encrypted and restarts the preview.

## Tools

| Tool | What it does | Arguments |
| --- | --- | --- |
| get_account | The account this connection acts for, its plan and what is left of its usage allowance. | — |
| list_projects | Your projects, most recently changed first, with ids and links. | query, limit |
| get_project | One project at a glance: kind, files revision, what MonstarX is doing, preview, publish status, missing secrets. | project_id |
| prepare_upload | A single-use upload link and the shell command that pushes the current folder, as a new project or a new version. | project_id, name, folder, expected_revision, force, rebuild |
| import_from_github | Bring in an app from a GitHub repository; MonstarX reads it itself (how Lovable, Bolt, v0 and Figma Make send whole apps). | repository, branch, folder, rebuild |
| push_files | Write a few text files directly (small edits, or clients without a shell). | project_id, name, files, delete, expected_revision, message |
| create_project | Have MonstarX build a new app from a description and pictures (a spec, a mockup, a Figma frame). | prompt, name, mode, image_urls |
| read_files | List a project's files, or read some of them. | project_id, paths |
| download_project | A single-use download link and the command that unpacks the project here. | project_id |
| send_message | Ask the project's MonstarX builder to build, answer or plan, as if you typed in the workspace, with pictures if you like. | project_id, message, mode, image_urls |
| get_messages | Read the project's chat, optionally waiting for MonstarX to finish replying. | project_id, after_message_id, wait_seconds, limit |
| stop | Stop what MonstarX is running in a project. | project_id |
| publish_project | Put the current version live on its MonstarX address and custom domain. | project_id |
| set_secrets | Store the environment variables the app reads, encrypted, in Backend → Secrets. | project_id, secrets |
| get_logs | The preview's state and its dev server's output; can start a stopped preview. | project_id, start, lines |

Every tool acts on projects you own. Tools that only read are marked read-only, so clients can run them without asking; publishing is marked as reaching the open web, so clients ask first.

## More clients

Any client with remote MCP works. Where these keep their servers (use https://uat.monstarx.app/mcp):

| Client | Where to add MonstarX |
| --- | --- |
| Zed | settings.json → `"context_servers": { "monstarx": { "url": "…/mcp" } }`; signs in with OAuth unless you add an Authorization header |
| JetBrains AI Assistant | Settings → Tools → AI Assistant → MCP: `{ "mcpServers": { "monstarx": { "url": "…/mcp" } } }` |
| Junie (JetBrains) | `~/.junie/mcp/mcp.json` with `url` (and `headers`), then Authorize |
| Cline | MCP servers → remote: `"type": "streamableHttp"`, `url`, `headers` |
| Roo Code | `"type": "streamable-http"`, `url`, `headers` |
| Kiro | `~/.kiro/settings/mcp.json` with `url`; OAuth by itself |
| Amp | `amp mcp add monstarx …/mcp`; OAuth by itself |
| opencode | `"mcp": { "monstarx": { "type": "remote", "url": "…/mcp" } }`, then `opencode mcp auth monstarx` |
| Goose | `~/.config/goose/config.yaml`: `type: streamable_http`, `uri: …/mcp` |
| Warp | MCP servers → add by URL, with a `headers` field for a key |
| Factory Droid | `droid mcp add monstarx …/mcp --type http --header "Authorization: Bearer bck_…"` |
| Devin | Customize → MCPs → HTTP, with the address and an Authorization header |
| Augment | Remote MCP (HTTP) with the address; OAuth or headers |
| Continue | `mcpServers: - name: monstarx, type: streamable-http, url: …/mcp` |
| Perplexity | + Custom connector → Remote, with OAuth or an API key (Pro, Max, Enterprise) |
| Mistral Le Chat | Connectors → Add Connector → Custom MCP Connector, with a Bearer token |
| Microsoft Copilot Studio | Add an existing MCP server (Streamable HTTP), with OAuth or an API key header |

## What runs on MonstarX

| Your code | What happens | Publishing |
| --- | --- | --- |
| MonstarX export coming home | A full MonstarX app again: database, accounts, email, storage | On MonstarX |
| Vite + React / Vue / Svelte, CRA (every Lovable, Bolt and v0 export) | Runs as it is, with its own packages | On MonstarX, as a static site |
| Next.js, Remix, React Router, Astro, Nuxt, SvelteKit, TanStack Start | Runs as it is in the preview, behind MonstarX’s proxy | By the host it already has |
| React Native, Expo, Flutter, Django, Rails, Laravel, Go… | Cannot run in a browser sandbox; rebuild: true has MonstarX study it and rebuild it as a web app | On MonstarX, after the rebuild |
| A library, a CLI, a dataset | Refused, with the reason | — |

The checks are the same as Projects → Import. An imported app runs on its own framework; to get MonstarX’s database, accounts and one-click backend, ask MonstarX to rebuild it on its stack.

## Limits

- An upload: 50 MB compressed; 3,000 text files and 12 MB of code; images and other files up to 10 MB each and 800 in all.
- push_files: 200 files, 400 KB each, 2 MB per call. image_urls: 6 pictures or PDFs, 15 MB each, public https links.
- Upload and download links work once, for 15 minutes.
- A push that would delete most of a project (fewer than a quarter of its files) is refused unless force is passed: that is almost always the wrong folder.
- A push is refused while MonstarX is building in the project; get_project shows when it is done.
- API keys: 20 per account. Browser sign-ins refresh for 90 days of use.
- MonstarX’s own work (send_message, create_project, rebuilds) uses your plan’s allowance; pushing, importing, downloading, reading and publishing do not.

## Security and privacy

- Sign in with OAuth 2.1 (PKCE, rotating refresh tokens) or an API key. MonstarX stores only a hash of each key and token; a key is shown once, when it is made.
- See and revoke keys and connected agents in [Settings → API & MCP](https://uat.monstarx.app/settings/api). Resetting your password disconnects every agent that signed in with the browser.
- Only a bearer token signs in to the MCP server — never your browser session — so a web page cannot act through it.
- The upload command leaves out .env files; if one arrives anyway, MonstarX does not store it and says so. Keep keys in Secrets.
- Upload and download links are single-use, bound to your account and one project, and expire in 15 minutes.
- Agents act as you: they can change and publish your projects. Connect only agents you use, and read what they ask before you allow them.

## Troubleshooting

- **The tools do not show up.** Most agents load MCP servers when a session starts: start a new one. In Claude Code, `/mcp` shows whether MonstarX is connected.
- **401 or “sign in”.** The sign-in lapsed or the key was revoked: authenticate again (`/mcp` in Claude Code, `codex mcp login monstarx`), or make a new key.
- **The agent says a tool call was cancelled.** Headless runs (codex exec, CI) refuse tools that need approval; publishing always asks. Run it interactively, or approve it.
- **curl: command not found / tar fails on Windows.** Use `command_windows_powershell` from prepare_upload’s answer: Windows 10 and 11 ship tar.exe and curl.exe.
- **Codex cannot upload.** Its sandbox blocks the network: approve the command, or allow network access.
- **“This upload has 3 files and the project has 214”.** The command ran in the wrong folder; run it where package.json is.
- **“The files in MonstarX changed since your copy was taken”.** Someone built in MonstarX after your last push or download. Download, merge, push with the new revision.
- **A private repository is not found.** Connect GitHub in MonstarX (Settings → Integrations) so it can read it.
- **The app does not start.** get_logs shows the preview’s output (install errors, a missing key). Set missing keys with set_secrets.

## For developers: the protocol

The server speaks the Model Context Protocol over Streamable HTTP (protocol versions 2025-11-25, 2025-06-18, 2025-03-26 and 2024-11-05), stateless: each POST to https://uat.monstarx.app/mcp carries one JSON-RPC message and gets JSON back. It offers tools only.

```bash
curl -s https://uat.monstarx.app/mcp \
  -H 'Authorization: Bearer bck_your_key' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"list_projects","arguments":{}}}'
```

OAuth discovery: https://uat.monstarx.app/.well-known/oauth-protected-resource/mcp (RFC 9728) and https://uat.monstarx.app/.well-known/oauth-authorization-server (RFC 8414), dynamic client registration at https://uat.monstarx.app/oauth/register (RFC 7591), and client ID metadata documents. Public clients with PKCE (S256); loopback redirects on any port. Scope: `monstarx`.