plopino-mcp

Purpose

Plopino MCP is an MCP server for Plopino, with the goal of letting AI agents directly publish the content they have just built and return a public link, without the user ever having to touch a browser. Publishable objects include a single page, a single file, or an entire folder (uploaded according to the original directory structure).

Main capabilities

• One-click publishing: Publish content to a public URL via the command line or an MCP tool.
• Document-first rendering: Word (doc/docx), Excel (xls/xlsx), and Markdown are rendered as readable pages; code and data files get syntax-highlighted previews; images and videos are displayed inline. The recipient can view them by opening the link, with no need to download files.
• Folder upload: Directory uploads are traversed recursively and skip .git、.env*、node_modules、.ssh、.aws and symbolic links; other files are included. Individual files explicitly selected on their own are uploaded as requested, and symlink inputs are rejected.
• In-place updates: The publish tool accepts an optional update_url, and after passing in the link returned by a previous publish, that page's content is replaced while the link stays the same (a token is required).
• Anonymous publishing: Anonymous by default, with no account, configuration, or API key required. The returned link is public; without a token the page is kept for one month, while with a token it is stored permanently and can be updated in place.
• Claim link: Anonymous creation returns claimUrl, which is a private browser link for the publisher. Open it yourself and sign in to confirm the claim, and the page will then be kept in the account. Do not append it to the public URL or share it with page viewers. In JSON output it is given in the claimUrl field; human-readable output is printed to stderr when publishing via the CLI, and is included in the MCP tool result when publishing via an agent.

How to use

Authentication (optional)

After setting PLOPINO_TOKEN , publishing is attributed to your account instead of being anonymous. You get a private dashboard, updates that keep the same link, and exemption from anonymous rate limits. Tokens can be created at plopino.com/b, and the panel provides ready-made commands with the token already included (the server keeps an encrypted copy, so you can come back for it at any time). Not setting a token is a supported configuration, not a degraded state; most users never need a token.

CLI publishing

The CLI publishes with a single command.login prompts for an email and a hidden password; if you do not have an account, create one on the website first. Signing in claims anonymous uploads made using the CLI's saved identity, reports the number claimed, and saves the session for subsequent uploads. An existing PLOPINO_TOKEN overwrites the saved session used for publishing. For accounts that only use Google/GitHub sign-in, subsequent uploads require an API token; CLI password sign-in requires the account to have a password.

Cookies are stored per server origin under ~/.config/plopino/ , and the file permissions are readable only by the owner. You can use PLOPINO_CONFIG_DIR to override the directory. Keeping that directory preserves the ability to claim anonymous uploads. Passwords are never stored. Signing out revokes the session but keeps the anonymous identity. Browser sessions and MCP sessions are independent of each other: signing in only on the website will not claim CLI uploads.

For non-interactive sign-in, use login --email you@example.com --password-stdin, providing the password via standard input from a secrets manager; do not pass the password as a command-line argument.--json gives structured results and errors; errors exit with status 1. By default, publishing writes only the URL to stdout and status to stderr.

Commands for the same server cannot run concurrently in the CLI; after forcibly terminating a process, the next command will identify and remove any stale lock when no command is running.

During the development phase before the npm release, replace the example's npx -y plopino Replace with node /path/to/boards/mcp/index.js.

MCP client setup

Any client that supports stdio MCP can use it—the server is an ordinary stdio process, and the only difference between clients is how it is registered. The following are all in the form used in each client's own documentation (verified 2026-09). Where plp_xxx appears, paste the token from plopino.com/b; that panel will fill it in for you and lets you choose the client. If the client does not want to run a local process, you can use the remote endpoint instead—the tools are the same, only a URL is needed.

• Codex (the CLI and IDE extension share ~/.codex/config.toml）
• WorkBuddy：~/.workbuddy/mcp.json(on Windows, %USERPROFILE%\.workbuddy\mcp.json; requires WorkBuddy 5.3+), then restart WorkBuddy
• Cursor: the same JSON goes in .cursor/mcp.json(project) or ~/.cursor/mcp.json(global)
• Windsurf: the same JSON goes in ~/.codeium/windsurf/mcp_config.json
• Claude Desktop: the same JSON goes in claude_desktop_config.json
• VS Code: the same idea goes in .vscode/mcp.json, but the key is servers, not mcpServers

No npm? The server is also available on the website as a single self-contained file, two lines instead of one, with no installation required."$HOME/…" is expanded by your shell when pasted, so what gets registered is an absolute path—this matters: the MCP client starts the server from an arbitrary working directory, and relative paths will fail.

After that, just ask: "publish this to Plopino" or "give me a link for that page".

Remote endpoint (no installation required)

All of the above runs on your machine. There is also a hosted Streamable HTTP endpoint that provides the same tools, for clients that support remote MCP servers and do not want to run a local process. Any client that accepts a remote server URL uses the same address. Authentication is the same: if you have a token, send Authorization: Bearer plp_xxx; if not, publish anonymously.

There are two deliberate differences from the stdio version:

1. publish_pathis not available remotely. It takes a path on the machine where the server is running, and remotely that is not your machine. Use publish_files to send content instead.
2. The endpoint is stateless: each request is handled independently, and there is no session to maintain.

Self-hosting/local

The server publishes to https://plopino.comby default. Set PLOPINO_BASE_URL to point to another instance—a staging host or your own deployment.

When to use it

• Let an AI agent publish a page or document immediately after building it and provide a shareable link.
• Publish a folder containing code, data, images, videos, or Word/Excel/Markdown as-is as a browsable page.
• Scenarios where links need to be kept long-term and content updated in place (using a token).
• Connect through the remote endpoint when you do not want to install a local process.

Limitations and caveats

• Anonymous uploads are rate-limited by the server per IP.
• publish_path recursively traverses directories and skips symbolic links—following symbolic links could escape the directory tree and upload files elsewhere on the machine.
• Nothing is uploaded before the tool is called; the server does no network I/O at startup.
• Node 20 or newer (required by MCP TypeScript SDK v2). The only runtime dependency is the MCP SDK.
• The remote endpoint does not support publish_path.
• stdout is the MCP protocol channel, and writing any non-JSON-RPC message will break the client; all logs must be written to stderr.
• The verified client configuration forms are 2026-09, and are listed in the official MCP registry as io.github.plopino/plopino-mcp, and it is also available on Smithery as an installable package.
• To fully test the publishing path, run a Plopino instance and connect the server to it via stdio.

Privacy and Retention

See the full policy at https://plopino.com/privacy。

• What is collected: only what is needed for publishing—the file contents and file names passed to the tool, the target URL, and, for anonymous publishing, the request IP address (used for daily rate limiting). The MCP server itself collects nothing and sends no telemetry; it runs locally and only writes to stderr.
• Use and storage: uploaded content is stored on Plopino servers and served from the returned public link.PLOPINO_TOKEN is stored in the local MCP client configuration; the server keeps only its SHA-256 hash.
• Third parties: content and usage data are not sold, shared, or sent to third parties for advertising. Plopino uses Cloudflare as a CDN/reverse proxy and self-hosted Umami for aggregate, cookieless visit counting.
• Retention period: anonymous uploads are deleted after 30 days; links can also be removed earlier from the account page. Uploads using a token are retained until you delete them or the account is closed. To request deletion or report abuse, contact abuse@plopino.com.
• Contact: abuse@plopino.com (abuse and privacy requests), or https://plopino.com/abuse。