@rebasepro/cli 0.9.1-canary.baa7a6b → 0.9.1-canary.d198c11

package/bin/rebase.js

@@ -1,70 +1,4 @@
 #!/usr/bin/env node
-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");
+import { entry } from "../dist/index.es.js";
 
 entry(process.argv);

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

@@ -1,6 +1,10 @@
 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;
@@ -24,42 +28,9 @@ 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;
 }
@@ -67,78 +38,17 @@ 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,
+ * Resolve the project id 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;
+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, 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 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. 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;
+/** 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.

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

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

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

@@ -1,8 +1,8 @@
 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 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;

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

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

package/dist/commands/init.d.ts

@@ -1,6 +1,4 @@
 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.
@@ -30,12 +28,6 @@ export interface InitOptions {
     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;

package/dist/commands/skills.d.ts

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