@rebasepro/cli 0.11.0 → 0.11.1-canary.g8caabf3

package/dist/manifest.d.ts

@@ -36,10 +36,12 @@ export declare function validateManifest(raw: unknown): {
  * the manifest a no-op for existing projects: the synthesized result is what
  * they would have written by hand.
  *
- * An ejected backend — one with its own `src/index.ts` entrypoint — is reported
- * as a `custom` app rather than a `backend` app. That is not a downgrade; it is
- * an accurate description, and it is what keeps such a project deploying exactly
- * as it does today.
+ * The backend's `runtime` is inferred from whether the repository declares a
+ * **Dockerfile** — the thing that actually builds an image — and from nothing
+ * else. It used to be inferred from the presence of `backend/src/index.ts`,
+ * which every scaffolded project had whether or not it wanted its own server, so
+ * projects predating the manifest silently landed on the custom runtime and paid
+ * for it (see `docs/cloud-deploy-workspace-vendoring.md`).
  */
 export declare function synthesizeManifest(projectRoot: string): RebaseProjectManifest;
 export declare function manifestPath(projectRoot: string): string;
@@ -72,12 +74,29 @@ export declare function buildableApps(manifest: RebaseProjectManifest): {
  * verdict.
  */
 export declare function assessManagedCompatibility(manifest: RebaseProjectManifest): ManagedCompatibility;
-/** Resolve a backend app's directories against the conventions it omits. */
-export declare function resolveBackendPaths(app: RebaseBackendAppConfig): {
+/**
+ * Resolve a backend app's directories against the conventions it omits.
+ *
+ * `hasCollections` replaces the old `mode: "cms" | "baas"` field. Where the
+ * collections come from was never an independent choice: either they are
+ * declared in code and the bundle ships them, or they are not and the runtime
+ * introspects the live database at boot. Declaring it separately only created
+ * the contradictory state — code-first declared, no collections anywhere.
+ *
+ * `hasConfig` is deliberately a **separate** question. A headless project has no
+ * `config/collections`, but it may still ship a config package — that is where
+ * the `storageAuthorize` hook lives, and storage is not under row-level
+ * security, so without one the server refuses to boot with storage enabled.
+ * Collapsing the two would leave a headless project nowhere to put it.
+ */
+export declare function resolveBackendPaths(app: RebaseBackendAppConfig, projectRoot: string): {
     config: string;
     functions: string;
     crons: string;
     schema: string;
     usersCollection: string;
-    mode: "cms" | "baas";
+    /** Whether a config package exists — hooks, storage authorization. */
+    hasConfig: boolean;
+    /** Whether collections are declared in code, under `<config>/collections`. */
+    hasCollections: boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/cli",
-  "version": "0.11.0",
+  "version": "0.11.1-canary.g8caabf3",
   "description": "Developer tools for Rebase projects",
   "main": "./dist/index.es.js",
   "module": "./dist/index.es.js",
@@ -31,12 +31,12 @@
     "execa": "^9.6.1",
     "inquirer": "14.0.2",
     "jiti": "^2.7.0",
-    "@rebasepro/agent-skills": "0.11.0",
-    "@rebasepro/client": "0.11.0",
-    "@rebasepro/codegen": "0.11.0",
-    "@rebasepro/server-postgres": "0.11.0",
-    "@rebasepro/types": "0.11.0",
-    "@rebasepro/server": "0.11.0"
+    "@rebasepro/agent-skills": "0.11.1-canary.g8caabf3",
+    "@rebasepro/client": "0.11.1-canary.g8caabf3",
+    "@rebasepro/server": "0.11.1-canary.g8caabf3",
+    "@rebasepro/codegen": "0.11.1-canary.g8caabf3",
+    "@rebasepro/server-postgres": "0.11.1-canary.g8caabf3",
+    "@rebasepro/types": "0.11.1-canary.g8caabf3"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

package/runtime/dev-server.mjs

@@ -31,7 +31,6 @@ const bundle = createSourceBundle({
     functions: optional(process.env.REBASE_DEV_FUNCTIONS),
     crons: optional(process.env.REBASE_DEV_CRONS),
     schema: optional(process.env.REBASE_DEV_SCHEMA),
-    mode: process.env.REBASE_DEV_MODE === "baas" ? "baas" : "cms",
     app: optional(process.env.REBASE_DEV_APP)
 });
 

package/templates/{template/backend → eject}/Dockerfile

@@ -1,10 +1,22 @@
-# ─── Multi-stage production Dockerfile for the Rebase backend ─────────
-# Produces a minimal image (~150MB) with only the runtime needed.
+# ─── Your image ───────────────────────────────────────────────────────
+#
+# `rebase eject` wrote this file, and it is yours now — nothing regenerates or
+# updates it. The platform runtime is no longer involved: this image compiles
+# and runs backend/src/index.ts, so CORS, auth wiring, storage and shutdown are
+# configured there rather than by the runtime, and Rebase runtime upgrades do
+# not reach this project.
+#
+# Assumes pnpm, which is what `rebase init` scaffolds a workspace for. On npm,
+# swap the three pnpm lines below for `npm ci` and `npm run build --workspace`.
 #
 # Build context: the project root (where pnpm-workspace.yaml lives)
 # Usage:
-#   docker build -t my-app-backend -f backend/Dockerfile .
-#   docker run -p 3001:3001 --env-file .env my-app-backend
+#   docker build -t my-app .
+#   docker compose -f docker-compose.custom.yml up
+#
+# The managed alternative — no image to build, your project mounted into the
+# published runtime — is docker-compose.yml, which is still here and still
+# works if you change `runtime` back to "managed" in rebase.json.
 
 # ── Stage 1: Install + Build ─────────────────────────────────────────
 FROM node:22-alpine AS builder

package/templates/{template → eject}/backend/src/env.ts

@@ -19,7 +19,6 @@ const __dirname = path.dirname(__filename);
  */
 function findEnvFile(startDir: string): string | undefined {
     let dir = startDir;
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         const candidate = path.join(dir, ".env");
         if (fs.existsSync(candidate)) return candidate;

package/templates/eject/docker-compose.custom.yml

@@ -0,0 +1,71 @@
+# ─── Self-hosting an ejected project ─────────────────────────────────
+#
+# `rebase eject` wrote this. It builds the image described by ./Dockerfile and
+# runs YOUR backend/src/index.ts, rather than mounting a bundle into the
+# published Rebase runtime.
+#
+#   docker compose -f docker-compose.custom.yml up -d db
+#   rebase db push                                    # once
+#   docker compose -f docker-compose.custom.yml up --build
+#
+# What you gave up by ejecting: the platform no longer upgrades the server
+# underneath you, and CORS, auth wiring, storage and shutdown are configured in
+# your entrypoint rather than by the runtime. What you gained: it is your
+# process, and you can put anything you like in it.
+#
+# `docker-compose.yml` is still here and still runs the managed shape. Nothing
+# stops you going back — set `runtime: "managed"` in rebase.json, `rebase build`,
+# and use that file instead.
+# ─────────────────────────────────────────────────────────────────────
+
+name: {{PROJECT_NAME}}
+
+services:
+  db:
+    image: postgres:18-alpine
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: rebase
+      POSTGRES_PASSWORD: ${DATABASE_PASSWORD:-changeme}
+      POSTGRES_DB: rebase
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U rebase -d rebase"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+      start_period: 10s
+
+  backend:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    ports:
+      - "${PORT:-3001}:3001"
+    env_file: .env
+    environment:
+      DATABASE_URL: postgresql://rebase:${DATABASE_PASSWORD:-changeme}@db:5432/rebase?options=-c%20search_path=public
+      ADMIN_CONNECTION_STRING: postgresql://rebase:${DATABASE_PASSWORD:-changeme}@db:5432/rebase?options=-c%20search_path=public
+      NODE_ENV: production
+      PORT: "3001"
+      # Your entrypoint serves the built frontend itself (see the `serveSPA`
+      # call in backend/src/index.ts), so this is one container, same origin.
+      CORS_ORIGINS: ${CORS_ORIGINS:?set CORS_ORIGINS to the origin you browse to}
+      # A durable named volume, which is the case this flag acknowledges.
+      STORAGE_PATH: /uploads
+      FORCE_LOCAL_STORAGE: "true"
+    depends_on:
+      db:
+        condition: service_healthy
+    volumes:
+      - uploads:/uploads
+
+volumes:
+  postgres_data:
+    driver: local
+  uploads:
+    driver: local

package/templates/overlays/baas/backend/package.json

@@ -2,12 +2,9 @@
     "name": "{{PROJECT_NAME}}-backend",
     "version": "1.0.0",
     "description": "Rebase BaaS — headless PostgreSQL API",
-    "main": "src/index.ts",
     "type": "module",
     "scripts": {
-        "dev": "tsx watch --include=\"./functions/**/*\" src/index.ts",
-        "build": "tsc",
-        "start": "node dist/index.js"
+        "build": "tsc"
     },
     "dependencies": {
         "@rebasepro/server": "workspace:*",

package/templates/overlays/baas/backend/tsconfig.json

@@ -5,7 +5,6 @@
     "moduleResolution": "node",
     "lib": ["ES2022"],
     "outDir": "./dist",
-    "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true,
@@ -15,5 +14,12 @@
     "declaration": true,
     "sourceMap": true
   },
-  "include": ["src/**/*"]
+  // `functions/` as well as `src/`, because this flavour has nothing in src:
+  // it declares no collections, so there is no generated schema, and the server
+  // entrypoint lives behind `rebase eject`. An include matching only an empty
+  // directory is TS18003 — tsc reports "no inputs" as an error, not a no-op.
+  //
+  // No `rootDir`: it would have to be `.` for both, and letting tsc infer the
+  // common root gets there without a second place to keep in sync.
+  "include": ["src/**/*", "functions/**/*"]
 }

package/templates/overlays/baas/config/index.ts

@@ -0,0 +1,15 @@
+/**
+ * The config package for a headless project.
+ *
+ * There are no collections here: this flavour introspects them from the live
+ * database at boot, which is exactly what "no `config/collections` directory"
+ * means to `rebase build`.
+ *
+ * The package still exists because storage does not run under row-level
+ * security and its keys share one flat namespace — so without an access model,
+ * a deployment with file storage enabled serves every user's files to every
+ * signed-in user. The server refuses to boot in that state, and this is the
+ * export it looks for.
+ */
+
+export { storageAuthorize } from "./storage.js";

package/templates/overlays/baas/config/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "{{PROJECT_NAME}}-config",
+  "version": "1.0.0",
+  "description": "Storage access control for a headless Rebase project",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@rebasepro/types": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/templates/overlays/baas/package.json

@@ -5,7 +5,8 @@
     "private": true,
     "type": "module",
     "workspaces": [
-        "backend"
+        "backend",
+        "config"
     ],
     "scripts": {
         "dev": "rebase dev",

package/templates/overlays/baas/pnpm-workspace.yaml

@@ -1,5 +1,6 @@
 packages:
   - "backend"
+  - "config"
 linkWorkspacePackages: true
 blockExoticSubdeps: false
 minimumReleaseAge: 0

package/templates/overlays/baas/rebase.json

@@ -1,14 +1,10 @@
 {
     "$schema": "https://rebase.pro/schemas/rebase.json",
-    "runtime": "^1",
+    "rebase": "^1",
     "apps": {
         "backend": {
             "type": "backend",
-            "mode": "baas"
-        },
-        "admin": {
-            "type": "admin",
-            "mode": "hosted"
+            "runtime": "managed"
         }
     }
 }

package/templates/template/README.md

@@ -60,20 +60,27 @@ server). Pin a port with `rebase dev --port 3001` if you need a stable one.
 ## Project Structure
 
 ```
-├── frontend/           # React frontend (Vite)
-│   ├── Dockerfile      # Production build → nginx
-│   └── nginx.conf      # SPA routing + compression
-├── backend/            # Hono backend with PostgreSQL
-│   ├── Dockerfile      # Multi-stage production build
+├── frontend/           # Your admin panel (React + Vite)
+├── backend/            # Server code
 │   ├── functions/      # Custom API endpoints (auto-discovered)
-│   └── src/
+│   └── src/            # Generated database schema
 ├── config/             # Shared collection definitions
 │   └── collections/    # Schema-as-Code TypeScript files
-├── docker-compose.yml  # Production stack (Postgres + Backend + Frontend)
+├── rebase.json         # Which apps this repository contains
+├── docker-compose.yml  # Self-hosting stack (Postgres + the Rebase runtime)
 ├── .env.example        # Environment variable reference
 └── package.json        # Root workspace config
 ```
 
+There is no Dockerfile, and that is deliberate: `rebase build` produces a
+**bundle** — your compiled collections, functions, crons and admin assets — and
+the published `rebasepro/server` image boots it. The artifact you self-host is
+the artifact Rebase Cloud runs, so moving between them changes nothing in this
+repository.
+
+If you would rather run your own server process, `rebase eject` writes the
+entrypoint, a Dockerfile and a compose file that builds them.
+
 ### Custom Functions
 
 Drop a Hono app in `backend/functions/` and it's auto-mounted at `/api/functions/<name>`:
@@ -105,23 +112,28 @@ All configuration is managed through a single `.env` file in the project root. B
 
 `init` already generated your `.env`. See the comments in `.env.example` for details on each variable, and edit `.env` directly to change any of them.
 
-## Production Deployment
+## Self-hosting
+
+Two containers: PostgreSQL, and the Rebase runtime with your built project
+mounted into it. There is no application image to build.
 
-The full stack — PostgreSQL, backend, and frontend — runs from
-`docker compose`. The backend image builds and boots, but it does **not**
-create your collection tables on its own, so push the schema once the
-database is up before (or right after) starting the rest of the stack.
+The runtime creates its auth tables at boot but **not** your collection tables —
+a container restart must not be able to change a schema as a side effect — so
+push the schema once, while the database is up.
 
 ```bash
-# 1. Start the database and create the tables from your collections
+# 1. Build your project into ./dist-bundle
+pnpm run build          # or: npm run build
+
+# 2. Start the database and create the tables from your collections
 docker compose up -d db
 pnpm run db:push        # or: npm run db:push
 
-# 2. Build and start the backend + frontend
-docker compose up -d --build
+# 3. Start the runtime
+docker compose up -d
 
 # View logs
-docker compose logs -f backend
+docker compose logs -f api
 
 # Stop
 docker compose down
@@ -130,6 +142,12 @@ docker compose down
 docker compose down -v
 ```
 
+One container now serves the API at `/api` and the admin at `/` — same origin,
+so there is no CORS between them and no second web server to run.
+
+To upgrade Rebase, set `REBASE_VERSION` in `.env` and restart. Your bundle is
+untouched.
+
 > `docker compose` reads the generated `.env` as-is. Set production values
 > (a strong `DATABASE_PASSWORD`, `JWT_SECRET`, storage credentials, …) by
 > editing `.env` directly — see `.env.example` for the full list. Do not

package/templates/template/backend/package.json

@@ -2,12 +2,9 @@
     "name": "{{PROJECT_NAME}}-backend",
     "version": "1.0.0",
     "description": "Rebase backend with PostgreSQL",
-    "main": "src/index.ts",
     "type": "module",
     "scripts": {
-        "dev": "tsx watch --include=\"../config/**/*\" --include=\"./functions/**/*\" src/index.ts",
-        "build": "rebase schema generate --collections ../config/collections && tsc",
-        "start": "node dist/backend/src/index.js"
+        "build": "rebase schema generate --collections ../config/collections && tsc"
     },
     "dependencies": {
         "{{PROJECT_NAME}}-config": "*",

package/templates/template/docker-compose.yml

@@ -1,17 +1,32 @@
-# ─── Rebase — Production Docker Compose ──────────────────────────────
+# ─── Self-hosting this project ───────────────────────────────────────
 #
-# Quick start:
-#   cp .env.example .env    # Edit with your secrets
-#   docker compose up -d    # Start everything
+# Two containers: PostgreSQL, and the Rebase runtime with your built project
+# mounted into it. There is no application image to build here — the runtime is
+# the same published image every Rebase deployment runs, and your project
+# travels as a bundle.
 #
-# This runs:
-#   1. PostgreSQL 18 with persistent data
-#   2. Backend (Node.js / Hono) with health checks
-#   3. Frontend (nginx) serving the Vite build
+# That is the point: the artifact you self-host is the artifact Rebase Cloud
+# runs. Nothing about this repository changes when you move between them; only
+# the destination does, and that lives in `.rebase/cloud.json`, which is not
+# committed.
+#
+#   rebase build              # produces ./dist-bundle
+#   docker compose up -d db
+#   rebase db push            # create the collection tables, once
+#   docker compose up
+#
+# One container then serves the API at /api and the admin at / — same origin, so
+# there is no CORS to configure between them and no second web server.
 #
 # For development, use `rebase dev` instead.
+#
+# To upgrade Rebase, change REBASE_VERSION and restart. Your bundle is untouched.
+# To run your OWN server code instead, `rebase eject` — it writes the entrypoint,
+# a Dockerfile and a compose file that builds them.
 # ─────────────────────────────────────────────────────────────────────
 
+name: {{PROJECT_NAME}}
+
 services:
   # ── PostgreSQL ───────────────────────────────────────────────────────
   db:
@@ -21,20 +36,25 @@ services:
       POSTGRES_USER: rebase
       POSTGRES_PASSWORD: ${DATABASE_PASSWORD:-changeme}
       POSTGRES_DB: rebase
+    # Published so `rebase db push` can reach it from the host. Remove this
+    # mapping once the schema is in place if the database should not be
+    # reachable from outside the compose network.
     ports:
       - "5432:5432"
     volumes:
       - postgres_data:/var/lib/postgresql
     healthcheck:
+      # The runtime must not start before the database can answer, or its first
+      # boot fails on a connection refused and the container restarts for no
+      # reason a reader would understand.
       test: ["CMD-SHELL", "pg_isready -U rebase -d rebase"]
       interval: 5s
       timeout: 5s
       retries: 10
       start_period: 10s
-    # Production tuning (adjust for your workload)
     command:
       - "postgres"
-      - "-c" 
+      - "-c"
       - "shared_buffers=256MB"
       - "-c"
       - "max_connections=100"
@@ -45,44 +65,48 @@ services:
       - "-c"
       - "log_min_duration_statement=1000"
 
-  # ── Backend ──────────────────────────────────────────────────────────
-  backend:
-    build:
-      context: .
-      dockerfile: backend/Dockerfile
+  # ── The Rebase runtime, booting your bundle ──────────────────────────
+  api:
+    image: rebasepro/server:${REBASE_VERSION:-latest}
     restart: unless-stopped
+    depends_on:
+      db:
+        condition: service_healthy
     ports:
       - "${PORT:-3001}:3001"
-    env_file: .env
     environment:
-      # Override DATABASE_URL to point to the Docker network service
       DATABASE_URL: postgresql://rebase:${DATABASE_PASSWORD:-changeme}@db:5432/rebase?options=-c%20search_path=public
       ADMIN_CONNECTION_STRING: postgresql://rebase:${DATABASE_PASSWORD:-changeme}@db:5432/rebase?options=-c%20search_path=public
+      JWT_SECRET: ${JWT_SECRET:?set JWT_SECRET in .env — `rebase init` generates one}
+      REBASE_SERVICE_KEY: ${REBASE_SERVICE_KEY:?set REBASE_SERVICE_KEY in .env — `rebase init` generates one}
       NODE_ENV: production
       PORT: "3001"
-      # The server refuses to boot with local storage under NODE_ENV=production,
-      # because the container filesystem is destroyed on the next restart and
-      # uploads go with it. That does not apply here: the `uploads` volume below
-      # is a durable named volume mounted at the storage path, which is exactly
-      # the case the check tells you to acknowledge with this flag. Switch to
-      # STORAGE_TYPE=s3 or gcs and drop this line if you move storage off-box.
+
+      # The origins a browser will load the admin from. With the admin folded
+      # into the bundle it is served from this very container, so this is just
+      # your own address — but it is still required, because an API that guesses
+      # its allowed origins is one that eventually allows the wrong one.
+      CORS_ORIGINS: ${CORS_ORIGINS:?set CORS_ORIGINS to the origin you browse to, e.g. http://localhost:3001}
+
+      # Auth tables are created at boot. Collection tables are not: run
+      # `rebase db push` once, against the database above. A container restart
+      # must not be able to change a schema as a side effect.
+      REBASE_MIGRATE_ON_BOOT: ${REBASE_MIGRATE_ON_BOOT:-ensure}
+
+      # Uploads land on the named volume below, which survives restarts. That is
+      # the case FORCE_LOCAL_STORAGE exists to acknowledge — without a durable
+      # mount the server refuses local storage in production, because the
+      # container filesystem is destroyed on the next deploy and every uploaded
+      # file goes with it. Switch to STORAGE_TYPE=s3 or gcs and drop both lines
+      # if you move storage off-box.
+      STORAGE_PATH: /uploads
       FORCE_LOCAL_STORAGE: "true"
-    depends_on:
-      db:
-        condition: service_healthy
     volumes:
-      - uploads:/app/backend/uploads
-
-  # ── Frontend ─────────────────────────────────────────────────────────
-  frontend:
-    build:
-      context: .
-      dockerfile: frontend/Dockerfile
-    restart: unless-stopped
-    ports:
-      - "80:80"
-    depends_on:
-      - backend
+      # Your built project. Writable, because the runtime installs the bundle's
+      # declared dependencies into it on first start — `rebase build` emits a
+      # package.json but not a node_modules.
+      - ./dist-bundle:/bundle
+      - uploads:/uploads
 
 volumes:
   postgres_data:

package/templates/template/frontend/src/main.tsx

@@ -8,12 +8,19 @@ window.addEventListener("unhandledrejection", (event: PromiseRejectionEvent) =>
     console.error("[Rebase] Unhandled promise rejection:", event.reason);
 });
 
+// Where this app is mounted, from the `path` declared in rebase.json.
+//
+// `rebase build` passes it to Vite as `base` (REBASE_APP_BASE), and Vite exposes
+// it back as BASE_URL — so the assets, the router and the server all agree on
+// one value without it being written down three times. At "/" this is "".
+const basename = import.meta.env.BASE_URL.replace(/\/$/, "");
+
 const router = createBrowserRouter([
     {
         path: "/*",
         element: <App/>
     }
-]);
+], { basename });
 
 ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
     <React.StrictMode>

package/templates/template/frontend/vite.config.ts

@@ -7,6 +7,11 @@ import { rebaseCollectionsPlugin } from "@rebasepro/app/vitePlugin";
 
 export default defineConfig({
     envDir: path.resolve(__dirname, ".."),
+    // The public path this app is served under, from its `path` in rebase.json.
+    // `rebase build` sets REBASE_APP_BASE; without this line an app declared at
+    // "/admin" would emit assets rooted at "/" and render a blank page. The
+    // build refuses to ship that — see docs/apps-and-runtimes.md §4.2.
+    base: process.env.REBASE_APP_BASE ?? "/",
     // Force a single copy of React and React Router across the app and all
     // @rebasepro/* packages. Without this, a locally `link:`ed Rebase checkout
     // resolves its own copies of react-router, producing "multiple copies of

package/templates/template/rebase.json

@@ -1,20 +1,17 @@
 {
     "$schema": "https://rebase.pro/schemas/rebase.json",
-    "runtime": "^1",
+    "rebase": "^1",
     "apps": {
         "backend": {
-            "type": "backend"
+            "type": "backend",
+            "runtime": "managed"
         },
-        "web": {
+        "admin": {
             "type": "static",
             "root": "frontend",
             "build": "npm run build --workspace frontend",
             "output": "frontend/dist",
-            "spa": true
-        },
-        "admin": {
-            "type": "admin",
-            "mode": "hosted"
+            "path": "/"
         }
     }
 }