@batadata/cli 0.1.15 → 0.1.17

package/dist/commands/claim.d.ts

@@ -1,10 +1,12 @@
 /**
- * bata claim <token> — redeem a claimable database into your team.
+ * bata claim <token> — redeem a legacy claim token into your team.
  *
- * Authed. Resolves the team (like `bata create`), calls
- * POST /v1/claim/redeem { claim_token, team_id }, and on success the project
- * becomes a permanent member of your team (its TTL is cleared). Typed,
- * agent-friendly errors for unknown / expired / already-claimed tokens.
+ * LEGACY: the anonymous, no-signup flow that issued claim tokens is gone —
+ * `bata new` now creates a database directly in your team. This command remains
+ * only to redeem a token from that retired flow. Authed. Resolves the team
+ * (like `bata create`), calls POST /v1/claim/redeem { claim_token, team_id },
+ * and on success the project becomes a permanent member of your team (its TTL
+ * is cleared). Typed errors for unknown / expired / already-claimed tokens.
  */
 export interface ClaimArgs {
     token?: string;

package/dist/commands/claim.js

@@ -1,10 +1,12 @@
 /**
- * bata claim <token> — redeem a claimable database into your team.
+ * bata claim <token> — redeem a legacy claim token into your team.
  *
- * Authed. Resolves the team (like `bata create`), calls
- * POST /v1/claim/redeem { claim_token, team_id }, and on success the project
- * becomes a permanent member of your team (its TTL is cleared). Typed,
- * agent-friendly errors for unknown / expired / already-claimed tokens.
+ * LEGACY: the anonymous, no-signup flow that issued claim tokens is gone —
+ * `bata new` now creates a database directly in your team. This command remains
+ * only to redeem a token from that retired flow. Authed. Resolves the team
+ * (like `bata create`), calls POST /v1/claim/redeem { claim_token, team_id },
+ * and on success the project becomes a permanent member of your team (its TTL
+ * is cleared). Typed errors for unknown / expired / already-claimed tokens.
  */
 import { api, apiError, resolveTeamId } from "../api.js";
 import { requireToken, saveConfig, isJsonMode } from "../config.js";
@@ -25,7 +27,8 @@ function printHelp() {
     log();
     log(`  ${colors.bold("bata claim")} ${colors.dim("<token>")}`);
     log();
-    log(`  Claim an instant database (from ${colors.cyan("bata new")}) into your team.`);
+    log(`  ${colors.yellow("Legacy:")} redeem a claim token from the retired anonymous flow.`);
+    log(`  ${colors.cyan("bata new")} now creates a database directly in your team — no token to claim.`);
     log(`  Requires login — pass ${colors.cyan("--api-key")}, set ${colors.cyan("BATA_API_KEY")}, or run ${colors.cyan("bata login")}.`);
     log();
     log(`  ${colors.bold("Examples")}`);

package/dist/commands/compute.d.ts

@@ -0,0 +1,24 @@
+/**
+ * bata compute — inspect and configure a branch's compute.
+ *
+ * `bata compute set` toggles the dedicated always-on tier and/or picks a fixed
+ * size for a branch's compute; `bata compute status` surfaces each branch's
+ * size + always-on state. Both resolve the compute via the branch (a branch has
+ * one compute today) so agents never handle raw compute IDs.
+ */
+interface ComputeSetFlags {
+    projectId?: string;
+    branch?: string;
+    alwaysOn?: boolean;
+    size?: number;
+}
+/**
+ * Parse `compute set` flags. `--always-on`/`--no-always-on` are valueless
+ * booleans; `--size <cu>` (and `--size=<cu>`) takes a number. `--project` /
+ * `--branch` accept both spaced and `=` forms, matching the other commands.
+ */
+export declare function parseComputeSetFlags(args: string[]): ComputeSetFlags;
+export declare function computeSet(args: string[]): Promise<void>;
+export declare function computeStatus(args: string[]): Promise<void>;
+export declare function handleCompute(args: string[]): Promise<void>;
+export {};

package/dist/commands/compute.js

@@ -0,0 +1,217 @@
+/**
+ * bata compute — inspect and configure a branch's compute.
+ *
+ * `bata compute set` toggles the dedicated always-on tier and/or picks a fixed
+ * size for a branch's compute; `bata compute status` surfaces each branch's
+ * size + always-on state. Both resolve the compute via the branch (a branch has
+ * one compute today) so agents never handle raw compute IDs.
+ */
+import { api, apiError, resolveTeamId } from "../api.js";
+import { requireToken, isJsonMode } from "../config.js";
+import { colors, log, json, spinner, table, heading } from "../utils/logger.js";
+import { emitError } from "../utils/errors.js";
+import { resolveProjectId } from "../link.js";
+// Fixed dedicated sizes: 1 CU = 512MB / 0.25 vCPU, so {1,2,4,8,16} = 512MB→8GB.
+// Mirrors DEDICATED_SIZE_CU in control-plane/src/routes/computes.ts.
+const DEDICATED_SIZE_CU = [1, 2, 4, 8, 16];
+/**
+ * Parse `compute set` flags. `--always-on`/`--no-always-on` are valueless
+ * booleans; `--size <cu>` (and `--size=<cu>`) takes a number. `--project` /
+ * `--branch` accept both spaced and `=` forms, matching the other commands.
+ */
+export function parseComputeSetFlags(args) {
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--project")
+            flags.projectId = args[++i];
+        else if (arg.startsWith("--project="))
+            flags.projectId = arg.slice("--project=".length);
+        else if (arg === "--branch")
+            flags.branch = args[++i];
+        else if (arg.startsWith("--branch="))
+            flags.branch = arg.slice("--branch=".length);
+        else if (arg === "--always-on")
+            flags.alwaysOn = true;
+        else if (arg === "--no-always-on")
+            flags.alwaysOn = false;
+        else if (arg === "--size")
+            flags.size = Number(args[++i]);
+        else if (arg.startsWith("--size="))
+            flags.size = Number(arg.slice("--size=".length));
+    }
+    return flags;
+}
+/** Fetch the project (branches enriched with their computes). Null on failure. */
+async function fetchProject(projectId, token, teamId) {
+    const query = {};
+    if (teamId)
+        query.team_id = teamId;
+    const res = await api.get(`/v1/projects/${projectId}`, token, query);
+    return res.ok ? res.data : null;
+}
+/** Resolve a branch by id OR name, else null. */
+function findBranch(project, ref) {
+    return project.branches?.find((b) => b.id === ref || b.name === ref) ?? null;
+}
+/** The compute serving a branch (a branch has one today); prefer an active one. */
+function branchCompute(branch) {
+    const computes = branch.computes ?? [];
+    return computes.find((comp) => comp.status === "active") ?? computes[0] ?? null;
+}
+export async function computeSet(args) {
+    const jsonMode = isJsonMode();
+    const flags = parseComputeSetFlags(args);
+    if (flags.alwaysOn === undefined && flags.size === undefined) {
+        emitError("MISSING_ARG", "Nothing to change.", "Pass --always-on/--no-always-on and/or --size <cu>.");
+    }
+    if (flags.size !== undefined && !DEDICATED_SIZE_CU.includes(flags.size)) {
+        emitError("INVALID_FLAG", `Invalid --size ${flags.size}. Allowed: ${DEDICATED_SIZE_CU.join(", ")} (512MB, 1GB, 2GB, 4GB, 8GB).`, "Example: bata compute set --branch main --size 8");
+    }
+    if (!flags.branch) {
+        emitError("MISSING_ARG", "A branch is required.", "Pass --branch <name-or-id>.");
+    }
+    const token = requireToken();
+    const projectId = resolveProjectId(flags.projectId).projectId;
+    if (!projectId) {
+        emitError("NO_PROJECT", "No project.", "Pass --project <id>, or run `bata link <project>` to set a default.");
+    }
+    const teamId = await resolveTeamId(token);
+    const s = jsonMode ? null : spinner(`Resolving branch ${colors.cyan(flags.branch)}`);
+    const project = await fetchProject(projectId, token, teamId);
+    if (!project) {
+        s?.stop();
+        emitError("API_UNAVAILABLE", "Failed to fetch project.", "");
+    }
+    const branch = findBranch(project, flags.branch);
+    if (!branch) {
+        s?.stop();
+        emitError("BRANCH_NOT_FOUND", `Branch "${flags.branch}" not found in this project.`, "List branches with: bata db branches --json");
+    }
+    const compute = branchCompute(branch);
+    if (!compute) {
+        s?.stop();
+        emitError("NOT_FOUND", `Branch "${branch.name}" has no compute yet.`, "Wait for the branch to finish provisioning, then retry.");
+    }
+    const body = {};
+    if (flags.alwaysOn !== undefined)
+        body.always_on = flags.alwaysOn;
+    if (flags.size !== undefined)
+        body.size_cu = flags.size;
+    const res = await api.patch(`/v1/computes/${compute.id}`, body, token);
+    s?.stop();
+    if (!res.ok) {
+        emitError(res.status === 401 || res.status === 403 ? "INVALID_KEY"
+            : res.status === 404 ? "NOT_FOUND"
+                : res.status >= 500 || res.status === 0 ? "API_UNAVAILABLE"
+                    : "CLI_ERROR", apiError(res, "Failed to update compute"), "");
+    }
+    if (jsonMode) {
+        json({
+            compute: {
+                id: res.data.id,
+                branch: branch.name,
+                project_id: projectId,
+                always_on: res.data.alwaysOn ?? null,
+                size_cu: res.data.sizeCu ?? null,
+                status: res.data.status ?? null,
+            },
+            notes: res.data.notes ?? [],
+        });
+        return;
+    }
+    log();
+    log(`  ${colors.green(">")} Compute for branch ${colors.cyan(branch.name)} updated`);
+    if (flags.alwaysOn !== undefined) {
+        log(`  ${colors.dim("Always-on:")} ${res.data.alwaysOn ? colors.green("on") : "off"}`);
+    }
+    if (flags.size !== undefined) {
+        log(`  ${colors.dim("Size:")}      ${res.data.sizeCu ?? flags.size} CU`);
+    }
+    for (const note of res.data.notes ?? []) {
+        log(`  ${colors.yellow("note:")} ${colors.dim(note)}`);
+    }
+    log();
+}
+export async function computeStatus(args) {
+    const jsonMode = isJsonMode();
+    const flags = parseComputeSetFlags(args); // reuse --project/--branch parsing
+    const token = requireToken();
+    const projectId = resolveProjectId(flags.projectId).projectId;
+    if (!projectId) {
+        emitError("NO_PROJECT", "No project.", "Pass --project <id>, or run `bata link <project>` to set a default.");
+    }
+    const teamId = await resolveTeamId(token);
+    const s = jsonMode ? null : spinner("Fetching computes");
+    const project = await fetchProject(projectId, token, teamId);
+    s?.stop();
+    if (!project) {
+        emitError("API_UNAVAILABLE", "Failed to fetch project.", "");
+    }
+    let branchList = project.branches ?? [];
+    if (flags.branch) {
+        const b = findBranch(project, flags.branch);
+        if (!b) {
+            emitError("BRANCH_NOT_FOUND", `Branch "${flags.branch}" not found in this project.`, "List branches with: bata db branches --json");
+        }
+        branchList = [b];
+    }
+    const rows = branchList.map((b) => {
+        const compute = branchCompute(b);
+        return {
+            branch: b.name,
+            compute_id: compute?.id ?? null,
+            status: compute?.status ?? null,
+            size_cu: compute?.sizeCu ?? null,
+            always_on: compute?.alwaysOn ?? false,
+        };
+    });
+    if (jsonMode) {
+        json({ project_id: projectId, computes: rows });
+        return;
+    }
+    heading(`Computes — ${project.name}`);
+    if (rows.length === 0) {
+        log(`  ${colors.dim("No branches found.")}`);
+        log();
+        return;
+    }
+    table(["BRANCH", "STATUS", "SIZE (CU)", "ALWAYS-ON"], rows.map((r) => [
+        r.branch,
+        r.status ?? "-",
+        r.size_cu != null ? String(r.size_cu) : "-",
+        r.always_on ? colors.green("on") : "-",
+    ]));
+    log();
+}
+function computeHelp() {
+    log();
+    log(`  ${colors.bold("bata compute")} — inspect and configure branch compute`);
+    log();
+    log(`  ${colors.cyan("bata compute status [--project <id>] [--branch <name-or-id>]")}`);
+    log(`  ${colors.cyan("bata compute set --branch <name-or-id> [--always-on|--no-always-on] [--size <cu>]")}`);
+    log();
+    log(`  ${colors.dim("--always-on / --no-always-on")}  Dedicated always-on primary (no cold starts; flat bill)`);
+    log(`  ${colors.dim("--size <cu>")}                   Fixed size: ${DEDICATED_SIZE_CU.join(", ")} CU (512MB, 1GB, 2GB, 4GB, 8GB)`);
+    log(`  ${colors.dim("--project <id>")}                Target project (else the linked/default project)`);
+    log(`  ${colors.dim("--branch <name-or-id>")}         Target branch by name OR id`);
+    log();
+    log(`  ${colors.dim("Changing --size restarts the compute briefly to apply it.")}`);
+    log();
+}
+export async function handleCompute(args) {
+    const sub = args[0];
+    if (!sub || sub === "--help" || sub === "-h" || sub === "help") {
+        computeHelp();
+        return;
+    }
+    switch (sub) {
+        case "set":
+            return computeSet(args.slice(1));
+        case "status":
+        case "info":
+            return computeStatus(args.slice(1));
+        default:
+            emitError("INVALID_FLAG", `Unknown subcommand: compute ${sub}`, "Available: set, status");
+    }
+}

package/dist/commands/new.d.ts

@@ -1,17 +1,21 @@
 /**
- * bata new — instant, no-signup Postgres (bata.new / claimable databases).
+ * bata new — instant Postgres in your team (one call, zero config).
  *
- * Calls the PUBLIC POST /v1/claim/new (no credentials needed), prints the
- * connection string, the expiry, and how to claim the database into a real
- * team later. `--json` emits the full payload (including the one-time claim
- * token) for agents.
+ * Authed (like every other command): requires a credential. Calls
+ * POST /v1/claim/new, which creates a REAL project directly in your team —
+ * owned, billed, and quota'd like any other — and prints the connection string.
+ * No name or region to pick; the compute is the smallest box and scales to zero.
  *
- * Honest wording: an UNCLAIMED database is permanently DELETED at its expiry.
+ * `--team <id>` targets a specific team (else your resolved/default team).
+ * `--json` emits the full payload for agents.
+ *
+ * (The old anonymous, no-signup flow with claim tokens is gone.)
  */
 export interface NewArgs {
+    team?: string;
     help: boolean;
 }
-/** Parse `bata new` args. No positional/flags today beyond --help (global
- *  flags like --json are stripped upstream in index.ts). Exported for tests. */
+/** Parse `bata new` args: optional `--team <id>` and `--help` (global flags
+ *  like --json are stripped upstream in index.ts). Exported for tests. */
 export declare function parseNewArgs(args: string[]): NewArgs;
 export declare function newDb(args: string[]): Promise<void>;

package/dist/commands/new.js

@@ -1,41 +1,45 @@
 /**
- * bata new — instant, no-signup Postgres (bata.new / claimable databases).
+ * bata new — instant Postgres in your team (one call, zero config).
  *
- * Calls the PUBLIC POST /v1/claim/new (no credentials needed), prints the
- * connection string, the expiry, and how to claim the database into a real
- * team later. `--json` emits the full payload (including the one-time claim
- * token) for agents.
+ * Authed (like every other command): requires a credential. Calls
+ * POST /v1/claim/new, which creates a REAL project directly in your team —
+ * owned, billed, and quota'd like any other — and prints the connection string.
+ * No name or region to pick; the compute is the smallest box and scales to zero.
  *
- * Honest wording: an UNCLAIMED database is permanently DELETED at its expiry.
+ * `--team <id>` targets a specific team (else your resolved/default team).
+ * `--json` emits the full payload for agents.
+ *
+ * (The old anonymous, no-signup flow with claim tokens is gone.)
  */
-import { api, apiError } from "../api.js";
-import { isJsonMode } from "../config.js";
+import { api, apiError, resolveTeamId } from "../api.js";
+import { requireToken, isJsonMode, saveConfig } from "../config.js";
 import { colors, log, json, success, kvList } from "../utils/logger.js";
 import { emitError } from "../utils/errors.js";
-/** Parse `bata new` args. No positional/flags today beyond --help (global
- *  flags like --json are stripped upstream in index.ts). Exported for tests. */
+/** Parse `bata new` args: optional `--team <id>` and `--help` (global flags
+ *  like --json are stripped upstream in index.ts). Exported for tests. */
 export function parseNewArgs(args) {
-    for (const arg of args) {
+    let team;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
         if (arg === "--help" || arg === "-h")
-            return { help: true };
+            return { team, help: true };
+        if (arg === "--team" && args[i + 1])
+            team = args[++i];
     }
-    return { help: false };
+    return { team, help: false };
 }
 function printHelp() {
     log();
     log(`  ${colors.bold("bata new")}`);
     log();
-    log(`  Create an instant, no-signup Postgres database and print how to connect.`);
-    log(`  You get a connection string immediately plus a one-time claim token.`);
-    log();
-    log(`  ${colors.bold("Claim it later")}`);
-    log(`    ${colors.cyan("bata claim <token>")}   Move the database into your team (clears the expiry)`);
-    log();
-    log(`  ${colors.yellow("Unclaimed databases are permanently DELETED at their expiry.")}`);
+    log(`  Create an instant Postgres database in your team and print how to connect.`);
+    log(`  One call, zero config — you get a connection string immediately.`);
+    log(`  Requires login — pass ${colors.cyan("--api-key")}, set ${colors.cyan("BATA_API_KEY")}, or run ${colors.cyan("bata login")}.`);
     log();
     log(`  ${colors.bold("Options")}`);
-    log(`    ${colors.dim("--json")}       Machine-readable output (includes the claim token)`);
-    log(`    ${colors.dim("--help, -h")}   Show this help`);
+    log(`    ${colors.dim("--team <id>")}   Team to create the database in (default: your team)`);
+    log(`    ${colors.dim("--json")}        Machine-readable output`);
+    log(`    ${colors.dim("--help, -h")}    Show this help`);
     log();
 }
 export async function newDb(args) {
@@ -44,33 +48,38 @@ export async function newDb(args) {
         printHelp();
         return;
     }
-    // No credentials: this hits the PUBLIC endpoint.
-    const res = await api.post("/v1/claim/new", {});
+    // Authed like every other command. Exits 4 NO_CREDENTIALS when absent.
+    const token = requireToken();
+    // Resolve the team unless one was passed explicitly. The server verifies
+    // membership either way.
+    const teamId = parsed.team ?? (await resolveTeamId(token));
+    const body = {};
+    if (teamId)
+        body.team_id = teamId;
+    const res = await api.post("/v1/claim/new", body, token);
     if (!res.ok) {
         const data = res.data;
         const code = data?.code;
         if (res.status === 404 && code === "CLAIMABLE_DISABLED") {
-            emitError("NOT_FOUND", "Instant databases (bata.new) are not enabled on this server.", "Contact the operator, or create a project with `bata create` after `bata login`.");
-        }
-        if (res.status === 503 || code === "CLAIM_POOL_EXHAUSTED") {
-            emitError("API_UNAVAILABLE", "The free database pool is full right now. Try again shortly.", "This is transient — retry in a minute.");
+            emitError("NOT_FOUND", "Instant databases (bata new) are not enabled on this server.", "Create a project with `bata create <name>` instead.");
         }
         if (res.status === 429) {
-            emitError("API_UNAVAILABLE", "Rate limit reached for instant databases from this network.", "Wait a bit before creating another, or claim one you already made.");
+            emitError("API_UNAVAILABLE", "Rate limit reached for instant databases from this network.", "Wait a bit before creating another.");
         }
         emitError("CLI_ERROR", apiError(res, "Failed to create instant database"));
     }
     const db = res.data;
+    saveConfig({ defaultProject: db.project_id });
     if (isJsonMode()) {
         json(db);
         return;
     }
     log();
-    success("Your instant database is ready to claim!");
+    success("Your instant database is ready!");
     log();
     kvList([
         ["Project ID", colors.dim(db.project_id)],
-        ["Expires", db.expires_at],
+        ["Team", colors.dim(db.team_id)],
     ]);
     log();
     log(`  ${colors.bold("Connection")}`);
@@ -80,11 +89,7 @@ export async function newDb(args) {
         ["Pooled", colors.dim(db.connection.pooled)],
     ]);
     log();
-    log(`  ${colors.bold("Claim token")} ${colors.dim("(shown once)")}`);
-    log(`    ${colors.cyan(db.claim_token)}`);
-    log();
-    log(`  ${colors.dim("Claim it into your team:")} ${colors.cyan(`bata claim ${db.claim_token}`)}`);
-    log(`  ${colors.yellow("Unclaimed databases are permanently DELETED at expiry.")}`);
+    log(`  ${colors.dim("Connect:")} ${colors.cyan("bata db url")}`);
     log(`  ${colors.dim("First connection may take a few seconds while the compute wakes.")}`);
     log();
 }

package/dist/index.js

@@ -13,6 +13,7 @@ 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 { link, unlink } from "./commands/link.js";
@@ -27,8 +28,8 @@ function help() {
     log(`    ${colors.cyan("bata")} ${colors.dim("<command>")} ${colors.dim("[options]")}`);
     log();
     log(`  ${colors.bold("Quick Start")}`);
-    log(`    ${colors.cyan("new")}                Instant no-signup database ${colors.dim("(no login) — claim it later")}`);
-    log(`    ${colors.cyan("claim <token>")}     Claim a ` + "`bata new`" + ` database into your team`);
+    log(`    ${colors.cyan("new")}                Instant database in your team ${colors.dim("(one call, zero config)")}`);
+    log(`    ${colors.cyan("claim <token>")}     ${colors.dim("Legacy: redeem a claim token from the retired anonymous flow")}`);
     log(`    ${colors.cyan("create <name>")}     Create a project and wait for it to be ready`);
     log(`    ${colors.cyan("connect <name>")}    Open psql to a project (auto-wakes if suspended)`);
     log(`    ${colors.cyan("status")}             Show all projects and their status`);
@@ -59,6 +60,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)")}`);
@@ -179,6 +184,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batadata/cli",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"