@rebasepro/cli 0.10.0 → 0.10.1-canary.14e53ae

package/dist/manifest.d.ts

@@ -0,0 +1,83 @@
+import type { ManagedCompatibility, RebaseAppConfig, RebaseBackendAppConfig, RebaseProjectManifest } from "@rebasepro/types";
+/** Runtime range written into new manifests. */
+export declare const CURRENT_RUNTIME_RANGE = "^1";
+/** Conventional locations, matching what `rebase init` scaffolds. */
+export declare const DEFAULT_CONFIG_DIR = "config";
+export declare const DEFAULT_FUNCTIONS_DIR = "backend/functions";
+export declare const DEFAULT_CRONS_DIR = "backend/crons";
+export declare const DEFAULT_SCHEMA_FILE = "backend/src/schema.generated.ts";
+export interface ManifestValidationIssue {
+    /** Dotted path to the offending value, e.g. `apps.web.output`. */
+    path: string;
+    message: string;
+}
+export interface LoadedManifest {
+    manifest: RebaseProjectManifest;
+    /** Where it came from — a real file, or inferred from the directory layout. */
+    source: "file" | "synthesized";
+    /** Absolute path to `rebase.json`, when one exists. */
+    filePath?: string;
+}
+export declare class ManifestError extends Error {
+    readonly issues: ManifestValidationIssue[];
+    constructor(message: string, issues?: ManifestValidationIssue[]);
+}
+/**
+ * Validate a parsed manifest, collecting every problem.
+ */
+export declare function validateManifest(raw: unknown): {
+    manifest?: RebaseProjectManifest;
+    issues: ManifestValidationIssue[];
+};
+/**
+ * Infer a manifest from a directory that does not have one.
+ *
+ * This mirrors exactly what the template scaffolds, which is what makes adopting
+ * 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.
+ */
+export declare function synthesizeManifest(projectRoot: string): RebaseProjectManifest;
+export declare function manifestPath(projectRoot: string): string;
+export declare function manifestExists(projectRoot: string): boolean;
+/**
+ * Read the manifest, falling back to a synthesized one.
+ *
+ * A malformed manifest throws — unlike a missing one. Silently ignoring a file
+ * the developer wrote, and building something else instead, is the worst
+ * available behaviour.
+ */
+export declare function loadManifest(projectRoot: string): LoadedManifest;
+/** Write a manifest, with a trailing newline so it plays well with other tools. */
+export declare function writeManifest(projectRoot: string, manifest: RebaseProjectManifest): string;
+/** Find the single backend app, if this repository declares one. */
+export declare function findBackendApp(manifest: RebaseProjectManifest): {
+    name: string;
+    app: RebaseBackendAppConfig;
+} | undefined;
+/** Apps that produce build output, in the order they should be built. */
+export declare function buildableApps(manifest: RebaseProjectManifest): {
+    name: string;
+    app: RebaseAppConfig;
+}[];
+/**
+ * Decide whether a project can run on the managed runtime, and say why not.
+ *
+ * "Not eligible" is never a dead end — it selects the custom-runtime path, which
+ * still deploys. The reasons exist so the answer is actionable rather than a
+ * 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): {
+    config: string;
+    functions: string;
+    crons: string;
+    schema: string;
+    usersCollection: string;
+    mode: "cms" | "baas";
+};

package/dist/utils/package-manager.d.ts

@@ -19,14 +19,38 @@ export interface PMCommands {
     /** The workspace dependency protocol: `"workspace:*"` for pnpm, `"*"` for npm. */
     workspaceProtocol: string;
 }
+/**
+ * Decide availability from a `spawnSync` outcome.
+ *
+ * Split out from the spawn itself so the decision is testable without starting
+ * a process — which is what made the old test load-sensitive and occasionally
+ * red for reasons that had nothing to do with the code under test.
+ *
+ * The three outcomes are distinguishable, and the old code conflated two of
+ * them by asking only `status === 0`:
+ *
+ *   not installed   status null, signal null,    error.code ENOENT
+ *   timed out       status null, signal SIGTERM, error.code ETIMEDOUT
+ *   broken install  status non-zero, no error
+ */
+export declare function pnpmAvailabilityFromProbe(res: {
+    status: number | null;
+    signal?: NodeJS.Signals | null;
+    error?: {
+        code?: string;
+    } | Error;
+}): boolean;
 /**
  * Whether pnpm is runnable on this machine.
  *
  * Used to decide whether a fresh project can be scaffolded with pnpm. Kept
- * cheap and non-interactive (short timeout, output discarded) so it never
- * hangs detection if a corepack shim misbehaves.
+ * cheap and non-interactive (bounded timeout, output discarded) so it never
+ * hangs detection if a corepack shim misbehaves, and memoised so that repeated
+ * detection in one CLI run costs one process rather than one per call.
  */
 export declare function isPnpmAvailable(): boolean;
