@rebasepro/cli 0.0.1-canary.f81da60 → 0.0.1-canary.fc811d7

package/LICENSE

@@ -1,201 +1,22 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+MIT License
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+Copyright (c) 2026 Rebase
 
-   1. Definitions.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
 
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/README.md

@@ -1,54 +1,78 @@
-## Rebase CLI
+# @rebasepro/cli
 
-This CLI tool allows you to create new Rebase projects and to deploy them to Rebase Cloud.
-**IMPORTANT**: You should not be using this tool directly, but `rebase` instead.
+Developer CLI for scaffolding, running, and managing Rebase projects.
 
-### CLI
-
-You can use the following commands:
-
-```bash
-rebase login
-```
+## Installation
 
 ```bash
-rebase init
+pnpm add -g @rebasepro/cli
 ```
 
-```bash
-rebase deploy
-```
+The CLI is also bundled with every Rebase project as a local dependency.
 
-### Using different templates
+## Commands
 
-You can initialize a new project using different templates. Please not that these templates can't
-be deployed to Rebase Cloud. For example:
+| Command | Description |
+|---------|-------------|
+| `rebase init` | Scaffold a new Rebase project |
+| `rebase dev` | Start the development server (backend + frontend) |
+| `rebase build` | Build all workspace packages |
+| `rebase start` | Start the backend server (production) |
+| `rebase schema generate` | Generate Drizzle schema from collection definitions |
+| `rebase schema introspect` | Introspect an existing database → Rebase collections |
+| `rebase db push` | Apply schema directly to database (dev) |
+| `rebase db generate` | Generate SQL migration files |
+| `rebase db migrate` | Run pending migrations |
+| `rebase generate-sdk` | Generate a typed TypeScript SDK from collections |
+| `rebase auth reset-password` | Reset a user's password |
+| `rebase doctor` | Detect schema drift between collections, Drizzle schema, and database |
+| `rebase cloud <command>` | Manage your apps on Rebase Cloud (auth, deploy, databases, …) |
 
-For Rebase Cloud
+Run `rebase --help` or `rebase <command> --help` for detailed usage.
 
-```bash
-rebase init
-```
+## Rebase Cloud
 
-For Rebase PRO:
+`rebase cloud` talks to the hosted control plane (default `https://app.rebase.pro`,
+override with `--url` or `REBASE_CLOUD_URL`). Sign in once — credentials are stored
+in `~/.rebase/credentials.json`, keyed per host — then link a directory to a project
+so deploy/logs/status need no flags.
 
 ```bash
-rebase init --pro
+rebase cloud login                 # sign in (stores a session)
+rebase cloud link                  # pick a project → writes .rebase/cloud.json
+rebase cloud deploy                # deploy the linked project + stream build logs
+rebase cloud logs --runtime        # tail runtime logs
+rebase cloud status                # project status at a glance
 ```
 
-#### To run locally
+| Group | Commands |
+|-------|----------|
+| Auth | `login`, `logout`, `whoami` |
+| Link/context | `link`, `unlink`, `use [org]`, `open` |
+| Projects | `projects list \| create \| info \| delete` |
+| Deploy/observe | `deploy`, `logs [--runtime] [-f]`, `status`, `metrics` |
+| Organizations | `orgs list \| create \| members` |
+| Databases | `db list \| create \| test`, `db backup list \| create \| restore` |
+| Resources | `webhooks list \| create \| delete`, `storage`, `clusters`, `billing [checkout]` |
+
+Most commands act on the linked project unless you pass `--project <id>`.
+Run `rebase cloud --help` for the full list.
 
-For development purposes, you can link the package locally.
+## Quick Start
 
 ```bash
-npm link rebase
+rebase init my-app
+cd my-app
+docker compose up -d db
+pnpm run db:push
+pnpm run dev
 ```
 
-### Development only
+## Related Packages
 
