@batadata/cli 0.1.16 → 0.1.17

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/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";
@@ -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.16",
+  "version": "0.1.17",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"