@batadata/cli 0.2.12 → 0.2.14

package/README.md

@@ -103,6 +103,7 @@ flag always wins**, so linking never silently overrides an intentional request:
 | `db branch create` / `db branch delete` | Manage branches |
 | `db branch checkout <name-or-id>` | Pin a branch into the directory's link |
 | `db studio` | Open the table browser in your browser |
+| `studio` | Run Turbine Studio locally against a branch: a local web UI (`npx turbine-orm studio`) over a direct TCP connection, nothing hosted. Wakes the compute first. Read-only by default; PII redaction is turbine's UI feature, not a BataDB server control (`--project`, `--branch`, `--port`) |
 | `restore points` | List recovery points and the PITR window (see [Point-in-time restore](#point-in-time-restore-pitr)) |
 | `restore create` | Restore a branch to a timestamp/LSN as a **new** branch |
 | `schema check <file>` | Check a proposed schema change against live query traffic |

package/dist/commands/doctor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * bata doctor: run turbine's index doctor against a branch and (optionally)
+ * upload the report into the project's index-advice ledger.
+ *
+ * `turbine doctor --json` (turbine-orm >= 0.46) emits a versioned report
+ * (schemaVersion 1) of missing-index findings scored against live statistics.
+ * This command wires that to BataDB so a CI job can keep the advice ledger
+ * current with one line, instead of hand-rolling a curl of a piped JSON blob.
+ *
+ * Nothing here interprets the report: the control plane owns the contract, and
+ * an unknown schemaVersion is its 400 to give, not ours to guess at.
+ */
+export interface DoctorArgs {
+    project?: string;
+    branch?: string;
+    /** Skip the upload and just print the report. */
+    dryRun: boolean;
+    /** Pass `--unused`/`--audit` through to turbine doctor. */
+    unused: boolean;
+    audit: boolean;
+    help: boolean;
+}
+export declare function parseDoctorArgs(args: string[]): DoctorArgs | {
+    error: string;
+};
+export declare function doctorCommand(args: string[]): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,201 @@
+/**
+ * bata doctor: run turbine's index doctor against a branch and (optionally)
+ * upload the report into the project's index-advice ledger.
+ *
+ * `turbine doctor --json` (turbine-orm >= 0.46) emits a versioned report
+ * (schemaVersion 1) of missing-index findings scored against live statistics.
+ * This command wires that to BataDB so a CI job can keep the advice ledger
+ * current with one line, instead of hand-rolling a curl of a piped JSON blob.
+ *
+ * Nothing here interprets the report: the control plane owns the contract, and
+ * an unknown schemaVersion is its 400 to give, not ours to guess at.
+ */
+import { spawn } from "node:child_process";
+import { api, apiError } from "../api.js";
+import { requireToken, isJsonMode } from "../config.js";
+import { colors, log, spinner, info as logInfo } from "../utils/logger.js";
+import { emitError } from "../utils/errors.js";
+import { resolveProjectId, readLinkFile } from "../link.js";
+export function parseDoctorArgs(args) {
+    const out = { dryRun: false, unused: false, audit: false, help: false };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        const takeVal = (flag) => {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("-"))
+                return undefined;
+            i++;
+            return next;
+        };
+        if (a === "--help" || a === "-h") {
+            out.help = true;
+        }
+        else if (a === "--project" || a === "-p") {
+            const v = takeVal("--project");
+            if (v === undefined)
+                return { error: "--project requires a value" };
+            out.project = v;
+        }
+        else if (a.startsWith("--project=")) {
+            out.project = a.slice("--project=".length);
+        }
+        else if (a === "--branch" || a === "-b") {
+            const v = takeVal("--branch");
+            if (v === undefined)
+                return { error: "--branch requires a value" };
+            out.branch = v;
+        }
+        else if (a.startsWith("--branch=")) {
+            out.branch = a.slice("--branch=".length);
+        }
+        else if (a === "--dry-run") {
+            out.dryRun = true;
+        }
+        else if (a === "--unused") {
+            out.unused = true;
+        }
+        else if (a === "--audit") {
+            out.audit = true;
+        }
+        else {
+            return { error: `Unknown argument: ${a}` };
+        }
+    }
+    return out;
+}
+function doctorHelp() {
+    log();
+    log(`  ${colors.bold("bata doctor")}: index advice from turbine doctor, into your ledger`);
+    log();
+    log(`  ${colors.dim("Usage:")}`);
+    log(`    bata doctor upload [--project <id>] [--branch <name|id>] [--dry-run]`);
+    log();
+    log(`  ${colors.dim("Runs `turbine doctor --json` against the branch's direct connection and")}`);
+    log(`  ${colors.dim("imports the findings into the project's index-advice ledger. Re-imports")}`);
+    log(`  ${colors.dim("refresh the numbers; advice you dismissed stays dismissed.")}`);
+    log();
+    log(`  ${colors.dim("--project <id>       Target project (default: linked/default project)")}`);
+    log(`  ${colors.dim("--branch <name|id>   Target branch (default: checked-out, else primary)")}`);
+    log(`  ${colors.dim("--dry-run            Print the report; do not upload")}`);
+    log(`  ${colors.dim("--unused             Also collect never-scanned/redundant index advice")}`);
+    log(`  ${colors.dim("--audit              Also audit previously-suggested indexes")}`);
+    log();
+    log(`  ${colors.dim("Requires turbine-orm >= 0.46 (fetched via npx if not installed).")}`);
+    log();
+}
+/** Run `turbine doctor --json` and capture stdout. */
+function runTurbineDoctor(databaseUrl, flags) {
+    return new Promise((resolve) => {
+        const child = spawn("npx", ["--yes", "turbine-orm@latest", "doctor", "--json", ...flags], {
+            env: { ...process.env, DATABASE_URL: databaseUrl },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", (err) => {
+            resolve({ ok: false, error: `Could not run turbine doctor: ${err.message}` });
+        });
+        child.on("close", (code) => {
+            // doctor exits non-zero when it HAS findings, which is not a failure for
+            // us: parse first, and only treat unparseable output as an error.
+            const start = stdout.indexOf("{");
+            if (start === -1) {
+                resolve({
+                    ok: false,
+                    error: `turbine doctor produced no JSON report (exit ${code}). ${stderr.trim().slice(0, 300)}`,
+                });
+                return;
+            }
+            try {
+                resolve({ ok: true, report: JSON.parse(stdout.slice(start)) });
+            }
+            catch (err) {
+                resolve({ ok: false, error: `Could not parse the doctor report: ${String(err)}` });
+            }
+        });
+    });
+}
+export async function doctorCommand(args) {
+    const sub = args[0] === "upload" ? args.slice(1) : args;
+    const parsed = parseDoctorArgs(sub);
+    if ("error" in parsed) {
+        emitError("INVALID_FLAG", parsed.error, "Usage: bata doctor upload [--project <id>] [--branch <name|id>]");
+    }
+    if (parsed.help) {
+        doctorHelp();
+        return;
+    }
+    const token = requireToken();
+    const projectId = parsed.project ?? resolveProjectId().projectId;
+    if (!projectId) {
+        emitError("NO_PROJECT", "No project specified.", "Pass --project <id>, or run `bata link <project>` to set a default.");
+    }
+    const s = spinner("Fetching connection info");
+    const connRes = await api.get(`/v1/connection-info/${projectId}`, token, { reveal: "true" });
+    if (!connRes.ok || !connRes.data?.connections?.length) {
+        s.stop();
+        emitError(connRes.status >= 500 || connRes.status === 0 ? "API_UNAVAILABLE" : "NOT_FOUND", apiError(connRes, "Could not fetch connection info for this project."), "");
+    }
+    // Branch precedence matches `db query`: --branch, else the checked-out branch
+    // when it belongs to this project, else primary.
+    const link = readLinkFile()?.link;
+    const pinned = link && link.projectId === projectId ? link.branchId ?? undefined : undefined;
+    const branchRef = parsed.branch ?? pinned;
+    const conns = connRes.data.connections;
+    const conn = branchRef
+        ? conns.find((c) => c.branch_id === branchRef || c.branch_name === branchRef)
+        : conns.find((c) => c.is_primary) ?? conns[0];
+    if (!conn?.direct) {
+        s.stop();
+        emitError("BRANCH_NOT_FOUND", branchRef
+            ? `Branch "${branchRef}" not found, or it has no direct connection.`
+            : "No direct connection string available for this project.", "List branches with: bata db branches --json");
+    }
+    s.update("Running turbine doctor");
+    const flags = [];
+    if (parsed.unused)
+        flags.push("--unused");
+    if (parsed.audit)
+        flags.push("--audit");
+    const result = await runTurbineDoctor(conn.direct, flags);
+    s.stop();
+    if (!result.ok) {
+        emitError("CLI_ERROR", result.error, "Requires turbine-orm >= 0.46 for `doctor --json`.");
+    }
+    const report = result.report;
+    const findingCount = Array.isArray(report.findings) ? report.findings.length : 0;
+    if (parsed.dryRun) {
+        if (isJsonMode()) {
+            log(JSON.stringify(report, null, 2));
+        }
+        else {
+            logInfo(`${findingCount} finding(s); not uploaded (--dry-run)`);
+            log(JSON.stringify(report, null, 2));
+        }
+        return;
+    }
+    const s2 = spinner("Uploading to the index-advice ledger");
+    const importRes = await api.post(`/v1/projects/${projectId}/index-advice/import`, report, token);
+    s2.stop();
+    if (!importRes.ok) {
+        emitError(importRes.status === 401 || importRes.status === 403
+            ? "INVALID_KEY"
+            : importRes.status >= 500 || importRes.status === 0
+                ? "API_UNAVAILABLE"
+                : "CLI_ERROR", apiError(importRes, "Could not import the doctor report."), "");
+    }
+    const data = importRes.data;
+    if (isJsonMode()) {
+        log(JSON.stringify({ ...data, branch: conn.branch_name ?? conn.branch_id }, null, 2));
+        return;
+    }
+    logInfo(`Imported ${colors.bold(String(data.imported))} new and refreshed ${colors.bold(String(data.updated))} existing recommendation(s)` +
+        (conn.branch_name ? ` from ${colors.cyan(conn.branch_name)}` : ""));
+    if (data.invalidIndexes > 0) {
+        log(`  ${colors.dim(`${data.invalidIndexes} invalid index(es) reported; see the console for cleanup SQL.`)}`);
+    }
+    log(`  ${colors.dim("Review them in the console under Insights, or with:")}`);
+    log(`  ${colors.dim(`bata db query "..." --json`)} ${colors.dim("/ GET /v1/projects/" + projectId + "/index-advice")}`);
+}

