@rebasepro/cli 0.11.0 → 0.11.1-canary.g8caabf3

package/bin/rebase.js

@@ -65,6 +65,27 @@ try {
     /* ignore */
 }
 
+/**
+ * `dist/` is gitignored, so in a fresh clone it does not exist until someone
+ * runs a build — and `rebase` is reached long before that: CONTRIBUTING's
+ * getting-started steps call `db push` and `dev` through it. Importing a
+ * missing module raises a bare ERR_MODULE_NOT_FOUND stack trace naming an
+ * internal path, which reads as a broken repository rather than a missing step.
+ *
+ * stderr, like the staleness warning above, so `--json` output stays parseable.
+ */
+if (!existsSync(distEntry)) {
+    const dev = existsSync(srcDir);
+    process.stderr.write(
+        `\x1b[31m✗ rebase CLI: not built yet — ${distEntry} is missing.\x1b[0m\n` +
+        (dev
+            ? "  Build it with: pnpm --filter @rebasepro/cli build\n" +
+              "  (or `pnpm build` from the repo root to build every package)\n"
+            : "  This install looks incomplete; try reinstalling @rebasepro/cli.\n")
+    );
+    process.exit(1);
+}
+
 const { entry } = await import("../dist/index.es.js");
 
 entry(process.argv);

package/dist/bundle.d.ts

