@rebasepro/cli 0.9.1-canary.742f831 → 0.9.1-canary.78ab3dc

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/context.d.ts

@@ -1,10 +1,6 @@
 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;
@@ -104,8 +100,6 @@ export declare function initOutputMode(rawArgs: string[]): boolean;
 export declare function isJsonMode(): boolean;
 /** Force the mode (tests only — production latches it via `initOutputMode`). */
 export declare function setJsonModeForTest(value: boolean): void;
-/** Write one JSON value to stdout, followed by a newline. */
-export declare function printJson(value: unknown): 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

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/deployments.d.ts

@@ -19,7 +19,6 @@ export interface DeploymentRow {
     gitCommitHash?: string;
     gitCommitMessage?: string;
 }
-export declare function deploymentImage(dep: DeploymentRow): string | null;
 /**
  * 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`.

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

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

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(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/init.d.ts

@@ -24,6 +24,8 @@ export interface InitOptions {
     introspect?: boolean;
     /** Starter template preset. */
     preset: TemplatePreset;
+    /** Whether `preset` came from an explicit --template rather than the default. */
+    explicitPreset?: boolean;
     /** Which parts of Rebase to scaffold. */
     flavor: TemplateFlavor;
     /** Detected package manager (pnpm or npm). */
@@ -51,5 +53,15 @@ export interface BuildQuestionsParams {
  * types registered by the installed version of inquirer.
  */
 export declare function buildInitQuestions(params: BuildQuestionsParams): Record<string, unknown>[];
+/**
+ * The `cd` a user must type to enter the new project.
+ *
+ * Not the project's basename: `init apps/my-app` has to say `cd apps/my-app`,
+ * and `init .` returns "" because they are already in the project.
+ */
+export declare function formatCdTarget(cwd: string, targetDirectory: string): string;
+/** Help for `rebase init` — the flags were previously only discoverable by
+ * triggering the non-TTY error. */
+export declare function printInitHelp(): void;
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
 export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): Promise<void>;