+/** Forget the memoised probe. For tests; nothing in a CLI run needs it. */
+export declare function resetPnpmAvailabilityCache(): void;
 /**
  * Detect the package manager for a Rebase project.
  *

package/dist/utils/project.d.ts

@@ -1,9 +1,17 @@
+/** The authored project manifest. Its presence alone marks a project root. */
+export declare const MANIFEST_FILENAME = "rebase.json";
 /**
  * Walk up from `startDir` to find the Rebase project root.
  *
- * The root is identified by a `package.json` that either:
- * - has `workspaces` containing "backend" or "frontend", OR
- * - has a sibling `backend/` directory
+ * A directory is the root when it holds a `rebase.json`, or when it holds a
+ * `package.json` that either lists `backend` as a workspace or sits beside both
+ * `backend/` and `config/`.
+ *
+ * `rebase.json` is checked first and needs no `package.json` beside it, because
+ * the conventions below all describe a repository that *contains the backend*.
+ * A repository holding only a frontend — the normal shape once a project's apps
+ * live in separate repositories — matches none of them, so without this the
+ * tooling could not run there at all.
  */
 export declare function findProjectRoot(startDir?: string): string | null;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/cli",
-  "version": "0.10.0",
+  "version": "0.10.1-canary.14e53ae",
   "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.10.0",
-    "@rebasepro/codegen": "0.10.0",
-    "@rebasepro/client": "0.10.0",
-    "@rebasepro/server-postgres": "0.10.0",
-    "@rebasepro/types": "0.10.0",
-    "@rebasepro/server": "0.10.0"
+    "@rebasepro/agent-skills": "0.10.1-canary.14e53ae",
+    "@rebasepro/client": "0.10.1-canary.14e53ae",
+    "@rebasepro/codegen": "0.10.1-canary.14e53ae",
+    "@rebasepro/server": "0.10.1-canary.14e53ae",
+    "@rebasepro/server-postgres": "0.10.1-canary.14e53ae",
+    "@rebasepro/types": "0.10.1-canary.14e53ae"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
@@ -48,6 +48,7 @@
   },
   "files": [
     "bin/",
+    "runtime/",
     "dist/",
     "templates/"
   ],

package/runtime/dev-server.mjs

@@ -0,0 +1,43 @@
+/**
+ * The development entrypoint.
+ *
+ * Run under `tsx` by `rebase dev` for projects that have no hand-written
+ * `backend/src/index.ts`. It boots the same runtime a deployment does, over the
+ * project's TypeScript **source** rather than a compiled bundle — so hot reload
+ * still works, and development still predicts production because both go through
+ * one boot path.
+ *
+ * Paths arrive in the environment rather than as arguments because `tsx watch`
+ * owns the argument list.
+ */
+import path from "node:path";
+import fs from "node:fs";
+import dotenv from "dotenv";
+
+const projectRoot = process.env.REBASE_DEV_PROJECT_ROOT || process.cwd();
+
+const envFile = process.env.DOTENV_CONFIG_PATH;
+if (envFile && fs.existsSync(envFile)) {
+    dotenv.config({ path: envFile });
+}
+
+const { createSourceBundle, runFromBundle } = await import("@rebasepro/server");
+
+const optional = (value) => (value && value.length > 0 ? value : undefined);
+
+const bundle = createSourceBundle({
+    projectRoot,
+    config: optional(process.env.REBASE_DEV_CONFIG),
+    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)
+});
+
+// The dev port file and the graceful-shutdown handlers both key off the project
+// root, so make sure the process agrees with the CLI about where that is.
+process.chdir(projectRoot);
+void path;
+
+await runFromBundle({ bundle });

package/templates/overlays/baas/backend/src/index.ts

@@ -122,6 +122,12 @@ pass: env.SMTP_PASS! }
                 }
                 : undefined
         },