@@ -94,11 +94,10 @@ export declare function normalizeEsmSpecifiers(outDir: string): {
  * deployed green, and answered 404 on every one of them, with the file still
  * sitting in the repository looking exactly like the server.
  *
- * A project that means to keep its own entrypoint declares the app as
- * `"type": "custom"`, which builds the repository's Dockerfile instead — which
- * is what {@link synthesizeManifest} already infers for a manifest-less repo
- * carrying one. The warning names that route rather than implying the file is
- * a mistake.
+ * A project that means to keep its own entrypoint runs `rebase eject`, which
+ * writes the entrypoint, a Dockerfile and a compose file together and flips the
+ * backend to `runtime: "custom"`. The warning names that route rather than
+ * implying the file is a mistake.
  */
 export declare function findUnusedServerEntry(projectRoot: string, functionsDir: string): string | undefined;
 /**
@@ -151,8 +150,15 @@ export declare function foldStaticIntoBundle(options: {
     bundleDir: string;
     /** Directory of built frontend assets (the static app's `output`). */
     assetsDir: string;
+    /** The app's name in `rebase.json`. Names its directory inside the bundle. */
+    appName: string;
+    /** Public base path this app is served under. */
+    path: string;
+    /** Serve `index.html` for unmatched paths under `path`. */
+    spa: boolean;
 }): {
     fileCount: number;
+    dir: string;
 };
 export declare function buildStaticBundle(options: {
     projectRoot: string;
@@ -160,6 +166,10 @@ export declare function buildStaticBundle(options: {
     assetsDir: string;
     outDir: string;
     runtimeRange: string;
+    /** Public base path. Default `/` — a standalone bundle owns its origin. */
+    path?: string;
+    /** Serve `index.html` for unmatched paths. Default `true`. */
+    spa?: boolean;
 }): {
     outDir: string;
     manifest: RebaseBundleManifest;

package/dist/commands/cloud/resources.d.ts

@@ -35,6 +35,26 @@ export declare function describeStorageState(state: StorageState | undefined): s
  * type; the verdict appears once there is one.
  */
 export declare function describeDatabaseState(db: Record<string, unknown> | undefined): string | undefined;
+/**
+ * One line describing what engine is serving this project.
+ *
+ * Three numbers are in play and they are easy to conflate — I have watched it
+ * happen. The **runtime version** (`1.2.0`) is the contract line a bundle's
+ * range resolves against; its major IS the contract major. The **framework
+ * version** (`0.11.0`) is the `@rebasepro` release the runtime image ships. They
+ * move independently on purpose: tying the contract line to the framework would
+ * make `^1` become `^0.11`, and pre-1.0 caret is restrictive, so every framework
+ * minor would fall outside every project's range and force a rebuild to receive
+ * an engine upgrade — the opposite of what the bundle/runtime split is for.
+ *
+ * So both are printed, rather than leaving anyone to infer one from a Docker tag.
+ */
+export declare function describeRuntime(project: {
+    runtimeMode?: string | null;
+    runtimeVersion?: string | null;
+    runtimeFrameworkVersion?: string | null;
+    runtimeVersionPin?: string | null;
+}): string;
 export declare function statusCommand(rawArgs: string[]): Promise<void>;
 export declare function metricsCommand(rawArgs: string[]): Promise<void>;
 export declare function webhooksCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;

package/dist/commands/eject.d.ts

@@ -0,0 +1 @@
+export declare function ejectCommand(rawArgs?: string[]): Promise<void>;

package/dist/commands/init.d.ts

@@ -1,19 +1,23 @@
 import type { PackageManager, PMCommands } from "../utils/package-manager";
-/** Returns an error message, or null when the name is a valid package name. */
-export declare function validateProjectName(name: string): string | null;
-export type TemplatePreset = "blog" | "ecommerce" | "blank";
 /**
- * How much of Rebase to scaffold.
+ * Every scaffolded file that carries a `{{PLACEHOLDER}}`.
  *
- * `cms` is the full triad (config + backend + frontend). `baas` is the backend
- * alone, serving the database over REST with no collection files and no UI.
- */
-/**
- * `cms` scaffolds BaaS + the admin UI; `baas` scaffolds the API alone. The
- * values match `RebaseBackendConfig.mode`, which is what the generated backend
- * sets — the labels below are what users actually read.
+ * Exported because it is the single source of truth: `init.test.ts` reads it and
+ * asserts that every template file containing `{{` appears here. It used to be a
+ * local, with the test harness keeping a *second* copy — so the two drifted, and
+ * a test built on the copy could not observe the production list at all.
+ *
+ * The drift shipped: `docker-compose.yml` arrived with the self-host work
+ * (26fd5259c) and was added to neither, so every scaffolded project got a literal
+ * `name: {{PROJECT_NAME}}`. In YAML `{{...}}` is a map, not a string, so the
+ * documented `docker compose up` path failed on the file before doing anything:
+ *
+ *   yaml: unmarshal errors: line 28: cannot unmarshal !!map into string
  */
-export type TemplateFlavor = "cms" | "baas";
+export declare const TEMPLATE_PLACEHOLDER_FILES: string[];
+/** Returns an error message, or null when the name is a valid package name. */
+export declare function validateProjectName(name: string): string | null;
+export type TemplatePreset = "blog" | "ecommerce" | "blank";
 export interface InitOptions {
     projectName: string;
     git: boolean;
@@ -26,8 +30,8 @@ export interface InitOptions {
     preset: TemplatePreset;
     /** Whether `preset` came from an explicit --template rather than the default. */
     explicitPreset?: boolean;
-    /** Which parts of Rebase to scaffold. */
-    flavor: TemplateFlavor;
+    /** Scaffold the backend alone, with no admin panel and no collections. */
+    headless: boolean;
     /** Detected package manager (pnpm or npm). */
     pm: PackageManager;
     /** Command helpers for the detected PM. */
@@ -42,7 +46,7 @@ export interface InitOptions {
 export interface BuildQuestionsParams {
     nameArg?: string;
     templateArg?: TemplatePreset;
-    flavorArg?: TemplateFlavor;
+    headlessArg?: boolean;
     hasGitFlag: boolean;
     hasInstallFlag: boolean;
     pm: PackageManager;

package/dist/fold-static.d.ts

@@ -4,6 +4,8 @@ export interface FoldableManifest {
         type?: string;
         build?: string;
         output?: string;
+        path?: string;
+        spa?: boolean;
     }>;
 }
 export interface FoldOptions {
@@ -11,36 +13,60 @@ export interface FoldOptions {
     manifest: FoldableManifest;
     /** The backend bundle directory, already written. */
     bundleDir: string;
-    /** Skip running the app's own build command; fold what is already built. */
+    /** Skip running each app's own build command; fold what is already built. */
     skipBuild?: boolean;
     log?: (message: string) => void;
 }
 export interface FoldOutcome {
     appName: string;
     fileCount: number;
+    /** Public base path this app was folded in at. */
+    path: string;
+}
+/** A static app as folding sees it, with the manifest's defaults applied. */
+export interface FoldableApp {
+    name: string;
+    build?: string;
+    output?: string;
+    /** Public base path, defaulted to `/`. */
+    path: string;
+    /** SPA fallback, defaulted to `true`. */
+    spa: boolean;
 }
 /**
- * Which static app, if any, should be served by the backend.
+ * Every static app in the manifest, in mount order.
  *
- * Exactly one `static` app is folded. With several, folding would have to choose,
- * and silently picking one of two websites is worse than doing nothing — so it
- * declines and names what it saw. Pure, so the decision is testable without a
- * filesystem.
+ * Longest path first, so the `/`-rooted app is registered last — its catch-all
+ * would otherwise claim its siblings' URLs. Pure, so the ordering is testable
+ * without a filesystem.
  */
-export declare function selectFoldableApp(manifest: FoldableManifest): {
-    app?: {
+export declare function foldableApps(manifest: FoldableManifest): {
+    apps: FoldableApp[];
+    /** Apps that cannot be folded, and why. */
+    skipped: {
         name: string;
-        build?: string;
-        output?: string;
-    };
-    /** Why nothing will be folded, when that is the answer. */
-    reason?: string;
+        reason: string;
+    }[];
 };
 /**
- * Build the project's frontend and fold it into the backend bundle.
+ * Assert a built app's assets are actually rooted at the path it is served from.
+ *
+ * An app mounted at `/admin` but built with Vite's default `base: "/"` emits
+ * `<script src="/assets/index-a1b2.js">`. The server serves `index.html` fine
+ * and 404s every asset: a blank page, no server error, nothing in the logs. It
+ * is the single most expensive silent failure in this design, so it is a build
+ * error rather than a runtime surprise.
+ *
+ * Only `<script src>` and `<link href>` are inspected — those are what a bundler
+ * rewrites through `base`. Author-written anchors and canonical URLs are not
+ * evidence of a misbuild.
+ */
+export declare function assertBuiltForPath(indexHtml: string, basePath: string, appName: string): void;
+/**
+ * Build the project's static apps and fold them into the backend bundle.
  *
  * Throws rather than exiting, so the caller decides whether a missing frontend
  * should fail its command — a `build` may reasonably want to stop, and so should
  * a deploy, but that is not this function's call to make.
  */
-export declare function foldFrontendIntoBundle(options: FoldOptions): Promise<FoldOutcome | null>;
+export declare function foldFrontendIntoBundle(options: FoldOptions): Promise<FoldOutcome[]>;

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from "./commands/schema";
 export * from "./commands/db";
 export * from "./commands/dev";
 export * from "./commands/build";
+export * from "./commands/eject";
 export * from "./commands/start";
 export * from "./commands/auth";
 export * from "./commands/doctor";