Start

Connect a frontend

Host and edit the UI on Robodev, or point Lovable, Bolt, v0, and other tools at the same project host.

A Robodev project host can serve the UI and the APIs together. Create from a starter in the dashboard or with robodev create, then edit locally and run robodev deploy. Hosted React builds set VITE_API_URL to empty and use window.location.origin. You can still point Lovable, Bolt, v0, or local Vite at the same host.

Hosted on Robodev

• index.html plus src/main.tsx (or .ts / .jsx / .js) is a React app. Starbase bundles it. index.html alone is a static site. No index.html is API-only.
• Space, Auth chat, and Marketplace: robodev create / deploy with .robodev frontend set runs the local Vite build and uploads that static site. Dashboard create stays API-only.
• Blessed browser packages: react, react-dom, and @robodev-ai/client. User package.json scripts and vite.config are not run.
• Swagger stays at /_robodev/docs so a React app can own /docs.

Lovable and Bolt build the UI; Robodev hosts the backend they write under robodev/. Do not run the full robodev CLI there — it needs browser OAuth and home-dir credentials. Bolt runs robodev-be in its terminal by default, or publishes through the Robodev MCP connector instead. Lovable has no terminal, so by default it publishes through the Robodev MCP connector (https://robodev.povio.dev/mcp, OAuth, no GitHub); the alternative deploys from GitHub Actions with robodev-be and a ROBODEV_DEPLOY_KEY secret. Start on the project's Connect page (/projects/:id/connect). Full headless full-stack deploys use robodev deploy with a deploy key; see Deploy (/docs/deploy). When the human wants the app served from Robodev, the Robodev MCP connector can also publish the frontend with publish_frontend_files — a built dist, or React source using react, react-dom, react-router-dom and @robodev-ai/client; it replaces the live frontend and keeps the backend. Lovable keeps its frontend in Lovable.

Connect Lovable or Bolt from the dashboard

• New project → Create project creates an empty project and opens its Connect page. For an app you already built (for example one on Supabase), use Already have an app? on Connect. Connect is also in the project sidebar.
• Lovable is selected by default; pick Bolt if you prefer. New app: Start building in Lovable / Start building in Bolt opens a new builder project with the prompt filled in. Existing app (Already have an app?): Copy prompt and paste it into your existing project's chat (a link would start a new project).
• Bolt, terminal (default): the prompt carries a one-time claim code (rdc_…, valid 30 minutes). Bolt runs npx robodev-be@latest auth rdc_…, which swaps it for a deploy key named Bolt, then npx robodev-be deploy. The Connect page shows Connected once that happens; Regenerate link makes a fresh code.
• Bolt, Robodev MCP (Use the Robodev connector instead): Copy URL & open Bolt copies https://robodev.povio.dev/mcp and opens Bolt's MCP servers settings. Click Custom MCP server, paste the URL, choose MCP OAuth, Connect, then Allow. Enable it for the project. No claim code. Once per Bolt account; the Connect page shows Connected once Bolt is authorized.
• Lovable, Robodev MCP (default): Copy URL & open Lovable copies https://robodev.povio.dev/mcp and opens Lovable's Add MCP server form. Name it Robodev, paste the URL, leave auth on OAuth, Add & authorize, then Allow on the Robodev page. Once per Lovable account. The Connect page shows Connected once Lovable is authorized; manage it under Profile → Connected apps.
• Lovable, GitHub Action: the prompt commits a redacted robodev/.robodev (no deployToken) and a .github/workflows/robodev.yml that runs robodev-be deploy. On the Connect page choose Deploy from GitHub Actions instead, then Create deploy key, and add it to the GitHub repo as the ROBODEV_DEPLOY_KEY Actions secret, then re-run the workflow.
• The Robodev connector also manages the project's Secrets (set_secret, list_secrets, delete_secret, restart_worker) and its app's end-user accounts (list_auth_users, delete_auth_user — only when the human asks). Secret values are write-only. See Secrets (/docs/secrets#agents).
• Existing app prompts migrate Supabase code — tables, row-level security, edge functions, auth and storage — to Robodev. Data is not copied.
• The frontend reads the backend URL from src/lib/robodev.ts (ROBODEV_URL, overridable with VITE_ROBODEV_URL). No prompt contains a deploy key.

Starting inside the builder instead? Point it at https://robodev.povio.dev/agents.md, add the Robodev skill (https://robodev.povio.dev/skills/robodev/SKILL.md), or see https://robodev.povio.dev/llms.txt. If the tool has no terminal and no GitHub (for example v0), keep the UI there and run robodev-be on a real machine.

Robodev vs Supabase

• Robodev: TypeScript robodev/database.ts plus robodev/api/*.ts, deployed with robodev-be deploy from a builder or robodev deploy from a real machine. The browser talks with fetch and VITE_API_URL, or with @robodev-ai/client.
• Not Supabase: no @supabase/supabase-js, no PostgREST .from(), no Postgres CDC / Supabase realtime, no RLS. App-defined WebSockets exist — see Sockets (/docs/sockets). File storage is Robodev storage via injected ctx.storage in defineApi, not the Supabase Storage API.
• End-user login is Robodev Auth on the project host (Bearer tokens). See Auth (/docs/auth). It is not the Starbase dashboard login.
• Discover routes from OpenAPI on the project host. Do not invent endpoints.

Fetch and env contract

Set VITE_API_URL to the project API URL with no trailing slash. After robodev-be auth, read it from robodev/.robodev as projectApiUrl. robodev create and robodev link write this for the starter. If the tool is not Vite, set its public env var to the same URL and read that name instead — the URL contract does not change.

function projectApiUrl(): string {
  const fromEnv = import.meta.env.VITE_API_URL;
  if (typeof fromEnv === "string" && fromEnv.trim()) return fromEnv.replace(/\/+$/, "");
  if (typeof window !== "undefined") return window.location.origin;
  return "";
}

async function request<T>(path: string, init?: RequestInit): Promise<T> {
  const apiUrl = projectApiUrl();
  const res = await fetch(`${apiUrl}${path}`, {
    ...init,
    headers: { "Content-Type": "application/json", ...init?.headers },
  });
  if (!res.ok) {
    throw new Error((await res.text()) || `${res.status} ${path}`);
  }
  return res.json() as Promise<T>;
}

const planets = await request<Planet[]>("/api/planets");
await request("/api/planets", {
  method: "POST",
  body: JSON.stringify({ name: "Mars" }),
});

// Protected route (GET /api/me in the starter):
const token = localStorage.getItem("accessToken");
const me = await request<{ user: { id: string; email: string } }>("/api/me", {
  headers: token ? { Authorization: `Bearer ${token}` } : {},
});

Optional @robodev-ai/client

Prefer the small browser client when you need signup, login, and Bearer attachment. It is not React hooks. Use api.get("/api/...") or api.fetch("/api/..."). Nested api.boards.list.get() is a path builder, not a typed SDK. File uploads go through your own defineApi handlers. How-to: Auth (/docs/auth) and Storage (/docs/storage).

React Native and Expo: pass createClient({ url, storage }) with a sync or async storage (AsyncStorage, an expo-secure-store adapter) and await api.auth.ready() before reading getToken() or opening a socket. Google sign-in uses api.auth.signIn.googleUrl({ redirectUri }) and api.auth.completeFromUrl(url). See React Native and Expo (/docs/dev#react-native).

import { createClient } from "@robodev-ai/client";

const api = createClient({ url: import.meta.env.VITE_API_URL });
await api.auth.signIn.email({ email, password });
const { user } = await api.auth.getUser();
const me = await api.get("/api/me");
const raw = await api.fetch("/api/me").then((r) => r.json());

Project hosts

• Production API: https://{projectId}.robodev.povio.dev
• OpenAPI: {VITE_API_URL}/openapi.json
• Swagger UI: {project host}/_robodev/docs — not https://robodev.povio.dev/docs
• Copy the API URL from the project page in Starbase, from robodev projects, or from robodev deploy output.

Backend with robodev-be

Tools that can run npm/npx write robodev/database.ts and robodev/api/*.ts in the workspace and deploy with robodev-be. Do not run the full robodev CLI (browser OAuth) inside those tools. Do not invent endpoints; after deploy, read OpenAPI. If a tool cannot run a terminal, tell the human to run the same robodev-be commands on a real machine.

Fallback prompt for tools with no terminal

Prefer the project's Connect page for Lovable and Bolt. For a tool that cannot run npm/npx, paste the frontend-only block below together with the project API URL.

You are building ONLY the frontend. Do not use Supabase.

The backend is Robodev, not Supabase, not PostgREST, not Firebase.

Rules:
- Do not install or import @supabase/supabase-js or any Supabase client.
- Do not use Supabase createClient, .from(), .auth, realtime, or storage APIs.
- Optional Robodev client: @robodev-ai/client (createClient + auth + fetch). Not required — platform fetch is fine.
- Call the project API with fetch and one env var: VITE_API_URL (no trailing slash).
- If this tool is not Vite, set its public env to the same URL and read that variable instead.
- Production API: https://{projectId}.robodev.povio.dev
- OpenAPI JSON: {VITE_API_URL}/openapi.json
- Swagger UI: {project host}/_robodev/docs on the PROJECT host (not the marketing site /docs).
- CORS allows all browser origins.
- Routes are public unless OpenAPI marks them with bearerAuth (or the handler uses auth: "required"). Public routes stay public — do not invent a login wall for them.
- End-user auth is Robodev Auth on the project host: POST /api/user/auth/register, POST /api/user/auth/login, POST /api/user/auth/refresh, GET /api/user/me. Store accessToken and refreshToken and send Authorization: Bearer <accessToken>. Not cookies. Not the Starbase dashboard JWT.
- File storage is Robodev storage via your defineApi handlers (multipart + ctx.storage.upload). Public files are served at GET /storage/objects/{key}. Do not use the Supabase Storage API.
- There is no Postgres CDC or Supabase realtime, and no row-level security. App-defined sockets exist — see Sockets (/docs/sockets). Wrap storage in your own handlers for access control.
- JSON in, JSON out. Send Content-Type: application/json on writes.
- Discover routes from OpenAPI. Use only routes that exist. Do not invent backend endpoints.
- If a route you need is missing, tell the human to add robodev/database.ts / robodev/api/*.ts and run `robodev deploy` outside this tool, then refresh OpenAPI.

Fetch helper:

const apiUrl = import.meta.env.VITE_API_URL as string | undefined;

async function request<T>(path: string, init?: RequestInit): Promise<T> {
  if (!apiUrl) {
    throw new Error("Missing VITE_API_URL. Set it to your Robodev project URL.");
  }
  const res = await fetch(`${apiUrl}${path}`, {
    ...init,
    headers: { "Content-Type": "application/json", ...init?.headers },
  });
  if (!res.ok) {
    throw new Error((await res.text()) || `${res.status} ${path}`);
  }
  return res.json() as Promise<T>;
}

Example:
const planets = await request<Planet[]>("/api/planets");
await request("/api/planets", { method: "POST", body: JSON.stringify({ name: "Mars" }) });

The human will paste VITE_API_URL. Prefer the project's Connect page and robodev-be when the tool has a terminal.

Next

Create a project at /projects/new, then open the link or copy the prompt from its Connect page. Getting started is at /docs.