+        // File storage is opt-in. With no bucket configured, storage is OFF in
+        // production — the upload routes answer 501 STORAGE_NOT_CONFIGURED —
+        // rather than writing to the container filesystem, which is erased on
+        // every restart and redeploy. Uploads that fail loudly are recoverable;
+        // uploads that succeed into a disk about to be wiped are not.
+        // Local disk stays the default in development, where it is what you want.
         storage: env.STORAGE_TYPE === "s3"
             ? {
                 type: "s3",
@@ -132,10 +138,21 @@ pass: env.SMTP_PASS! }
                 endpoint: env.S3_ENDPOINT,
                 forcePathStyle: env.S3_FORCE_PATH_STYLE
             }
-            : {
-                type: "local",
-                basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
-            },
+            : env.STORAGE_TYPE === "gcs"
+                ? {
+                    type: "gcs",
+                    bucket: env.GCS_BUCKET!,
+                    projectId: env.GCS_PROJECT_ID,
+                    keyFilename: env.GCS_KEY_FILENAME
+                }
+                // Set FORCE_LOCAL_STORAGE=true only if this deployment really
+                // does have a durable volume mounted at STORAGE_PATH.
+                : isProduction && !env.FORCE_LOCAL_STORAGE
+                    ? undefined
+                    : {
+                        type: "local",
+                        basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
+                    },
         history: true,
         enableSwagger: true
     });

package/templates/overlays/baas/rebase.json

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

package/templates/template/.env.example

@@ -80,12 +80,19 @@ VITE_API_URL=http://localhost:3001
 # ── Storage ───────────────────────────────────────────────────────────────────
 # Set STORAGE_TYPE to choose a storage backend. Default is "local" (filesystem).
 #
-# Supported values: local, s3
+# Supported values: local, s3, gcs
+#
+# In production, "local" means NO file storage: uploads answer
+# 501 STORAGE_NOT_CONFIGURED instead of landing on a container filesystem that
+# is erased on the next redeploy. Configure a bucket below to switch it on, or
+# set FORCE_LOCAL_STORAGE=true if a durable volume really is mounted at
+# STORAGE_PATH (the generated docker-compose.yml does exactly that).
 #
 # STORAGE_TYPE=local
 
 # --- Local filesystem (default — great for dev and single-server deployments) --
 # STORAGE_PATH=./uploads
+# FORCE_LOCAL_STORAGE=true      # Only with a durable volume mounted at STORAGE_PATH
 
 # --- S3-compatible (AWS S3, Cloudflare R2, MinIO, Hetzner Object Storage, Backblaze B2) ---
 # STORAGE_TYPE=s3
@@ -103,9 +110,15 @@ VITE_API_URL=http://localhost:3001
 # S3_ENDPOINT=https://storage.googleapis.com
 # S3_ACCESS_KEY_ID=GOOG...      # HMAC access key
 # S3_SECRET_ACCESS_KEY=...      # HMAC secret
+
+# --- Native GCS (Google Cloud Storage, Firebase Storage) ---
+# STORAGE_TYPE=gcs
+# GCS_BUCKET=my-gcs-bucket
+# GCS_PROJECT_ID=               # Optional — auto-detected from credentials
+# GCS_KEY_FILENAME=             # Omit on GCP: Workload Identity/ADC supplies credentials
 #
-# For native GCS SDK or other providers (Azure Blob, etc.), implement the
-# StorageController interface and pass it directly in your backend config.
+# For other providers (Azure Blob, etc.), implement the StorageController
+# interface and pass it directly in your backend config.
 
 # ── Backups (optional) ────────────────────────────────────────────────────────
 # Manual backups: `rebase db backup --out ./backups` (or an s3://… URL).

package/templates/template/README.md

