Sidequery Artifacts

Build and share small apps, APIs, and automations on infrastructure you control.

Everything you build is an artifact: a React UI, a TypeScript server, or both, with persistent SQLite storage, file uploads, secrets, logs, and scheduled runs. Build with your coding agent through MCP, then manage source, versions, and execution in the browser.

Deploy on Cloudflare or run your own servers with celld. Keep tools private, share them with your team, or publish a public URL.

What you can build

• Dashboards and tools: artifacts with a React UI and, optionally, their own TypeScript server, SQLite database, and file storage.
• APIs and webhooks: endpoints, which are artifacts with a server and no UI: Workers fetch handlers with outbound requests, secrets, and SQLite storage.
• Automations: run any artifact's server on an interval or cron schedule, with pause/resume, manual runs, logs, and execution history.
• Platform resources: native Workers declare queues, KV, R2, D1, or Durable Objects when the managed runtime is not enough.
• Things to share: give any artifact a readable URL, choose private or public access, and organize it in a personal or team library.

Projects support helper files and pinned bun dependencies. Edit and restore source revisions, or remix an existing project into a new one with fresh data. Source restores preserve the current database and files; they do not roll back live data.

Get started

Install Bun 1.4.0 or newer, then start the full application locally:

bunx @sidequery/artifacts host

Open localhost:4786 for the gallery. Connect your agent to the HTTP MCP endpoint at http://127.0.0.1:4786/mcp to create apps and scripts. The server runs in the foreground; Ctrl-C stops it.

The first run downloads and verifies a pinned celld binary. Apps and runtime data persist on your machine. The bundled runtime supports Apple Silicon macOS and glibc Linux on arm64 or x64.

For a persistent installation and a background service:

bun add --global @sidequery/artifacts
artifacts host start
artifacts host status

Use artifacts host install to enable startup at login. See the host guide for lifecycle commands, data locations, and upgrades.

Deploy

Docker

Run the full application locally with persistent storage:

docker run -d --name artifacts --restart unless-stopped \
  --stop-timeout 60 \
  -p 127.0.0.1:4786:4786 \
  -v artifacts-data:/app/.celld \
  ghcr.io/sidequery/artifacts:latest

Open localhost:4786. This example runs without sign-in and accepts connections from your machine only. See the Docker guide for network access, configuration, backups, and image versions.

Cloudflare and celld fleets

Configure sign-in before using a network deployment. The authentication guide covers provider setup, Cloudflare Access, MCP OAuth, and troubleshooting. The default local host needs no sign-in.

Both deployment options run the Artifacts application, including the gallery, HTTP MCP server, app backends, scripts, storage, and schedules. You own the infrastructure and configure who can sign in.

	Cloudflare	Your own servers with celld
Run on	Cloudflare Workers and Durable Objects	Machines running celld nodes backed by a supported object store
Operations	Cloudflare manages the runtime	You manage nodes, TLS, storage, and rollouts
Setup	Cloudflare deployment	celld deployment

Cloudflare deployment requires Workers Paid. Production CPU/memory qualification is still outstanding; see the deployment guide for current limits.

The local host command binds to loopback and uses local development state. For a network deployment, follow the celld guide to configure production nodes and authentication. The local host command does not provision a fleet or migrate its data to one.

Sign in with the system your team already uses: Google, GitHub, Microsoft Entra ID, Okta, Auth0, Keycloak, or another OAuth/OIDC provider. Artifacts uses Better Auth, a built-in authentication library, to connect to these services on either deployment. Cloudflare Access is an alternative for Cloudflare deployments. Personal libraries are private to their owner; admitted team members can read and edit the team library. Public links are configured separately from library ownership. See authentication and access and link access.

Build with your agent

Add your deployment's HTTP MCP URL to your client:

https://your-artifacts-host/mcp

For the local host, use http://127.0.0.1:4786/mcp. Remote clients use the configured deployment's sign-in flow. One connection supports personal and team libraries: use library_scope: "private" or library_scope: "team" on a tool call, or choose the library in the MCP gallery. Optional workspace and library URL parameters remain supported as connection defaults.

The connection advertises nine model tools: artifact_guide, artifact_list, artifact_read, artifact_write, artifact_edit, artifact_open, artifacts_discover, artifacts_query, and artifacts_execute. All 54 hosted operations remain available through that same connection. Use artifacts_discover to find an operation and retrieve its exact argument schema and relevant guide; call it through artifacts_query for reads or artifacts_execute for actions.

In the hosted gallery, More actions → Delete moves an artifact or script to recoverable Trash. Links stop working and schedules pause; source history, data, files and secrets are preserved. Restore it from Trash to recover its original link. Schedules stay paused until explicitly resumed. MCP exposes artifact_delete, script_delete, artifacts_trash, artifact_undelete and script_undelete through discovery. Local file connections expose their supported artifact operations through the same interface. No configuration switch is needed.

Ask your agent to read artifact_guide before authoring; topic backend covers servers, endpoints, and schedules. For example:

Build a team lunch poll with a React UI and a SQLite backend.

Create a webhook that verifies a signature using a stored secret and saves incoming events to SQLite.

Make an endpoint that checks a URL every hour and records the result.

For sign-in steps, supported credentials, and connection failures, see Connect to an existing deployment.

The tools support source reads and edits, typechecking, history, restore, remix, and execution. Scripts created with the earlier script_* tools keep working, and artifact_* tools operate on them by name; see legacy scripts. MCP Apps clients can also display interactive React artifacts inside the conversation. Clients without MCP Apps support still receive tool results and diagnostics.

Local files and terminal workflows

For React artifacts stored alongside your work, use the file-based CLI and gallery:

artifacts write overview --file overview.artifact.tsx
artifacts typecheck overview
artifacts web --port 4784

This workspace mode supports local source files, history, and stdio MCP. It does not execute artifact servers or schedules, and it does not synchronize with the full host. Herdr is optional for opening artifacts beside a terminal agent. See the local workspace and MCP reference for setup, inline views, targeted edits, history, and compatibility with older Canvas sources.

Documentation

Start with the documentation index to find the guide for your task.

• Authentication, MCP sign-in, and access permissions
• Portable MCP plugin and host surfaces
• Host commands and local persistence
• Deploy to Cloudflare
• Deploy celld on your own infrastructure
• Endpoints, URLs, dependencies, remix, schedules, and legacy scripts
• Native Workers, manifests, providers, and recovery
• Complete project export and import
• App backends and SQLite
• File storage
• Client-side routing
• Runtime plugins
• Local workspace, CLI, and MCP reference
• Source map and release process

Development

Preview the gallery with an isolated sample library:

bun install --frozen-lockfile
bun run demo

Open localhost:4788. Each launch creates temporary sample files and history, separate from your existing library. Set DEMO_PORT to use another port. Stop with Ctrl-C.

bun install --frozen-lockfile
bun run dev:cloudflare

This starts the application under local workerd at localhost:4785. To develop against celld instead, use bun run dev:celld with celld on your PATH; see the runtime setup.

bun run typecheck
bun run test
bun run typecheck:cloudflare
bun run test:cloudflare

Browser tests require bun x playwright install chromium. Additional suites cover MCP Apps and Herdr, celld (bun run test:celld), and package installation (bun run test:package). e2e/Dockerfile is the Herdr integration-test environment; the root Dockerfile builds the standalone celld image.