@rebasepro/cli 0.10.1-canary.d8d45b2 → 0.10.1-canary.ed78a2c

package/dist/bundle.d.ts

@@ -80,6 +80,27 @@ export declare function normalizeEsmSpecifiers(outDir: string): {
     rewritten: number;
     unresolved: string[];
 };
+/**
+ * A hand-written server entrypoint that a bundle does not use.
+ *
+ * `rebase dev` runs `backend/src/index.ts` whenever a project has one, so for
+ * the whole of local development that file *is* the server and every route
+ * written in it works. A bundle has no entrypoint of its own: the runtime boots
+ * the bundle and mounts what the manifest points at — the config package,
+ * functions, crons and the schema. The file is not compiled, not shipped, and
+ * never imported.
+ *
+ * Nothing said so. A project with custom routes in its entrypoint built clean,
+ * 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.
+ */
+export declare function findUnusedServerEntry(projectRoot: string, functionsDir: string): string | undefined;
 /**
  * Compile and assemble a bundle.
  */
@@ -98,6 +119,41 @@ export declare function buildBundle(options: BuildBundleOptions): Promise<BuildB
  * manifest — no compilation, no dependency closure (a static bundle installs
  * nothing at boot).
  */
+/**
+ * Fold a built static app into a backend bundle, so one runtime serves both.
+ *
+ * ## Why this exists
+ *
+ * A managed tenant runs one pod, and `bootFromBundle` on the backend path already
+ * knows how to serve a SPA — it looks for `entry.static` and mounts `serveSPA`
+ * last, behind `REBASE_SERVE_STATIC`. What was missing was anything putting the
+ * assets there.
+ *
+ * The consequence was not subtle. A project whose custom image served its website
+ * at `/` and its API at `/api` — the shape the scaffolded template produces — lost
+ * the website the moment it moved to the managed runtime: the API answered
+ * perfectly and every page 404'd. Managed could not be a drop-in replacement for
+ * custom while the frontend simply vanished.
+ *
+ * Folding restores parity with the container it replaces, which is the only
+ * honest baseline. It is deliberately the FIRST implementation and not the last:
+ * a static app on its own bucket behind a CDN is better for cache behaviour and
+ * lets the frontend deploy independently. But that needs infrastructure that does
+ * not exist yet, and "your site is gone" is not an acceptable state to leave a
+ * project in while it gets built.
+ *
+ * The trade it makes, stated plainly: frontend and backend now deploy together
+ * and the bundle carries the built assets. For a project that was shipping both
+ * in one image already, that is exactly what it had.
+ */
+export declare function foldStaticIntoBundle(options: {
+    /** The backend bundle directory, already written. */
+    bundleDir: string;
+    /** Directory of built frontend assets (the static app's `output`). */
+    assetsDir: string;
+}): {
+    fileCount: number;
+};
 export declare function buildStaticBundle(options: {
     projectRoot: string;
     appName: string;

package/dist/commands/cloud/bundle-deploy.d.ts

@@ -23,6 +23,31 @@ export declare function bundleDeployBody(input: {
     manifest: RebaseBundleManifest;
     app?: string;
     message?: string;
+    /**
+     * Every app this repository declares in `rebase.json`, so the platform can
+     * register the whole set rather than only the one being deployed.
+     */
+    declaredApps?: DeclaredApp[];
 }): Record<string, unknown>;
+/** An app as `rebase.json` declares it, reduced to what the registry stores. */
+export interface DeclaredApp {
+    name: string;
+    type: string;
+}
+/**
+ * The apps a project manifest declares.
+ *
+ * A deploy only ever ships ONE app's bundle, so the trigger alone could never
+ * tell the platform that the repository also contains a web frontend and an
+ * admin panel — and the Apps page, whose whole job is to show the set, listed a
+ * single entry called "backend". Sending the declared set fixes that without
+ * pretending the others are deployed: the platform registers them, and their
+ * status says what is actually true.
+ */
+export declare function declaredAppsFrom(manifest: {
+    apps?: Record<string, {
+        type?: string;
+    }>;
+} | null | undefined): DeclaredApp[];
 /** Upload a bundle archive; returns the control-plane bundle id. */
 export declare function uploadBundle(url: string, token: string, projectId: string, tarPath: string): Promise<string>;

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

@@ -1,2 +1,50 @@
+/** A project row, reduced to what says how it deploys (camel or snake columns). */
+export interface DeployProjectRow {
+    runtimeMode?: string;
+    runtime_mode?: string;
+    gitRepoUrl?: string;
+    git_repo_url?: string;
+    gitBranch?: string;
+    git_branch?: string;
+}
+/** A deployment row, reduced to what says what it was built from. */
+export interface DeploySourceRow {
+    id?: string | number;
+    status?: string;
+    createdAt?: string | Date;
+    created_at?: string | Date;
+    sourceRef?: string;
+    source_ref?: string;
+    bundleId?: string;
+    bundle_id?: string;
+}
+export interface BareDeployPlan {
+    /**
+     * Whether the project runs the platform runtime — in which case any source
+     * build here ejects it back onto a container image.
+     */
+    managed: boolean;
+    /**
+     * `git` — the control plane will clone the configured repository.
+     * `snapshot` — it will rebuild the newest uploaded source archive.
+     * `none` — it holds neither, and will refuse.
+     */
+    source: "git" | "snapshot" | "none";
+    /** Lines describing the build, printed before it is triggered. */
+    lines: string[];
+}
+/** Rough age of a timestamp, for "…uploaded 6d ago". Undefined if unreadable. */
+export declare function timeAgo(value: string | Date | undefined, now: Date): string | undefined;
+/**
+ * Whether this project runs on the managed runtime.
+ *
+ * `runtimeMode` on the project row is the authority — the control plane writes
+ * it. The bundle-id fallback covers a control plane that does not return the
+ * field: a successful deploy that served a bundle only happens on the managed
+ * path.
+ */
+export declare function isManagedProject(project: DeployProjectRow | undefined, latest: DeploySourceRow | undefined): boolean;
+/** What a `deploy` with nothing attached will build, in the words to print. */
+export declare function planBareDeploy(project: DeployProjectRow | undefined, latest: DeploySourceRow | undefined, now: Date): BareDeployPlan;
 export declare function deployCommand(rawArgs: string[], projectRef: string): Promise<void>;
 export declare function logsCommand(rawArgs: string[], projectRef: string): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -23,6 +23,19 @@ interface GenerateSDKArgs {
     token?: string;
     help?: boolean;
 }
+/**
+ * The base URL to show in the printed usage example.
+ *
+ * `rebase dev` binds a port derived from the project path, not 3001, and writes
+ * the one it actually got to `.rebase/state.json`. Printing a hardcoded
+ * `localhost:3001` sent people to a port nothing was listening on — or, with
+ * several projects on one machine, to a different project's backend. Prefer the
+ * port this project last ran on; fall back to the literal only when the project
+ * has never been started.
+ */
+export declare function resolveExampleBaseUrl(cwd: string): string;
+/** Whether a slug can be written as `rebase.data.<slug>` rather than a lookup. */
+export declare function isIdentifierLike(slug: string): boolean;
 /**
  * Main entry point for the generate-sdk command.
  */

package/dist/fold-static.d.ts

@@ -0,0 +1,46 @@
+/** The apps section of a project manifest, as much of it as folding needs. */
+export interface FoldableManifest {
+    apps?: Record<string, {
+        type?: string;
+        build?: string;
+        output?: string;
+    }>;
+}
+export interface FoldOptions {
+    projectRoot: string;
+    manifest: FoldableManifest;
+    /** The backend bundle directory, already written. */
+    bundleDir: string;
+    /** Skip running the app's own build command; fold what is already built. */
+    skipBuild?: boolean;
+    log?: (message: string) => void;
+}
+export interface FoldOutcome {
+    appName: string;
+    fileCount: number;
+}
+/**
+ * Which static app, if any, should be served by the backend.
+ *
+ * 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.
+ */
+export declare function selectFoldableApp(manifest: FoldableManifest): {
+    app?: {
+        name: string;
+        build?: string;
+        output?: string;
+    };
+    /** Why nothing will be folded, when that is the answer. */
+    reason?: string;
+};
+/**
+ * Build the project's frontend and fold it 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>;