package/dist/commands/studio.d.ts

@@ -0,0 +1,31 @@
+/**
+ * bata studio: launch turbine-orm's Studio locally against a BataDB branch.
+ *
+ * Zero hosting infra: resolves the branch's DIRECT connection URI from the
+ * control plane, wakes the compute if it scaled to zero, then spawns
+ * `npx --yes turbine-orm@latest studio` with DATABASE_URL set. Studio itself
+ * is turbine's local web UI (loopback-only, read-only by default); everything
+ * it renders travels over a direct TCP connection from this machine.
+ *
+ * Compat-honest: PII redaction in Studio is turbine's feature (PII-tagged
+ * columns are redacted by default, `--show-pii` unredacts), not something
+ * BataDB enforces server-side.
+ */
+export interface StudioArgs {
+    project?: string;
+    branch?: string;
+    port?: number;
+    write: boolean;
+    showPii: boolean;
+    noOpen: boolean;
+    help: boolean;
+}
+/**
+ * Parse `bata studio` args (both `--flag value` and `--flag=value` forms).
+ * Returns `{ error }` on a malformed flag so the caller can fail fast with
+ * INVALID_FLAG before touching the network. Exported for unit testing.
+ */
+export declare function parseStudioArgs(args: string[]): StudioArgs | {
+    error: string;
+};
+export declare function studio(args?: string[]): Promise<void>;