@@ -4,57 +4,53 @@ A [Rebase](https://rebase.pro) project with a PostgreSQL backend.
 
 ## Quick Start
 
-### Option 1: Docker (recommended for production)
+`rebase init` already generated a `.env` for you with a real `JWT_SECRET`, a
+database password, and a free local database port. **Don't run
+`cp .env.example .env`** — that would overwrite those generated values.
+`.env.example` is a reference for the variables you can set, not a starting
+point for this project.
 
-```bash
-cp .env.example .env
-# Edit .env — set JWT_SECRET and DATABASE_URL (see comments for generators)
-
-docker compose up -d
-```
-
-That's it. Your app is running:
-- **Frontend**: http://localhost (port 80)
-- **Backend API**: http://localhost:3001
-- **PostgreSQL**: localhost:5432
-
-### Option 2: Local Development
-
-#### Prerequisites
+### Prerequisites
 
 - [Node.js](https://nodejs.org) >= 18
 - [pnpm](https://pnpm.io) or [npm](https://www.npmjs.com) (v7+)
-- A PostgreSQL database (you can start the included database container via `docker compose up -d db`)
+- [Docker](https://www.docker.com) (to run the included PostgreSQL container),
+  or your own PostgreSQL database
 
-#### Setup
+### Run it
 
-1. Install dependencies:
+1. Install dependencies (skip if `init` already did this):
 
 ```bash
 pnpm install   # or: npm install
 ```
 
-2. Configure environment:
+2. Start the PostgreSQL database container:
 
 ```bash
-cp .env.example .env
-# Edit .env — set DATABASE_URL, JWT_SECRET
+docker compose up -d db
 ```
 
-3. Generate schema and push to database:
+3. Create the database tables from your collections:
 
 ```bash
-pnpm run schema:generate   # or: npm run schema:generate
-pnpm run db:push            # or: npm run db:push
+pnpm run db:push   # or: npm run db:push
 ```
 
-4. Start the dev server:
+4. Start the dev servers:
 
 ```bash
 pnpm dev   # or: npm run dev
 ```
 
-Backend (Hono + PostgreSQL) on port 3001, frontend (Vite + React) on port 5173.
+Open **http://localhost:5173** — the admin panel. The first account you
+register becomes the admin. The backend API (Hono + PostgreSQL) runs on
+port 3001; the frontend (Vite + React) on port 5173.
+
+> The `db:push` step is what creates the tables for the example `posts`,
+> `authors`, and `tags` collections. Skip it and the admin panel still opens,
+> but those collections will be empty and their API calls will fail until the
+> tables exist.
 
 ## Project Structure
 
@@ -102,12 +98,21 @@ All configuration is managed through a single `.env` file in the project root. B
 - **Frontend**: Vite reads `VITE_*` variables via `envDir` pointing to the project root
 - **Scripts**: load via `dotenv` from the project root
 
-Copy `.env.example` to `.env` to get started. See the comments in `.env.example` for details on each variable.
+`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
 
+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.
+
 ```bash
-# Build and start
+# 1. 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
 
 # View logs
@@ -120,6 +125,11 @@ docker compose down
 docker compose down -v
 ```
 
+> `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
+> `cp .env.example .env`; that discards the values `init` generated.
+
 ## Documentation
 
 - [Rebase Docs](https://rebase.pro/docs)

package/templates/template/backend/src/index.ts

@@ -123,6 +123,12 @@ pass: env.SMTP_PASS! }
                 }
                 : undefined
         },
+        // File storage is opt-in. With no bucket configured, storage is OFF in
+        // production — the upload routes answer 501 STORAGE_NOT_CONFIGURED —
+        // rather than writing to the container filesystem, which is erased on
+        // every restart and redeploy. Uploads that fail loudly are recoverable;
+        // uploads that succeed into a disk about to be wiped are not.
+        // Local disk stays the default in development, where it is what you want.
         storage: env.STORAGE_TYPE === "s3"
             ? {
                 type: "s3",
@@ -133,10 +139,21 @@ pass: env.SMTP_PASS! }
                 endpoint: env.S3_ENDPOINT,
                 forcePathStyle: env.S3_FORCE_PATH_STYLE
             }
-            : {
-                type: "local",
-                basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
-            },
+            : env.STORAGE_TYPE === "gcs"
+                ? {
+                    type: "gcs",
+                    bucket: env.GCS_BUCKET!,
+                    projectId: env.GCS_PROJECT_ID,
+                    keyFilename: env.GCS_KEY_FILENAME
+                }
+                // Set FORCE_LOCAL_STORAGE=true only if this deployment really
+                // does have a durable volume mounted at STORAGE_PATH.
+                : isProduction && !env.FORCE_LOCAL_STORAGE
+                    ? undefined
+                    : {
+                        type: "local",
+                        basePath: env.STORAGE_PATH || path.resolve(__dirname, "../../uploads")
+                    },
         history: true
     });
 

package/templates/template/gitignore

@@ -29,3 +29,7 @@ uploads/
 # Rebase dev
 .rebase-dev-url
 .rebase-dev-port
+
+# Built project bundle (`rebase build`)
+dist-bundle/
+.rebase/

package/templates/template/rebase.json

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