@batadata/cli 0.1.16 → 0.2.0

package/dist/commands/projects.d.ts

@@ -1,3 +1,4 @@
+import { type ComputeTier } from "../pricing.js";
 /**
  * Only surface `defaultProject` if it's actually one of the caller's real
  * projects — a saved default from another team/key/stale config must never
@@ -7,7 +8,22 @@ export declare function validDefaultProject(projects: Array<{
     id: string;
 }>, defaultProject: string | undefined): string | null;
 export declare function list(): Promise<void>;
-export declare function create(): Promise<void>;
+/**
+ * Parse the compute tier/size flags for `projects create`:
+ *   --tier serverless|always-on   (default: serverless)   also --tier=…
+ *   --size 1|2|4|8|16|32|64|128   (default: 1; >16 = serverless only)  also --size=…
+ *
+ * Returns the API tier value (`always_on` / `serverless`) and the size, or an
+ * `error` describing the first invalid flag so the caller can exit non-zero.
+ * `always-on` (hyphen, the CLI spelling) maps to the API's `always_on`.
+ */
+export declare function parseCreateComputeArgs(args: string[]): {
+    tier: ComputeTier;
+    sizeCu: number;
+} | {
+    error: string;
+};
+export declare function create(args?: string[]): Promise<void>;
 export declare function info(projectId?: string): Promise<void>;
 export declare function deleteProject(projectId?: string): Promise<void>;
 /**

package/dist/commands/projects.js

@@ -4,6 +4,7 @@ import { colors, log, json, success, spinner, table, kvList, heading } from "../
 import { prompt, confirmDestructive, select } from "../utils/prompts.js";
 import { emitError } from "../utils/errors.js";
 import { resolveProjectId } from "../link.js";
+import { computePriceSummary, ALL_SIZE_CU, FLY_MAX_SIZE_CU } from "../pricing.js";
 function projectCreatedAt(p) {
     return p.created_at ?? p.createdAt ?? "";
 }
@@ -95,9 +96,78 @@ export async function list() {
     ]));
     log();
 }
-export async function create() {
+/**
+ * Parse the compute tier/size flags for `projects create`:
+ *   --tier serverless|always-on   (default: serverless)   also --tier=…
+ *   --size 1|2|4|8|16|32|64|128   (default: 1; >16 = serverless only)  also --size=…
+ *
+ * Returns the API tier value (`always_on` / `serverless`) and the size, or an
+ * `error` describing the first invalid flag so the caller can exit non-zero.
+ * `always-on` (hyphen, the CLI spelling) maps to the API's `always_on`.
+ */
+export function parseCreateComputeArgs(args) {
+    let tierRaw;
+    let sizeRaw;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--tier" || arg === "--size") {
+            // The spaced form needs a value: reject a missing one (end of args, or
+            // the next token is another flag) instead of silently using the default.
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("-")) {
+                const usage = arg === "--tier" ? "serverless|always-on" : "1|2|4|8|16|32|64|128";
+                return { error: `${arg} requires a value (${usage}).` };
+            }
+            if (arg === "--tier")
+                tierRaw = next;
+            else
+                sizeRaw = next;
+            i++;
+        }
+        else if (arg.startsWith("--tier="))
+            tierRaw = arg.slice("--tier=".length);
+        else if (arg.startsWith("--size="))
+            sizeRaw = arg.slice("--size=".length);
+    }
+    let tier = "serverless";
+    if (tierRaw !== undefined) {
+        const normalized = tierRaw.toLowerCase();
+        if (normalized === "serverless")
+            tier = "serverless";
+        else if (normalized === "always-on" || normalized === "always_on")
+            tier = "always_on";
+        else {
+            return {
+                error: `Invalid --tier "${tierRaw}". Use "serverless" or "always-on".`,
+            };
+        }
+    }
+    let sizeCu = 1;
+    if (sizeRaw !== undefined) {
+        const parsed = Number(sizeRaw);
+        if (!ALL_SIZE_CU.includes(parsed)) {
+            return {
+                error: `Invalid --size "${sizeRaw}". Use one of ${ALL_SIZE_CU.join(", ")} CU (sizes above ${FLY_MAX_SIZE_CU} are serverless/density only).`,
+            };
+        }
+        // Density-only sizes (>16 CU) can't run always-on (always-on is Fly-hosted).
+        if (parsed > FLY_MAX_SIZE_CU && tier === "always_on") {
+            return {
+                error: `--size ${parsed} CU is serverless-only (density-hosted); it can't be used with --tier always-on.`,
+            };
+        }
+        sizeCu = parsed;
+    }
+    return { tier, sizeCu };
+}
+export async function create(args = []) {
     const token = requireToken();
     const config = loadConfig();
+    const compute = parseCreateComputeArgs(args);
+    if ("error" in compute) {
+        emitError("INVALID_FLAG", compute.error, "");
+        return;
+    }
     heading("Create a new project");
     const name = await prompt("Project name");
     if (!name) {
@@ -106,7 +176,13 @@ export async function create() {
     const region = await select("Select a region", REGIONS);
     const s = spinner("Creating project");
     const teamId = await resolveTeamId(token);
-    const body = { name, region };
+    const body = {
+        name,
+        region,
+        // One friendly step: the compute is born on the chosen tier + size (no
+        // follow-up `bata compute set` needed). Defaults to serverless / 1 CU.
+        compute: { tier: compute.tier, size_cu: compute.sizeCu },
+    };
     if (teamId) {
         body.team_id = teamId;
     }
@@ -121,12 +197,15 @@ export async function create() {
     const project = res.data;
     // Set as default project
     saveConfig({ defaultProject: project.id });
+    const tierLabel = compute.tier === "always_on" ? "Always-on (dedicated)" : "Serverless";
     log();
     success(`Project ${colors.cyan(project.name)} created`);
     log();
     kvList([
         ["ID", colors.dim(project.id)],
         ["Region", project.region],
+        ["Compute", `${tierLabel} · ${compute.sizeCu} CU`],
+        ["Pricing", colors.dim(computePriceSummary(compute.tier, compute.sizeCu))],
         ["Status", statusBadge(project.status)],
     ]);
     log();
@@ -272,7 +351,7 @@ export async function handleProjects(args) {
     const sub = args[0];
     switch (sub) {
         case "create":
-            return create();
+            return create(args.slice(1));
         case "info":
             return info(resolveProjectArg(args.slice(1)));
         case "delete":

package/dist/index.js

@@ -13,14 +13,20 @@ import { claim } from "./commands/claim.js";
 import { status } from "./commands/status.js";
 import { connect } from "./commands/connect.js";
 import { usage } from "./commands/usage.js";
+import { handleCompute } from "./commands/compute.js";
 import { handleRestore } from "./commands/restore.js";
 import { handlePowdb } from "./commands/powdb.js";
+import { importDb } from "./commands/import.js";
 import { link, unlink } from "./commands/link.js";
 import { parseGlobalFlags } from "./args.js";
 import { isJsonMode } from "./config.js";
 import { colors, log, banner } from "./utils/logger.js";
 import { exitCodeFor, isRetryable } from "./utils/errors.js";
-const VERSION = "0.1.4";
+import { createRequire } from "node:module";
+// Read the version from package.json (dist/index.js → ../package.json) instead
+// of a hardcoded constant — the constant sat at "0.1.4" while releases shipped
+// through 0.1.19, so every published CLI misreported `--version`.
+const VERSION = createRequire(import.meta.url)("../package.json").version;
 function help() {
     banner();
     log(`  ${colors.bold("Usage")}`);
@@ -45,7 +51,7 @@ function help() {
     log(`  ${colors.bold("Projects")}`);
     log(`    ${colors.cyan("projects")}           List all projects`);
     log(`    ${colors.cyan("projects list")}      Alias for status`);
-    log(`    ${colors.cyan("projects create")}    Create a new project (interactive)`);
+    log(`    ${colors.cyan("projects create")}    Create a new project ${colors.dim("(--tier serverless|always-on, --size 1|2|4|8|16|32|64|128)")}`);
     log(`    ${colors.cyan("projects info")}      Show project details`);
     log(`    ${colors.cyan("projects delete")}    Delete a project`);
     log();
@@ -59,6 +65,10 @@ function help() {
     log(`    ${colors.cyan("db studio")}          Open table browser in browser`);
     log(`    ${colors.cyan("db query")}           Run a SQL query ${colors.dim("(--branch <id> to target a branch)")}`);
     log();
+    log(`  ${colors.bold("Compute")}`);
+    log(`    ${colors.cyan("compute status")}      Show each branch's compute size + always-on state`);
+    log(`    ${colors.cyan("compute set")}         Dedicated always-on tier / fixed size ${colors.dim("(--always-on, --size <cu>)")}`);
+    log();
     log(`  ${colors.bold("Restore (PITR)")}`);
     log(`    ${colors.cyan("restore points")}     List recovery points + the PITR window`);
     log(`    ${colors.cyan("restore create")}     Restore a branch to a timestamp/LSN ${colors.dim("(creates a NEW branch)")}`);
@@ -69,6 +79,9 @@ function help() {
     log(`    ${colors.cyan("schema check|dump|diff")}  Schema safety gate + introspection`);
     log(`    ${colors.cyan("migrate check")}      Gate a migration against live query traffic ${colors.dim("(exit 2 if breaking)")}`);
     log();
+    log(`  ${colors.bold("Migrate in (Neon → BataDB)")}`);
+    log(`    ${colors.cyan("import")}             Migrate a Postgres/Neon DB into BataDB ${colors.dim("(--source <uri> [--name|--project])")}`);
+    log();
     log(`  ${colors.bold("PowDB (embedded lane, Stage A)")}`);
     log(`    ${colors.cyan("powdb pull")}         Pull a branch's schema + data into a local PowDB-loadable PowQL script`);
     log();
@@ -179,6 +192,10 @@ async function main() {
             case "db":
                 await handleDb(rest);
                 break;
+            // Compute (dedicated always-on tier + size picker)
+            case "compute":
+                await handleCompute(rest);
+                break;
             // Restore (PITR)
             case "restore":
                 await handleRestore(rest);
@@ -199,6 +216,10 @@ async function main() {
             case "migrate":
                 await handleMigrate(rest);
                 break;
+            // Import (Neon → BataDB)
+            case "import":
+                await importDb(rest);
+                break;
             // Dev
             case "dev":
                 await dev();

package/dist/pricing.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Customer-facing compute pricing for CLI output.
+ *
+ * SOURCE OF TRUTH: control-plane/src/lib/pricing.ts (`computePerCuHourCents`).
+ * The CLI is a zero-dependency package that can't import across workspaces, so
+ * the rate is re-declared here. If the canonical rate changes, update this too.
+ *
+ * COST-TRUTH RULE: every displayed price is DERIVED from this one rate — never a
+ * hardcoded dollar figure — so the CLI can only ever quote a price that billing
+ * actually produces. Serverless copy deliberately makes no wake-latency promise.
+ */
+/** Cents per CU-hour of compute. Mirrors pricing.ts `computePerCuHourCents`. */
+export declare const COMPUTE_PER_CU_HOUR_CENTS = 1;
+/** Standard billing month: 365d × 24h ÷ 12. An always-on primary runs all of it. */
+export declare const HOURS_PER_MONTH = 730;
+/** Fly-capable fixed sizes (any tier). 1 CU = 512MB / 0.25 vCPU → {1,2,4,8,16} = 512MB→8GB. */
+export declare const DEDICATED_SIZE_CU: readonly [1, 2, 4, 8, 16];
+/** Density-only sizes (16/32/64GB) — serverless computes on a density host only.
+ * Mirrors DENSITY_ONLY_SIZE_CU in control-plane/src/lib/compute-sizes.ts. */
+export declare const DENSITY_ONLY_SIZE_CU: readonly [32, 64, 128];
+/** Every selectable size (Fly-capable + density-only). */
+export declare const ALL_SIZE_CU: readonly [1, 2, 4, 8, 16, 32, 64, 128];
+/** Largest size a Fly-hosted compute may run; above this needs serverless/density. */
+export declare const FLY_MAX_SIZE_CU = 16;
+export type ComputeTier = "serverless" | "always_on";
+/** The base compute rate as a dollar string, e.g. "$0.01". */
+export declare function computePerCuHourDollars(): string;
+/** Flat monthly cost of an always-on `sizeCu` compute (730h), e.g. 4 → "$29.20". */
+export declare function alwaysOnMonthlyDollars(sizeCu: number): string;
+/**
+ * One-line price implication for the create confirmation. Always-on quotes the
+ * flat monthly bill (with the arithmetic shown); serverless states the usage
+ * rate and scale-to-zero — with no wake-latency claim.
+ */
+export declare function computePriceSummary(tier: ComputeTier, sizeCu: number): string;

package/dist/pricing.js

@@ -0,0 +1,44 @@
+/**
+ * Customer-facing compute pricing for CLI output.
+ *
+ * SOURCE OF TRUTH: control-plane/src/lib/pricing.ts (`computePerCuHourCents`).
+ * The CLI is a zero-dependency package that can't import across workspaces, so
+ * the rate is re-declared here. If the canonical rate changes, update this too.
+ *
+ * COST-TRUTH RULE: every displayed price is DERIVED from this one rate — never a
+ * hardcoded dollar figure — so the CLI can only ever quote a price that billing
+ * actually produces. Serverless copy deliberately makes no wake-latency promise.
+ */
+/** Cents per CU-hour of compute. Mirrors pricing.ts `computePerCuHourCents`. */
+export const COMPUTE_PER_CU_HOUR_CENTS = 1; // $0.01 / CU-hour
+/** Standard billing month: 365d × 24h ÷ 12. An always-on primary runs all of it. */
+export const HOURS_PER_MONTH = 730;
+/** Fly-capable fixed sizes (any tier). 1 CU = 512MB / 0.25 vCPU → {1,2,4,8,16} = 512MB→8GB. */
+export const DEDICATED_SIZE_CU = [1, 2, 4, 8, 16];
+/** Density-only sizes (16/32/64GB) — serverless computes on a density host only.
+ * Mirrors DENSITY_ONLY_SIZE_CU in control-plane/src/lib/compute-sizes.ts. */
+export const DENSITY_ONLY_SIZE_CU = [32, 64, 128];
+/** Every selectable size (Fly-capable + density-only). */
+export const ALL_SIZE_CU = [...DEDICATED_SIZE_CU, ...DENSITY_ONLY_SIZE_CU];
+/** Largest size a Fly-hosted compute may run; above this needs serverless/density. */
+export const FLY_MAX_SIZE_CU = 16;
+/** The base compute rate as a dollar string, e.g. "$0.01". */
+export function computePerCuHourDollars() {
+    return `$${(COMPUTE_PER_CU_HOUR_CENTS / 100).toFixed(2)}`;
+}
+/** Flat monthly cost of an always-on `sizeCu` compute (730h), e.g. 4 → "$29.20". */
+export function alwaysOnMonthlyDollars(sizeCu) {
+    const dollars = (sizeCu * HOURS_PER_MONTH * COMPUTE_PER_CU_HOUR_CENTS) / 100;
+    return `$${dollars.toFixed(2)}`;
+}
+/**
+ * One-line price implication for the create confirmation. Always-on quotes the
+ * flat monthly bill (with the arithmetic shown); serverless states the usage
+ * rate and scale-to-zero — with no wake-latency claim.
+ */
+export function computePriceSummary(tier, sizeCu) {
+    if (tier === "always_on") {
+        return `fixed ~${alwaysOnMonthlyDollars(sizeCu)}/mo (${sizeCu} CU × ${computePerCuHourDollars()}/CU-hr × ${HOURS_PER_MONTH}h)`;
+    }
+    return `usage-billed at ${computePerCuHourDollars()}/CU-hr while awake, scale-to-zero when idle`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batadata/cli",
-  "version": "0.1.16",
+  "version": "0.2.0",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"
@@ -10,7 +10,9 @@
     "build": "tsc -p tsconfig.build.json",
     "dev": "tsc -p tsconfig.build.json --watch",
     "typecheck": "tsc --noEmit",
-    "test": "node --test \"test/*.test.mjs\"",
+    "test": "npm run test:node && npm run test:vitest",
+    "test:node": "node --test \"test/*.test.mjs\"",
+    "test:vitest": "vitest run",
     "pretest": "npm run build"
   },
   "engines": {