package/dist/commands/studio.js

@@ -0,0 +1,262 @@
+/**
+ * bata studio: launch turbine-orm's Studio locally against a BataDB branch.
+ *
+ * Zero hosting infra: resolves the branch's DIRECT connection URI from the
+ * control plane, wakes the compute if it scaled to zero, then spawns
+ * `npx --yes turbine-orm@latest studio` with DATABASE_URL set. Studio itself
+ * is turbine's local web UI (loopback-only, read-only by default); everything
+ * it renders travels over a direct TCP connection from this machine.
+ *
+ * Compat-honest: PII redaction in Studio is turbine's feature (PII-tagged
+ * columns are redacted by default, `--show-pii` unredacts), not something
+ * BataDB enforces server-side.
+ */
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { api, asList, apiError } from "../api.js";
+import { requireToken, loadConfig, isJsonMode } from "../config.js";
+import { colors, log, spinner, info as logInfo } from "../utils/logger.js";
+import { emitError, isRetryable } from "../utils/errors.js";
+import { resolveProjectId, readLinkFile } from "../link.js";
+/**
+ * Parse `bata studio` args (both `--flag value` and `--flag=value` forms).
+ * Returns `{ error }` on a malformed flag so the caller can fail fast with
+ * INVALID_FLAG before touching the network. Exported for unit testing.
+ */
+export function parseStudioArgs(args) {
+    const out = { write: false, showPii: false, noOpen: false, help: false };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        const takeVal = (flag) => {
+            const next = args[++i];
+            if (next === undefined || next.startsWith("-")) {
+                return { error: `${flag} requires a value.` };
+            }
+            return next;
+        };
+        let v;
+        if (a === "--project") {
+            v = takeVal("--project");
+            if (typeof v !== "string")
+                return v;
+            out.project = v;
+        }
+        else if (a.startsWith("--project=")) {
+            out.project = a.slice("--project=".length);
+        }
+        else if (a === "--branch") {
+            v = takeVal("--branch");
+            if (typeof v !== "string")
+                return v;
+            out.branch = v;
+        }
+        else if (a.startsWith("--branch=")) {
+            out.branch = a.slice("--branch=".length);
+        }
+        else if (a === "--port" || a.startsWith("--port=")) {
+            const raw = a === "--port" ? takeVal("--port") : a.slice("--port=".length);
+            if (typeof raw !== "string")
+                return raw;
+            const n = Number(raw);
+            if (!Number.isInteger(n) || n <= 0 || n > 65535) {
+                return { error: `Invalid port "${raw}". Use an integer between 1 and 65535.` };
+            }
+            out.port = n;
+        }
+        else if (a === "--write") {
+            out.write = true;
+        }
+        else if (a === "--show-pii") {
+            out.showPii = true;
+        }
+        else if (a === "--no-open") {
+            out.noOpen = true;
+        }
+        else if (a === "--help" || a === "-h") {
+            out.help = true;
+        }
+        else {
+            return { error: `Unknown flag "${a}".` };
+        }
+    }
+    return out;
+}
+function studioHelp() {
+    const usage = (line) => log(`  ${colors.cyan(line)}`);
+    const note = (line) => log(`  ${colors.dim(line)}`);
+    log();
+    log(`  ${colors.bold("bata studio")}: launch Turbine Studio locally against a BataDB branch`);
+    log();
+    usage("bata studio [--project <id|name>] [--branch <name|id>] [--port <n>]");
+    usage("bata studio [--write] [--show-pii] [--no-open]");
+    log();
+    note("Runs turbine-orm's Studio on YOUR machine (npx turbine-orm@latest studio)");
+    note("over a direct TCP connection to the branch. Nothing is hosted by BataDB;");
+    note("close the terminal and it's gone.");
+    log();
+    note("--project <id|name>  Target project (default: linked/default project)");
+    note("--branch <name|id>   Target branch (default: the checked-out branch from");
+    note("                     `bata db branch checkout`, else the primary branch)");
+    note("--port <n>           Local port for Studio (default: turbine's 4983)");
+    note("--write              Forwarded to turbine: enable single-row writes (default read-only)");
+    note("--show-pii           Forwarded to turbine: show PII-tagged columns unredacted");
+    note("--no-open            Forwarded to turbine: don't auto-open the browser");
+    log();
+    note("Honesty notes: Studio binds to loopback only and is read-only by default.");
+    note("PII redaction is turbine's client-side feature (PII-tagged columns are");
+    note("redacted in the UI), NOT a BataDB server-side control: the direct");
+    note("connection itself sees real data.");
+    note("A scaled-to-zero compute is woken first; that can take a few seconds.");
+    log();
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Wake a branch's compute and wait until it answers a query. Kicks the start
+ * endpoint when the compute reports suspended, then probes with `SELECT 1`
+ * via /v1/sql/execute: retryable failures (503 COMPUTE_STARTING, connection
+ * refused) keep polling; a hard failure stops early (Studio's own connection
+ * will surface the real error). Budget exhausted → COMPUTE_STARTING (exit 6),
+ * the retryable contract agents already know.
+ */
+async function wakeBranch(branchId, computeStatus, token, onTick) {
+    if (computeStatus === "suspended") {
+        // Non-fatal if it fails: the probe below (or the proxy) can still wake it.
+        await api.post(`/v1/computes/${branchId}/start`, {}, token).catch(() => undefined);
+    }
+    const budget = 120_000;
+    const interval = 3_000;
+    const start = Date.now();
+    while (true) {
+        const res = await api.post("/v1/sql/execute", { branch_id: branchId, query: "SELECT 1" }, token);
+        if (res.ok && !res.data?.error)
+            return;
+        const body = res.data;
+        const retryable = isRetryable({ status: res.status, code: body?.code, message: body?.error });
+        if (!retryable)
+            return; // hard failure: let Studio's own connection report it
+        if (Date.now() - start >= budget) {
+            emitError("COMPUTE_STARTING", apiError(res, "Compute is still starting"), "compute is starting; retry `bata studio` in a few seconds");
+        }
+        onTick(Math.round((Date.now() - start) / 1000));
+        await sleep(interval);
+    }
+}
+export async function studio(args = []) {
+    const parsed = parseStudioArgs(args);
+    if ("error" in parsed) {
+        emitError("INVALID_FLAG", parsed.error, "Usage: bata studio [--project <id|name>] [--branch <name|id>] [--port <n>]");
+    }
+    if (parsed.help) {
+        studioHelp();
+        return;
+    }
+    // Studio is a long-running local web server with browser interaction; there
+    // is no headless JSON equivalent. Point agents at the headless surfaces.
+    if (isJsonMode()) {
+        emitError("INTERACTIVE_ONLY", "bata studio launches a local web UI and can't run in --json mode.", "Use `bata db query <sql> --json` or `bata schema dump` for headless access.");
+    }
+    const token = requireToken();
+    const config = loadConfig();
+    // Project precedence: --project (id OR name, resolved against /v1/projects)
+    // > .batadata link > config default.
+    let projectId = resolveProjectId().projectId;
+    if (parsed.project) {
+        const s = spinner("Looking up project");
+        const query = {};
+        if (config.defaultTeam)
+            query.team_id = config.defaultTeam;
+        const projRes = await api.get("/v1/projects", token, query);
+        s.stop();
+        if (!projRes.ok) {
+            emitError(projRes.status === 401 || projRes.status === 403 ? "INVALID_KEY"
+                : projRes.status >= 500 || projRes.status === 0 ? "API_UNAVAILABLE"
+                    : "CLI_ERROR", apiError(projRes, "Failed to fetch projects."), "");
+        }
+        const found = asList(projRes.data).find((p) => p.id === parsed.project || p.name === parsed.project);
+        if (!found) {
+            emitError("NOT_FOUND", `Project "${parsed.project}" not found.`, "List projects with: bata status");
+        }
+        projectId = found.id;
+    }
+    if (!projectId) {
+        emitError("NO_PROJECT", "No project specified.", "Pass --project <id|name>, or run `bata link <project>` to set a default.");
+    }
+    const s = spinner("Fetching connection info");
+    const connRes = await api.get(`/v1/connection-info/${projectId}`, token, { reveal: "true" });
+    if (!connRes.ok || !connRes.data?.connections?.length) {
+        s.stop();
+        emitError(connRes.status >= 500 || connRes.status === 0 ? "API_UNAVAILABLE" : "NOT_FOUND", apiError(connRes, "Could not fetch connection info for this project."), "");
+    }
+    const conns = connRes.data.connections;
+    // Branch precedence: an explicit --branch wins, else the branch pinned by
+    // `bata db branch checkout` in .batadata/project.json, but ONLY when studio
+    // targets the linked project (same guard as `db query`: a pinned branch from
+    // project A must never resolve against an explicit --project B).
+    const link = readLinkFile()?.link;
+    const pinnedBranch = link && link.projectId === projectId ? link.branchId ?? undefined : undefined;
+    const branchRef = parsed.branch ?? pinnedBranch;
+    const conn = branchRef
+        ? conns.find((c) => c.branch_id === branchRef || c.branch_name === branchRef)
+        : conns.find((c) => c.is_primary) ?? conns[0];
+    if (!conn) {
+        s.stop();
+        emitError("BRANCH_NOT_FOUND", `Branch "${branchRef}" not found in this project.`, "List branches with: bata db branches --json");
+    }
+    if (!conn.direct || !conn.branch_id) {
+        s.stop();
+        emitError("NOT_FOUND", "No direct connection string available for this branch.", "");
+    }
+    // BataDB computes scale to zero: wake the branch before handing the URI to
+    // Studio, so its first introspection doesn't hit a cold compute and die.
+    s.update("Waking compute");
+    await wakeBranch(conn.branch_id, conn.compute_status, token, (secs) => {
+        s.update(`Waking compute (${secs}s)`);
+    });
+    s.stop();
+    log();
+    logInfo(`Launching Turbine Studio for ${colors.cyan(connRes.data.project_name ?? projectId)}`
+        + (conn.branch_name ? ` ${colors.dim(`branch ${conn.branch_name}`)}` : ""));
+    log(`  ${colors.dim("Local UI over a direct TCP connection. Read-only by default;")}`);
+    log(`  ${colors.dim("PII redaction is turbine's UI feature, not a BataDB server control.")}`);
+    log(`  ${colors.dim("Press Ctrl+C to stop.")}`);
+    log();
+    // Run npx from a scratch dir so a turbine.config.* in the user's cwd can
+    // never override the DATABASE_URL we resolved (turbine's env wins over its
+    // config file, but a scratch cwd removes the question entirely). Studio
+    // introspects the live DB, so no config/client generation is needed.
+    const scratchDir = mkdtempSync(path.join(os.tmpdir(), "bata-studio-"));
+    const cleanup = () => {
+        try {
+            rmSync(scratchDir, { recursive: true, force: true });
+        }
+        catch {
+            /* best effort */
+        }
+    };
+    const turbineArgs = ["--yes", "turbine-orm@latest", "studio"];
+    if (parsed.port !== undefined)
+        turbineArgs.push("--port", String(parsed.port));
+    if (parsed.write)
+        turbineArgs.push("--write");
+    if (parsed.showPii)
+        turbineArgs.push("--show-pii");
+    if (parsed.noOpen)
+        turbineArgs.push("--no-open");
+    const child = spawn("npx", turbineArgs, {
+        cwd: scratchDir,
+        stdio: "inherit",
+        env: { ...process.env, DATABASE_URL: conn.direct },
+    });
+    child.on("error", (err) => {
+        cleanup();
+        emitError("CLI_ERROR", `Failed to launch turbine-orm studio via npx: ${err.message}`, "Is npx (Node.js) on your PATH?");
+    });
+    child.on("exit", (code) => {
+        cleanup();
+        process.exit(code ?? 0);
+    });
+}

package/dist/index.js

@@ -17,6 +17,8 @@ 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 { studio } from "./commands/studio.js";
+import { doctorCommand } from "./commands/doctor.js";
 import { link, unlink } from "./commands/link.js";
 import { parseGlobalFlags } from "./args.js";
 import { isJsonMode } from "./config.js";
@@ -63,6 +65,8 @@ function help() {
     log(`    ${colors.cyan("db branch delete")}   Delete a branch`);
     log(`    ${colors.cyan("db branch checkout")} Pin a branch into ${colors.dim(".batadata/project.json")}`);
     log(`    ${colors.cyan("db studio")}          Open table browser in browser`);
+    log(`    ${colors.cyan("studio")}             Run Turbine Studio locally against a branch ${colors.dim("(local UI, direct TCP)")}`);
+    log(`    ${colors.cyan("doctor upload")}      Import turbine index advice into the project ledger`);
     log(`    ${colors.cyan("db query")}           Run a SQL query ${colors.dim("(--branch <id> to target a branch)")}`);
     log();
     log(`  ${colors.bold("Compute")}`);
@@ -220,6 +224,13 @@ async function main() {
             case "import":
                 await importDb(rest);
                 break;
+            // Local Turbine Studio against a branch
+            case "doctor":
+                await doctorCommand(rest);
+                break;
+            case "studio":
+                await studio(rest);
+                break;
             // Dev
             case "dev":
                 await dev();

package/package.json

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