-You can change the environment when deploying to Rebase Cloud by defining the --env variable.
-Possible values are `prod` (default) and `dev`.
-
-```bash
-rebase deploy --env dev
-```
+| Package | Role |
+|---------|------|
+| `@rebasepro/server` | Backend framework used by `dev` and `start` |
+| `@rebasepro/server-postgres` | PostgreSQL driver used by schema/db commands |
+| `@rebasepro/codegen` | Powers `generate-sdk` |
+| `@rebasepro/types` | Shared type definitions |

package/dist/commands/api-keys.d.ts

@@ -0,0 +1 @@
+export declare function apiKeysCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;

package/dist/commands/build.d.ts

@@ -0,0 +1 @@
+export declare function buildCommand(): Promise<void>;

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

@@ -0,0 +1,3 @@
+export declare function loginCommand(rawArgs: string[]): Promise<void>;
+export declare function logoutCommand(rawArgs: string[]): Promise<void>;
+export declare function whoamiCommand(rawArgs: string[]): Promise<void>;

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

@@ -0,0 +1,61 @@
+import { createRebaseClient } from "@rebasepro/client";
+/** Default hosted control plane (the Rebase Cloud console origin). */
+export declare const DEFAULT_CLOUD_URL = "https://app.rebase.pro";
+/** Project-local link file: <project>/.rebase/cloud.json */
+export declare function projectLinkPath(cwd?: string): string;
+/** Host that a bare `rebase cloud` command should target, if any. */
+export declare function currentContextUrl(): string | undefined;
+/** Persist the active organization id for a host. */
+export declare function setContextOrg(url: string, org: string | undefined): void;
+export declare function getContextOrg(url: string): string | undefined;
+/** Mark a host as the active context (called on login). */
+export declare function setCurrentContext(url: string): void;
+export declare function resolveCloudUrl(rawArgs: string[]): string;
+export type CloudClient = ReturnType<typeof createRebaseClient>;
+/**
+ * Build an SDK client bound to a control-plane host, backed by the on-disk
+ * credential store. `autoRefresh` is disabled so we never leave a dangling
+ * setTimeout that keeps the CLI process alive; token refresh is done on demand
+ * by `requireClient`.
+ */
+export declare function createCloudClient(url: string): CloudClient;
+/**
+ * Return an authenticated client for the resolved host, refreshing the access
+ * token if it is close to expiry. Exits with a helpful message when there is no
+ * usable session (never logged in, or the refresh token was revoked).
+ */
+export declare function requireClient(rawArgs: string[]): Promise<{
+    client: CloudClient;
+    url: string;
+}>;
+export interface ProjectLink {
+    url: string;
+    projectId: string;
+    projectName?: string;
+    orgId?: string;
+}
+export declare function readLink(cwd?: string): ProjectLink | null;
+export declare function writeLink(link: ProjectLink, cwd?: string): void;
+export declare function removeLink(cwd?: string): boolean;
+/**
+ * Resolve the project id to operate on: explicit `--project` flag wins,
+ * otherwise the linked project. Exits with guidance when neither is present.
+ */
+export declare function requireProjectId(rawArgs: string[]): string;
+/** Print an error (+ optional hint) and exit non-zero. Never returns. */
+export declare function fail(message: string, hint?: string): never;
+export declare function success(message: string): void;
+/** Colorize a deployment / resource status token. */
+export declare function colorStatus(status: string | undefined): string;
+/** Render a two-column key/value block with aligned keys. */
+export declare function keyValues(rows: Array<[string, string | undefined]>): void;
+/**
+ * Surface an SDK/HTTP error consistently. The SDK throws RebaseApiError with
+ * a `.status` and `.message`; anything else falls back to its string form.
+ */
+export declare function reportError(e: unknown, context: string): never;
+/**
+ * Open a URL in the user's default browser (best effort). Always prints the URL
+ * first so it stays usable over SSH or when no browser is available.
+ */
+export declare function openUrl(target: string, label?: string): void;

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

@@ -0,0 +1 @@
+export declare function dbCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;

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

@@ -0,0 +1,2 @@
+export declare function deployCommand(rawArgs: string[], projectId: string): Promise<void>;
+export declare function logsCommand(rawArgs: string[], projectId: string): Promise<void>;

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

@@ -0,0 +1 @@
+export declare function cloudCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;

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

