@rebasepro/cli 0.9.0 → 0.9.1-canary.0de22e0

package/README.md

@@ -26,9 +26,38 @@ The CLI is also bundled with every Rebase project as a local dependency.
 | `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, …) |
 
 Run `rebase --help` or `rebase <command> --help` for detailed usage.
 
+## Rebase Cloud
+
+`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 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
+```
+
+| 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.
+
 ## Quick Start
 
 ```bash
@@ -43,7 +72,7 @@ pnpm run dev
 
 | Package | Role |
 |---------|------|
-| `@rebasepro/server-core` | Backend framework used by `dev` and `start` |
-| `@rebasepro/server-postgresql` | PostgreSQL driver used by schema/db commands |
-| `@rebasepro/sdk-generator` | Powers `generate-sdk` |
+| `@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/bin/rebase.js

@@ -1,4 +1,70 @@
 #!/usr/bin/env node
-import { entry } from "../dist/index.es.js";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const distEntry = join(here, "..", "dist", "index.es.js");
+const srcDir = join(here, "..", "src");
+
+/**
+ * Warn when the built CLI is older than the source it was built from.
+ *
+ * `rebase` runs `dist/`, and a global install of this package is usually a
+ * symlink to a working checkout — so every agent and shell on the machine runs
+ * whatever was last built, not what is in the code. A stale build is invisible:
+ * the command works, it just silently lacks the subcommand you added, which
+ * reads as "my change did nothing" rather than "you forgot to build".
+ *
+ * Development-only by construction: `src/` is not in the published `files`
+ * list, so this is skipped entirely for installed copies.
+ *
+ * Writes to **stderr**. Agents parse stdout as JSON under `--json`, and a
+ * warning there would corrupt the one guarantee those commands make.
+ */
+function newestMtimeMs(dir, deadline) {
+    let newest = 0;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (Date.now() > deadline) break; // never let a warning cost real time
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            newest = Math.max(newest, newestMtimeMs(full, deadline));
+        } else if (/\.tsx?$/.test(entry.name) && !/\.(test|spec)\.tsx?$/.test(entry.name)) {
+            // Tests are not bundled, so editing one does not make dist stale.
+            // Counting them cried wolf on the ordinary edit-test-run loop.
+            newest = Math.max(newest, statSync(full).mtimeMs);
+        }
+    }
+    return newest;
+}
+
+function warnIfStale() {
+    if (!existsSync(srcDir) || !existsSync(distEntry)) return;
+    const builtAt = statSync(distEntry).mtimeMs;
+    const editedAt = newestMtimeMs(srcDir, Date.now() + 150);
+    // A couple of seconds of slack: a build writes dist while src is being
+    // stat'd, and a sub-second delta is that race, not a stale build.
+    const staleByMs = editedAt - builtAt;
+    if (staleByMs <= 2000) return;
+
+    const seconds = Math.round(staleByMs / 1000);
+    const ago = seconds >= 3600
+        ? `${Math.round(seconds / 3600)}h`
+        : seconds >= 60 ? `${Math.round(seconds / 60)}m` : `${seconds}s`;
+    process.stderr.write(
+        `⚠ rebase CLI: dist/ is ${ago} older than src/ — you are running a stale build.\n` +
+        `  Rebuild with: (cd ${join(here, "..")} && npm run build)\n`
+    );
+}
+
+// A broken staleness check must never stop the CLI from running.
+try {
+    warnIfStale();
+} catch {
+    /* ignore */
+}
+
+const { entry } = await import("../dist/index.es.js");
 
 entry(process.argv);

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,151 @@
+import { createRebaseClient } from "@rebasepro/client";
+/** Project-local link file: <project>/.rebase/cloud.json */
+export declare function projectLinkPath(cwd?: string): string;
+/** 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 declare function fetchTenantBaseDomain(client: CloudClient, url: string): Promise<string | undefined>;
+/**
+ * Public host for a project — `<subdomain>.<base>`, or the bare subdomain when
+ * the base domain is unknown.
+ *
+ * It deliberately never falls back to a guessed domain. The user copies this
+ * string into a browser, so a plausible-but-wrong hostname is worse than an
+ * obviously incomplete one: `acme.rebase.pro` looks reachable and isn't, while
+ * `acme` reads as "the subdomain is acme" and prompts no wasted debugging.
+ */
+export declare function formatTenantHost(subdomain: string | undefined, baseDomain: string | undefined): string | undefined;
+/** The fields of a project row this module needs to render a host. */
+export interface HostableProject {
+    subdomain?: string;
+    /** Resolved server-side; absent on control planes older than the host hook. */
+    host?: string;
+}
+/**
+ * The host to display for a project.
+ *
+ * Prefers `host` off the record: the control plane resolves it through the same
+ * `tenantHost()` the ingress uses, so it accounts for the project's *cluster*
+ * base domain. The CLI cannot compute that itself — `clusters` is admin-only
+ * under RLS, so a normal user's token cannot read `baseDomain`, and a project on
+ * a second cluster is served somewhere the platform default does not name.
+ *
+ * `baseDomain` (from `platform-config`) remains the fallback for a control plane
+ * that predates the hook — right for the single-cluster case, which is every
+ * project today.
+ */
+export declare function projectHost(project: HostableProject, baseDomain: string | undefined): string | undefined;
+export interface ProjectLink {
+    url: string;
+    projectId: string;
+    /** The project's subdomain — the slug users see in console URLs and type into --project. */
+    slug?: 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;
+/**
+ * The raw project reference to operate on: explicit `--project` flag wins,
+ * otherwise the linked project. Exits with guidance when neither is present.
+ * The value is a slug (the project's subdomain, as shown in console URLs) or,
+ * for old scripts and link files, a raw project UUID.
+ */
+export declare function requireProjectRef(rawArgs: string[]): string;
+/**
+ * Resolve a project reference — slug or UUID — to the internal id the API
+ * takes, or undefined when no such project is visible. Slugs cost one lookup;
+ * UUIDs pass through untouched so linked directories and old scripts skip the
+ * round-trip.
+ */
+export declare function lookupProjectId(ref: string, client: CloudClient): Promise<string | undefined>;
+/** Like `lookupProjectId`, but exits with guidance when the ref matches nothing. */
+export declare function resolveProjectRef(ref: string, client: CloudClient): Promise<string>;
+/** `requireProjectRef` + `resolveProjectRef` in one step. */
+export declare function requireProject(rawArgs: string[], client: CloudClient): Promise<string>;
+/**
+ * The project reference to SHOW: the slug the user typed or the linked slug.
+ * Never resolves — for human output only. Old link files predate `slug` and
+ * fall back to the stored id.
+ */
+export declare function displayProjectRef(rawArgs: string[]): string;
+/**
+ * Resolve and latch the output mode for this invocation. Call once at the top of
+ * `cloudCommand`, before anything can print or `fail`. Returns the resolved mode
+ * (handy for tests, which otherwise leave it at its `false` default).
+ */
+export declare function initOutputMode(rawArgs: string[]): boolean;
+/** Whether the current invocation is emitting machine-readable JSON. */
+export declare function isJsonMode(): boolean;
+/** Force the mode (tests only — production latches it via `initOutputMode`). */
+export declare function setJsonModeForTest(value: boolean): void;
+/**
+ * The one output primitive every new command uses: in JSON mode emit `json`
+ * (and nothing else); otherwise run `human`. Keeping the two behind a single
+ * call is what guarantees a command can never print a table AND a JSON blob.
+ */
+export declare function emit(human: () => void, json: unknown): void;
+/** Print an error (+ optional hint) and exit non-zero. Never returns. */
+export declare function fail(message: string, hint?: string, code?: string): never;
+/**
+ * Confirm a destructive/irreversible action, respecting non-interactive use.
+ *
+ * With `--yes`/`-y` it proceeds silently. In JSON mode or a non-TTY it REFUSES
+ * to prompt — a prompt that can hang is a known repo landmine — and fails,
+ * telling the caller to pass `--yes`. Only an interactive terminal gets a real
+ * confirm prompt; declining there aborts cleanly (exit 0).
+ */
+export declare function confirmDestructive(opts: {
+    yes: boolean;
+    prompt: string;
+}): Promise<void>;
+/**
+ * Positional tokens after `rebase cloud` — `[group, action, arg1, …]`.
+ *
+ * Deliberately NOT `arg({}, { permissive: true })._`: in permissive mode `arg`
+ * pushes UNKNOWN FLAGS onto `_` too, so `rollback --yes --json` would report
+ * `--yes` as the deployment id. Operand extraction must see operands only, so
+ * anything starting with `-` is dropped — the same filter the db backup handler
+ * has always used.
+ */
+export declare function cloudPositionals(rawArgs: string[]): string[];
+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. Empty rows are skipped
+ * — including `null`, which the API sends for an unset column and which used to
+ * print the literal string "null" (e.g. `Custom domain: null`).
+ */
+export declare function keyValues(rows: Array<[string, string | null | 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/debug.d.ts

@@ -0,0 +1,117 @@
+/** How a probe's outcome should be read. */
+export type Verdict = 
+/** Behaving as a healthy deployment should. */
+"ok"
+/** Reachable and legal, but worth a human look (e.g. a public read). */
+ | "warn"
+/** Broken, or wired up wrong. */
+ | "fail"
+/** We could not classify the response. */
+ | "unknown";
+export interface ProbeReading {
+    verdict: Verdict;
+    /** What this status code *means for this endpoint*, in one sentence. */
+    meaning: string;
+}
+export interface ProbeSpec {
+    id: string;
+    /** Column label in human output. */
+    label: string;
+    method: "GET" | "POST";
+    /** Path relative to the project origin. */
+    path: (opts: ProbeTargets) => string;
+    body?: unknown;
+    /** One-line statement of what a healthy deployment answers here. */
+    healthy: string;
+    interpret: (status: number | null) => ProbeReading;
+    /**
+     * Read the response body as well. Set only where the body carries a fact the
+     * status code cannot — today, the function listing.
+     */
+    needsBody?: boolean;
+    /**
+     * Sharpen the status-code reading using the parsed body. Returning null
+     * keeps {@link interpret}'s verdict.
+     */
+    refine?: (body: unknown, targets: ProbeTargets) => ProbeReading | null;
+}
+export interface ProbeTargets {
+    /** Collection used for the unauthenticated-read probe. */
+    collection: string;
+    /** Function to confirm exists, if the caller named one. */
+    fn?: string;
+}
+/**
+ * The probe set, in the order a failure cascades: if `health` is down, nothing
+ * below it is meaningful, so it is checked first and reported first.
+ */
+export declare const PROBES: ProbeSpec[];
+/** The function names out of a listing body, or null when it is not one. */
+export declare function functionNames(body: unknown): string[] | null;
+export interface ProbeResult {
+    id: string;
+    label: string;
+    method: string;
+    url: string;
+    status: number | null;
+    ms: number;
+    verdict: Verdict;
+    meaning: string;
+    healthy: string;
+    /**
+     * Whether the STATUS CODE alone looked healthy. False means the code itself
+     * was wrong; true with a failing `verdict` means the code was fine and the
+     * body carried the bad news (a named function that did not load). The
+     * summary uses this so it never tells you to expect a 200 you already got.
+     */
+    statusOk: boolean;
+}
+/**
+ * Run one probe. A transport failure is a `null` status, never a thrown error:
+ * "nothing answered" is a diagnosis in its own right and the other probes still
+ * need to run.
+ */
+export declare function runProbe(origin: string, spec: ProbeSpec, targets: ProbeTargets): Promise<ProbeResult>;
+/** The worst verdict across probes — what the command's exit code keys off. */
+export declare function overallVerdict(results: ProbeResult[]): Verdict;
+export interface ParsedLogLine {
+    ts: string | null;
+    pod: string | null;
+    text: string;
+}
+export declare function parseLogLine(line: string): ParsedLogLine;
+/**
+ * Lines an operator scanning for a fault wants to see.
+ *
+ * Matches the structured `severity` field first, then the shapes that show up
+ * in unstructured output. `refus`/`denied` are in the list because a permission
+ * failure often logs at info level and is exactly what one is hunting for.
+ */
+export declare function isErrorLine(text: string): boolean;
+export interface RequestLogEntry {
+    status: number | null;
+    method: string;
+    path: string;
+    latencyMs: number | null;
+}
+/**
+ * Pull an HTTP request record out of a log line, or null when it is not one.
+ *
+ * Only structured request lines are recognised. Guessing at prose would produce
+ * a table with invented columns, which is worse than a short one.
+ */
+export declare function parseRequestLine(text: string): RequestLogEntry | null;
+/**
+ * Startup lines: what the server *decided* it was going to do. Which storage
+ * backend it bound, which functions it loaded, whether auth tables were found.
+ * This is the fastest way to tell a misconfiguration from a runtime fault.
+ */
+export declare function isBootLine(text: string): boolean;
+/** Render a number of seconds back as the compact duration a user would type. */
+export declare function formatDuration(seconds: number): string;
+/**
+ * Parse a duration like `15m`, `2h`, `90s`, `1d` (or a bare number of seconds)
+ * into seconds. Returns null when it is not a duration.
+ */
+export declare function parseSince(input: string | undefined): number | null;
+export declare function debugCommand(action: string | undefined, rawArgs: string[]): Promise<void>;

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

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

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

@@ -0,0 +1,38 @@
+/** A deployment row, as the data API hands it back (camel or snake columns). */
+export interface DeploymentRow {
+    id: string | number;
+    status?: string;
+    createdAt?: string | Date;
+    created_at?: string | Date;
+    finishedAt?: string | Date;
+    finished_at?: string | Date;
+    imageUrl?: string;
+    image_url?: string;
+    rollbackOf?: string;
+    rollback_of?: string;
+    triggeredBy?: string;
+    triggered_by?: string;
+    triggerSource?: string;
+    trigger_source?: string;
+    triggeredByUserId?: string;
+    triggered_by_user_id?: string;
+    gitCommitHash?: string;
+    gitCommitMessage?: string;
+}
+/**
+ * The backend's rule EXACTLY: a rollback is honoured only for a successful
+ * deploy that recorded an image. Any other row 409s `deploy_not_rollbackable`.
+ */
+export declare function isRollbackable(dep: DeploymentRow): boolean;
+/** finishedAt − createdAt in ms, or null (still running / missing / skewed). */
+export declare function deploymentDurationMs(dep: DeploymentRow): number | null;
+export declare function triggerInfo(dep: DeploymentRow): {
+    by: string;
+    source: string;
+    userId: string;
+};
+/** Shape one deployment row into the stable JSON view the CLI publishes. */
+export declare function deploymentView(dep: DeploymentRow): Record<string, unknown>;
+export declare function deploymentsListCommand(rawArgs: string[]): Promise<void>;
+export declare function rollbackCommand(rawArgs: string[]): Promise<void>;
+export declare function cancelCommand(rawArgs: string[]): Promise<void>;

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

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

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

@@ -0,0 +1,6 @@
+export declare function envCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+/** Parse `KEY=VALUE` or `KEY VALUE` from the positional operands. */
+export declare function parseEnvAssignment(operands: string[]): {
+    key: string;
+    value: string;
+} | null;

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

@@ -0,0 +1,3 @@
+/** The identifier CREATE EXTENSION takes. `pgvector` is a common alias. */
+export declare function resolveExtensionAlias(name: string): string;
+export declare function extensionsCommand(action: string | undefined, rawArgs: 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/power.d.ts

@@ -0,0 +1,3 @@
+type PowerAction = "start" | "stop" | "restart";
+export declare function powerCommand(action: PowerAction, rawArgs: string[]): Promise<void>;
+export {};

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[], projectRef: string): Promise<void>;
+export declare function deleteProject(rawArgs: string[], projectRef: 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(action: string | undefined, rawArgs: string[]): Promise<void>;
+export declare function clustersCommand(rawArgs: string[]): Promise<void>;
+export declare function billingCommand(rawArgs: string[]): Promise<void>;

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

@@ -0,0 +1,8 @@
+export declare function settingsCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+/** Build the update patch from the flags actually supplied (pure/testable). */
+export declare function buildSettingsPatch(args: {
+    name?: string;
+    subdomain?: string;
+    repo?: string;
+    branch?: string;
+}): Record<string, string>;

package/dist/commands/init.d.ts

@@ -1,5 +1,19 @@
 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.
+ *
+ * `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;
@@ -10,14 +24,23 @@ export interface InitOptions {
     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;
+    /** Cloud project slug (its subdomain) to link the scaffold to. */
+    cloudProject?: string;
+    /** One-time setup key that authenticates the cloud link. */
+    setupKey?: string;
+    /** Control-plane URL the setup key is redeemed against. */
+    cloudUrl?: string;
 }
 export interface BuildQuestionsParams {
     nameArg?: string;
     templateArg?: TemplatePreset;
+    flavorArg?: TemplateFlavor;
     hasGitFlag: boolean;
     hasInstallFlag: boolean;
     pm: PackageManager;

package/dist/commands/skills.d.ts

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

package/dist/index.d.ts

@@ -8,5 +8,6 @@ export * from "./commands/start";
 export * from "./commands/auth";
 export * from "./commands/doctor";
 export * from "./commands/generate_sdk";
+export * from "./commands/cloud";
 export * from "./utils/project";
 export * from "./utils/package-manager";