@@ -0,0 +1,5 @@
+export declare function linkCommand(rawArgs: string[]): Promise<void>;
+export declare function unlinkCommand(): void;
+export declare function selectOrgCommand(rawArgs: string[]): Promise<void>;
+/** Open the Rebase Cloud dashboard (or the linked project) in a browser. */
+export declare function openCommand(rawArgs: string[]): void;

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

@@ -0,0 +1 @@
+export declare function orgsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;

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

@@ -0,0 +1,13 @@
+import { type CloudClient } from "./context";
+export declare function listProjects(rawArgs: string[]): Promise<void>;
+export declare function createProject(rawArgs: string[]): Promise<void>;
+export declare function projectInfo(rawArgs: string[], projectId: string): Promise<void>;
+export declare function deleteProject(rawArgs: string[], projectId: string): Promise<void>;
+export declare function firstRow(client: CloudClient, collection: string, projectId: string): Promise<Record<string, unknown> | undefined>;
+export declare function latestDeployment(client: CloudClient, projectId: string): Promise<{
+    id: string | number;
+    status?: string;
+    createdAt?: string;
+    logs?: string;
+} | undefined>;
+export declare function fmtDate(value: string | undefined): string;

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

@@ -0,0 +1,6 @@
+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>;
+export declare function storageCommand(rawArgs: string[]): Promise<void>;
+export declare function clustersCommand(rawArgs: string[]): Promise<void>;
+export declare function billingCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -2,7 +2,7 @@
  * CLI command: generate-sdk
  *
  * Reads collection definitions from a specified directory (default: ./config/collections),
- * generates a typed JS SDK, and writes it to the output directory (default: ./generated/sdk).
+ * generates a typed TypeScript SDK, and writes it to the output directory (default: ./generated/sdk).
  *
  * Uses jiti for dynamic TypeScript import of collection files.
  */

package/dist/commands/init.d.ts

@@ -1,3 +1,17 @@
+import type { PackageManager, PMCommands } from "../utils/package-manager";
+export type TemplatePreset = "blog" | "ecommerce" | "blank";
+/**
+ * How much of Rebase to scaffold.
+ *
+ * `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.
+ */
+export type TemplateFlavor = "cms" | "baas";
 export interface InitOptions {
     projectName: string;
     git: boolean;
@@ -6,6 +20,28 @@ export interface InitOptions {
     templateDirectory: string;
     databaseUrl?: string;
     introspect?: boolean;
+    /** Starter template preset. */
+    preset: TemplatePreset;
+    /** Which parts of Rebase to scaffold. */
+    flavor: TemplateFlavor;
+    /** Detected package manager (pnpm or npm). */
+    pm: PackageManager;
+    /** Command helpers for the detected PM. */
+    pmCommands: PMCommands;
 }
+export interface BuildQuestionsParams {
+    nameArg?: string;
+    templateArg?: TemplatePreset;
+    flavorArg?: TemplateFlavor;
+    hasGitFlag: boolean;
+    hasInstallFlag: boolean;
+    pm: PackageManager;
+}
+/**
+ * Builds the interactive prompt questions for `rebase init`.
+ * Exported for testability — all prompt `type` values must match
+ * types registered by the installed version of inquirer.
+ */
+export declare function buildInitQuestions(params: BuildQuestionsParams): Record<string, unknown>[];
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
-export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): void;
+export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): Promise<void>;

package/dist/commands/skills.d.ts

@@ -0,0 +1 @@
+export declare function skillsCommand(subcommand: string | undefined, _args: string[]): Promise<void>;

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(): Promise<void>;

package/dist/index.d.ts

@@ -3,6 +3,11 @@ export * from "./commands/init";
 export * from "./commands/schema";
 export * from "./commands/db";
 export * from "./commands/dev";
+export * from "./commands/build";
+export * from "./commands/start";
 export * from "./commands/auth";
-export * from "./auth";
+export * from "./commands/doctor";
+export * from "./commands/generate_sdk";
+export * from "./commands/cloud";
 export * from "./utils/project";
+export * from "./utils/package-manager";