@batadata/cli 0.1.3 → 0.1.5

package/dist/api.js

@@ -14,7 +14,7 @@ export async function request(method, path, options = {}) {
     }
     const headers = {
         "Content-Type": "application/json",
-        "User-Agent": "@batadata/cli 0.1.3",
+        "User-Agent": "@batadata/cli 0.1.4",
     };
     if (options.token) {
         headers["Authorization"] = `Bearer ${options.token}`;

package/dist/commands/db.js

@@ -36,26 +36,46 @@ function formatDate(iso) {
  * when the compute is ready to serve a query without a cold start.
  */
 function branchStatusLabel(b) {
-    const base = b.computeStatus || b.status || "-";
+    const base = b.computeStatus || "-";
     if (b.ready === true)
         return `${base} ${colors.green("✓")}`;
     return base;
 }
 /**
- * Resolve a project's primary branch (the one to run a query against). Lists
- * branches the same way `db branches` does (GET /v1/projects/:id) and returns
- * the primary, falling back to the first branch. Returns null if the project
- * has no branches or the lookup failed.
+ * List a project's branches (GET /v1/projects/:id), each enriched by the server
+ * with computeStatus + ready. Returns null if the lookup failed.
  */
-async function getPrimaryBranch(projectId, token, teamId) {
+async function listBranches(projectId, token, teamId) {
     const query = {};
     if (teamId)
         query.team_id = teamId;
     const res = await api.get(`/v1/projects/${projectId}`, token, query);
     if (!res.ok)
         return null;
-    const list = res.data.branches ?? [];
-    return list.find((b) => b.is_primary) ?? list[0] ?? null;
+    return { branches: res.data.branches ?? [], projectName: res.data.name };
+}
+/**
+ * Resolve a project's primary branch (the one to run a query against), falling
+ * back to the first branch. Returns null if the project has no branches or the
+ * lookup failed.
+ */
+async function getPrimaryBranch(projectId, token, teamId) {
+    const result = await listBranches(projectId, token, teamId);
+    if (!result)
+        return null;
+    return result.branches.find((b) => b.isPrimary) ?? result.branches[0] ?? null;
+}
+/**
+ * Resolve a `--branch` reference — which may be a branch ID **or** a branch
+ * name — to a concrete branch. Agents naturally pass the name (the same string
+ * they used with `db branch create`), so accepting only an id was a footgun
+ * ("Branch not found"). Returns null if no branch matches.
+ */
+async function resolveBranchRef(projectId, token, teamId, ref) {
+    const result = await listBranches(projectId, token, teamId);
+    if (!result)
+        return null;
+    return result.branches.find((b) => b.id === ref || b.name === ref) ?? null;
 }
 export async function connect() {
     // psql is an interactive session — there's no headless equivalent. Don't spawn
@@ -123,38 +143,31 @@ export async function branches() {
         emitError("NO_PROJECT", "No default project set.", "Set one with: bata projects info <id>");
     }
     const s = jsonMode ? null : spinner("Fetching branches");
-    const query = {};
-    if (config.defaultTeam)
-        query.team_id = config.defaultTeam;
-    const res = await api.get(`/v1/projects/${projectId}`, token, query);
+    const result = await listBranches(projectId, token, config.defaultTeam);
     s?.stop();
-    if (!res.ok) {
-        emitError(res.status === 401 || res.status === 403 ? "INVALID_KEY"
-            : res.status === 404 ? "NO_PROJECT"
-                : res.status >= 500 || res.status === 0 ? "API_UNAVAILABLE"
-                    : "CLI_ERROR", apiError(res, "Failed to fetch branches"), "");
+    if (!result) {
+        emitError("API_UNAVAILABLE", "Failed to fetch branches.", "");
     }
-    const branchList = res.data.branches || [];
+    const branchList = result.branches;
     if (jsonMode) {
         json({
             project_id: projectId,
-            project_name: res.data.name,
+            project_name: result.projectName,
             branches: branchList.map((b) => ({
                 id: b.id,
                 name: b.name,
-                is_primary: b.is_primary,
-                status: b.status,
+                is_primary: b.isPrimary ?? false,
                 // Compute readiness — what agents poll on between a create/cold start
                 // and a successful query.
                 computeStatus: b.computeStatus ?? null,
                 ready: b.ready ?? null,
-                created_at: b.created_at,
+                created_at: b.createdAt ?? null,
             })),
             count: branchList.length,
         });
         return;
     }
-    heading(`Branches — ${res.data.name}`);
+    heading(`Branches — ${result.projectName}`);
     if (branchList.length === 0) {
         log(`  ${colors.dim("No branches found.")}`);
         log();
@@ -162,11 +175,11 @@ export async function branches() {
     }
     table(["NAME", "PRIMARY", "STATUS", "CREATED"], branchList.map((b) => [
         b.name,
-        b.is_primary ? colors.green("yes") : "-",
-        // Prefer the live compute lifecycle (computeStatus); fall back to the
-        // branch row status. Mark ready with a check so the column is scannable.
+        b.isPrimary ? colors.green("yes") : "-",
+        // Live compute lifecycle (computeStatus), with a check once ready so the
+        // column is scannable.
         branchStatusLabel(b),
-        formatDate(b.created_at),
+        formatDate(b.createdAt ?? ""),
     ]));
     log();
 }
@@ -275,10 +288,11 @@ export async function studio() {
     openBrowser(studioUrl);
 }
 /**
- * Pull a `--branch <id>` / `--branch=<id>` flag out of the query args and return
- * the explicit branch id (if any) plus the remaining args, which join into the
- * SQL string. Keeps `db query` order-independent (the flag can sit before or
- * after the SQL) and consistent with how global flags are parsed.
+ * Pull a `--branch <ref>` / `--branch=<ref>` flag out of the query args and
+ * return the explicit branch ref — an id OR a name, resolved later — plus the
+ * remaining args, which join into the SQL string. Keeps `db query`
+ * order-independent (the flag can sit before or after the SQL) and consistent
+ * with how global flags are parsed.
  */
 function parseBranchFlag(args) {
     let branchId;
@@ -311,11 +325,22 @@ export async function query(args = []) {
         emitError("NO_PROJECT", "No default project set.", "Set one with: bata projects info <id>");
     }
     const s = jsonMode ? null : spinner("Running query");
-    // Target branch: an explicit --branch <id> wins; otherwise resolve the
-    // project's primary branch. /v1/sql/execute is keyed on branch_id, not
-    // project. (The old code POSTed to /v1/query/:projectId, which 404s.)
-    let branchId_ = branchId;
-    if (!branchId_) {
+    // Target branch: an explicit --branch <id-or-name> wins; otherwise resolve
+    // the project's primary branch. /v1/sql/execute is keyed on branch_id, not
+    // project. (The old code POSTed to /v1/query/:projectId, which 404s.) We
+    // resolve the --branch value against the project's branch list so a NAME
+    // works too — sending a name straight through as branch_id 404'd ("Branch
+    // not found").
+    let branchId_;
+    if (branchId) {
+        const branch = await resolveBranchRef(projectId, token, config.defaultTeam, branchId);
+        if (!branch) {
+            s?.stop();
+            emitError("BRANCH_NOT_FOUND", `Branch "${branchId}" not found in this project.`, "List branches with: bata db branches --json");
+        }
+        branchId_ = branch.id;
+    }
+    else {
         const branch = await getPrimaryBranch(projectId, token, config.defaultTeam);
         if (!branch) {
             s?.stop();
@@ -401,9 +426,9 @@ function dbHelp(sub) {
             log(`  ${colors.bold("bata db query")} — run a SQL query against a branch`);
             log();
             usage('bata db query "SELECT 1"');
-            usage("bata db query <sql> [--branch <branch_id>] [--json]");
+            usage("bata db query <sql> [--branch <id-or-name>] [--json]");
             log();
-            note("--branch <branch_id>   Target a specific branch (default: the project's primary)");
+            note("--branch <id-or-name>  Target a specific branch by id OR name (default: the project's primary)");
             note("--json                 Emit rows as JSON objects + row_count");
             note("Cold-start note: a just-created/idle branch may answer with exit 6");
             note("(retryable) while its compute wakes — retry in a few seconds.");
@@ -447,7 +472,7 @@ function dbHelp(sub) {
             usage("bata db branch create    Create a new branch");
             usage("bata db branch delete    Delete a branch");
             usage("bata db studio           Open the table browser");
-            usage("bata db query <sql>      Run a SQL query (--branch <id> to target a branch)");
+            usage("bata db query <sql>      Run a SQL query (--branch <id-or-name> to target a branch)");
             log();
             note("Add --help to any subcommand for details (e.g. bata db query --help).");
     }

package/dist/commands/dev.js

@@ -4,7 +4,7 @@ export async function dev() {
     log(`  Get started with BataDB in your project:`);
     log();
     log(`  ${colors.cyan("1.")} ${colors.bold("Install the ORM")}`);
-    log(`     ${colors.dim("npm install @batadata/turbine")}`);
+    log(`     ${colors.dim("npm install turbine-orm")}`);
     log();
     log(`  ${colors.cyan("2.")} ${colors.bold("Set your database URL")}`);
     log(`     ${colors.dim("Add DATABASE_URL to your .env file:")}`);
@@ -14,10 +14,16 @@ export async function dev() {
     log(`     ${colors.dim("bata generate")}`);
     log();
     log(`  ${colors.cyan("4.")} ${colors.bold("Import and query")}`);
-    log(`     ${colors.dim("import { turbine } from '@batadata/turbine'")}`);
-    log(`     ${colors.dim("const db = turbine('DATABASE_URL')")}`);
+    log(`     ${colors.dim("import { turbine } from './generated/turbine'")}`);
+    log(`     ${colors.dim("const db = turbine({ connectionString: process.env.DATABASE_URL })")}`);
     log(`     ${colors.dim("const users = await db.users.findMany()")}`);
     log();
+    log(`  ${colors.dim("On the edge? Bind BataDB's HTTP driver to Turbine with zero glue:")}`);
+    log(`     ${colors.dim("import { turbineHttp } from 'turbine-orm/serverless'")}`);
+    log(`     ${colors.dim("import { Pool } from '@batadata/serverless'")}`);
+    log(`     ${colors.dim("import { SCHEMA } from './generated/turbine/metadata.js'")}`);
+    log(`     ${colors.dim("const db = turbineHttp(new Pool({ connectionString: process.env.DATABASE_URL }), SCHEMA)")}`);
+    log();
     log(`  ${colors.bold("Useful commands:")}`);
     log(`    ${colors.cyan("bata db connect")}     Open psql shell`);
     log(`    ${colors.cyan("bata db studio")}      Open visual table browser`);

package/dist/commands/generate.js

@@ -4,21 +4,21 @@ function printHelp() {
     log();
     log(`  ${colors.bold("bata generate")} ${colors.dim("— generate types from your database schema")}`);
     log();
-    log(`  Runs the Turbine type generator (${colors.dim("@batadata/turbine")}) against your`);
+    log(`  Runs the Turbine type generator (${colors.dim("turbine-orm")}) against your`);
     log(`  database, producing typed query bindings.`);
     log();
     log(`  ${colors.bold("Options")}`);
     log(`    ${colors.dim("--watch, -w")}   Regenerate on schema changes`);
     log(`    ${colors.dim("--help, -h")}    Show this help`);
     log();
-    log(`  ${colors.dim("Requires @batadata/turbine. Install with:")} ${colors.cyan("npm install @batadata/turbine")}`);
+    log(`  ${colors.dim("Requires turbine-orm. Install with:")} ${colors.cyan("npm install turbine-orm")}`);
     log();
 }
 /**
  * Resolve a runnable Turbine binary without invoking the network.
- * Prefers a locally installed binary; falls back to none (we do NOT
- * silently shell out to `npx`, which would try to download an unpublished
- * package and hang/crash).
+ * Prefers a locally installed binary (the `turbine` bin shipped by the
+ * `turbine-orm` package); falls back to a global install on PATH. We do NOT
+ * silently shell out to `npx`, which would trigger a download/prompt.
  */
 function resolveTurbine() {
     // 1. Local node_modules binary
@@ -46,10 +46,11 @@ export async function generate(args) {
     if (!turbine) {
         error("Turbine is not installed.");
         log();
-        log(`  ${colors.dim("`bata generate` uses the Turbine type generator, which is not")}`);
-        log(`  ${colors.dim("bundled with the CLI. Install it in your project first:")}`);
+        log(`  ${colors.dim("`bata generate` uses the Turbine type generator (the `turbine` bin")}`);
+        log(`  ${colors.dim("from turbine-orm), which is not bundled with the CLI. Install it")}`);
+        log(`  ${colors.dim("in your project first:")}`);
         log();
-        log(`    ${colors.cyan("npm install @batadata/turbine")}`);
+        log(`    ${colors.cyan("npm install turbine-orm")}`);
         log();
         log(`  ${colors.dim("Then run")} ${colors.cyan("bata generate")} ${colors.dim("again.")}`);
         log();
@@ -71,7 +72,7 @@ export async function generate(args) {
     });
     child.on("error", (err) => {
         warn(`Failed to run turbine generate: ${err.message}`);
-        error("Make sure @batadata/turbine is installed and on your PATH.");
+        error("Make sure turbine-orm is installed and its `turbine` bin is on your PATH.");
         process.exit(1);
     });
     child.on("exit", (code) => {

package/dist/config.js

@@ -1,7 +1,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-const CONFIG_PATH = path.join(os.homedir(), ".batarc");
+/**
+ * Resolve the `~/.batarc` path at CALL time, not import time. Reading
+ * `os.homedir()` once into a top-level const freezes the home directory before
+ * anything can override HOME — which silently breaks (a) users who set a custom
+ * HOME and (b) tests that redirect HOME to a temp dir (the redirect would be
+ * ignored and the suite would read the developer's REAL ~/.batarc). Preferring
+ * the env vars makes the override deterministic across platforms.
+ */
+function configPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, ".batarc");
+}
 const DEFAULT_API_URL = "https://api.batadata.com";
 const runtime = { json: false, yes: false };
 export function setRuntime(ctx) {
@@ -23,7 +34,7 @@ export function isYes() {
 }
 export function loadConfig() {
     try {
-        const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+        const raw = fs.readFileSync(configPath(), "utf-8");
         return JSON.parse(raw);
     }
     catch {
@@ -33,11 +44,11 @@ export function loadConfig() {
 export function saveConfig(config) {
     const existing = loadConfig();
     const merged = { ...existing, ...config };
-    fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+    fs.writeFileSync(configPath(), JSON.stringify(merged, null, 2) + "\n", "utf-8");
 }
 export function clearConfig() {
     try {
-        fs.unlinkSync(CONFIG_PATH);
+        fs.unlinkSync(configPath());
     }
     catch {
         // File doesn't exist, that's fine

package/dist/index.js

@@ -15,7 +15,7 @@ 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.3";
+const VERSION = "0.1.4";
 function help() {
     banner();
     log(`  ${colors.bold("Usage")}`);

package/dist/utils/logger.js

@@ -124,6 +124,6 @@ export function kvList(items) {
 // Banner
 export function banner() {
     log();
-    log(`  ${colors.cyan(colors.bold("BataDB"))} ${colors.dim("v0.1.3")} ${colors.dim("— serverless Postgres platform")}`);
+    log(`  ${colors.cyan(colors.bold("BataDB"))} ${colors.dim("v0.1.4")} ${colors.dim("— serverless Postgres platform")}`);
     log();
 }

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@batadata/cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CLI for BataDB — serverless Postgres platform",
   "bin": {
     "bata": "./dist/index.js"
   },
   "type": "module",
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run"
   },
   "engines": {

package/dist/commands/db.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/db.test.js

@@ -1,173 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const { get, post } = vi.hoisted(() => ({
-    get: vi.fn(async () => ({
-        ok: true,
-        status: 200,
-        data: { id: "proj_1", name: "demo", branches: [{ id: "br_primary", name: "main", is_primary: true, status: "ready" }] },
-    })),
-    post: vi.fn(async () => ({ ok: true, status: 200, data: { columns: ["n"], rows: [{ n: "1" }], rowCount: 1 } })),
-}));
-vi.mock("../api.js", () => ({
-    api: { get, post, del: vi.fn() },
-    resolveTeamId: vi.fn(async () => "team_test"),
-    // Mirror the real apiError so retryable mapping (which reads the server code)
-    // gets a realistic message; we don't need its exact format here.
-    apiError: (res, fallback) => {
-        const msg = res?.data?.error ?? fallback;
-        const code = res?.data?.code ? ` (${res.data.code})` : "";
-        return `${msg}${code}`;
-    },
-    asList: (data) => (Array.isArray(data) ? data : []),
-}));
-import { query, handleDb } from "./db.js";
-import { setRuntime } from "../config.js";
-let tmpHome;
-let logSpy;
-// process.exit must NOT actually exit the test runner. Throw a tagged error so
-// the handler unwinds at the exit point; tests catch it and read the code.
-class ExitError extends Error {
-    code;
-    constructor(code) {
-        super(`exit ${code}`);
-        this.code = code;
-    }
-}
-beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "bata-cli-db-test-"));
-    vi.stubEnv("HOME", tmpHome);
-    vi.stubEnv("USERPROFILE", tmpHome);
-    // A real credential + a default project so query() reaches the network seam.
-    fs.writeFileSync(path.join(tmpHome, ".batarc"), JSON.stringify({ defaultProject: "proj_1" }));
-    setRuntime({ apiKey: "test-token", apiUrl: "https://api.test.local", json: true, yes: false });
-    get.mockClear();
-    post.mockClear();
-    vi.spyOn(process, "exit").mockImplementation(((code) => {
-        throw new ExitError(code ?? 0);
-    }));
-    // Silence the JSON/decorative output so test logs stay clean.
-    logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-    vi.spyOn(console, "error").mockImplementation(() => { });
-});
-afterEach(() => {
-    vi.unstubAllEnvs();
-    vi.restoreAllMocks();
-    setRuntime({ json: false, yes: false });
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-/** Run a handler that's expected to call process.exit; return the exit code. */
-async function exitCodeOf(run) {
-    try {
-        await run();
-    }
-    catch (e) {
-        if (e instanceof ExitError)
-            return e.code;
-        throw e;
-    }
-    return 0; // handler returned without exiting (success path)
-}
-describe("db query — --help short-circuits before any network call", () => {
-    it("`db query --help` prints help and makes NO api call (exit 0)", async () => {
-        const code = await exitCodeOf(() => handleDb(["query", "--help"]));
-        expect(post).not.toHaveBeenCalled();
-        expect(get).not.toHaveBeenCalled();
-        expect(code).toBe(0);
-        // It actually printed usage, not a row result.
-        const printed = logSpy.mock.calls.map((c) => String(c[0])).join("\n");
-        expect(printed).toContain("bata db query");
-        expect(printed).toContain("--branch");
-    });
-    it("`db query -h` (short flag) also short-circuits with no api call", async () => {
-        const code = await exitCodeOf(() => handleDb(["query", "-h"]));
-        expect(post).not.toHaveBeenCalled();
-        expect(get).not.toHaveBeenCalled();
-        expect(code).toBe(0);
-    });
-    it("`db --help` prints general db help with no api call", async () => {
-        const code = await exitCodeOf(() => handleDb(["--help"]));
-        expect(post).not.toHaveBeenCalled();
-        expect(get).not.toHaveBeenCalled();
-        expect(code).toBe(0);
-    });
-});
-describe("db query — branch targeting", () => {
-    it("--branch <id> sets branch_id in the request body and skips primary lookup", async () => {
-        await exitCodeOf(() => query(["SELECT 1", "--branch", "br_explicit"]));
-        expect(post).toHaveBeenCalledTimes(1);
-        expect(post).toHaveBeenCalledWith("/v1/sql/execute", expect.objectContaining({ branch_id: "br_explicit", query: "SELECT 1" }), "test-token");
-        // Explicit branch → no need to resolve the primary.
-        expect(get).not.toHaveBeenCalled();
-    });
-    it("--branch=<id> (equals form) is also honored", async () => {
-        await exitCodeOf(() => query(["--branch=br_eq", "SELECT 2"]));
-        expect(post).toHaveBeenCalledWith("/v1/sql/execute", expect.objectContaining({ branch_id: "br_eq", query: "SELECT 2" }), "test-token");
-    });
-    it("without --branch, resolves the project's primary branch (default behavior)", async () => {
-        await exitCodeOf(() => query(["SELECT 1"]));
-        expect(get).toHaveBeenCalledTimes(1); // resolved primary
-        expect(post).toHaveBeenCalledWith("/v1/sql/execute", expect.objectContaining({ branch_id: "br_primary", query: "SELECT 1" }), "test-token");
-    });
-});
-describe("db query — retryable cold-start mapping (exit 6)", () => {
-    it("503 + { code: COMPUTE_STARTING } maps to exit 6 (retryable), not 1", async () => {
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 503,
-            data: { error: "compute is starting", code: "COMPUTE_STARTING" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "br_cold"]));
-        expect(code).toBe(6);
-    });
-    it("REGRESSION GUARD: a non-5xx status carrying { code: COMPUTE_STARTING } still maps to exit 6", async () => {
-        // The pre-fix code only looked at the HTTP status (>=500 || 0), so a
-        // COMPUTE_STARTING surfaced on, say, a 425 would have been CLI_ERROR (exit
-        // 1). This is the exact guard for the body-code inspection.
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 425,
-            data: { error: "compute is starting", code: "COMPUTE_STARTING" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "br_cold"]));
-        expect(code).toBe(6);
-    });
-    it("a connection-refused error body maps to exit 6", async () => {
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 0,
-            data: { error: "connect ECONNREFUSED 127.0.0.1:5432" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "br_cold"]));
-        expect(code).toBe(6);
-    });
-    it("a generic 5xx maps to exit 6", async () => {
-        post.mockResolvedValueOnce({ ok: false, status: 502, data: { error: "bad gateway" } });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "br_cold"]));
-        expect(code).toBe(6);
-    });
-    it("a genuine SQL syntax error (200 with error field) stays exit 1, NOT retryable", async () => {
-        post.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            data: { error: 'syntax error at or near "SELCT"' },
-        });
-        const code = await exitCodeOf(() => query(["SELCT 1", "--branch", "br_ok"]));
-        expect(code).toBe(1);
-    });
-    it("a 400 bad-input SQL error stays exit 1, NOT retryable", async () => {
-        post.mockResolvedValueOnce({
-            ok: false,
-            status: 400,
-            data: { error: "relation does not exist" },
-        });
-        const code = await exitCodeOf(() => query(["SELECT * FROM nope", "--branch", "br_ok"]));
-        expect(code).toBe(1);
-    });
-    it("a 401 stays auth (exit 4), not retryable", async () => {
-        post.mockResolvedValueOnce({ ok: false, status: 401, data: { error: "invalid key" } });
-        const code = await exitCodeOf(() => query(["SELECT 1", "--branch", "br_ok"]));
-        expect(code).toBe(4);
-    });
-});

package/dist/commands/projects.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/projects.test.js

@@ -1,104 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// --- Mock the network layer so no real HTTP happens and we can assert that the
-// --- DELETE call is (or isn't) invoked. This is the seam: deleteProject() calls
-// --- `api.del(...)`, so a spy here proves whether the delete actually proceeds.
-// `vi.hoisted` so the spy exists before the hoisted vi.mock factory runs.
-const { del, readlineQuestion } = vi.hoisted(() => ({
-    del: vi.fn(async () => ({ ok: true, status: 200, data: {} })),
-    // The interactive prompt seam: confirm() -> prompt() -> readline.question().
-    // Default answer is empty; a TTY test sets it to "n" to decline.
-    readlineQuestion: vi.fn((_q, cb) => cb("")),
-}));
-vi.mock("../api.js", () => ({
-    api: {
-        get: vi.fn(async () => ({ ok: true, status: 200, data: {} })),
-        post: vi.fn(async () => ({ ok: true, status: 200, data: {} })),
-        del,
-    },
-    // No real /v1/teams round-trip; deleteProject only needs an optional team id.
-    resolveTeamId: vi.fn(async () => "team_test"),
-    apiError: (_res, fallback) => fallback,
-    asList: (data) => (Array.isArray(data) ? data : []),
-}));
-// Mock readline so the interactive confirm() branch never blocks on real stdin.
-vi.mock("node:readline", () => ({
-    default: { createInterface: () => ({ question: readlineQuestion, close: () => { } }) },
-    createInterface: () => ({ question: readlineQuestion, close: () => { } }),
-}));
-// We deliberately do NOT mock ../config.js or ../utils/prompts.js — the whole
-// point of this test is to exercise the REAL confirmDestructive() + the REAL
-// runtime flag plumbing (setRuntime/isYes/isJsonMode), since that branch is the
-// destructive-headless contract under test.
-import { deleteProject } from "./projects.js";
-import { setRuntime } from "../config.js";
-let tmpHome;
-let realIsTTY;
-beforeEach(() => {
-    // Point ~/.batarc at a throwaway HOME so loadConfig/saveConfig never touch the
-    // developer's real config. os.homedir() reads HOME at call time (verified).
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "bata-cli-test-"));
-    vi.stubEnv("HOME", tmpHome);
-    vi.stubEnv("USERPROFILE", tmpHome); // Windows parity
-    // requireToken() resolves the --api-key runtime value first, so a real
-    // credential exists without writing a config file.
-    setRuntime({ apiKey: "test-token", apiUrl: "https://api.test.local", json: false, yes: false });
-    del.mockClear();
-    readlineQuestion.mockClear();
-    readlineQuestion.mockImplementation((_q, cb) => cb(""));
-    // Snapshot isTTY so individual tests can override it and we restore after.
-    realIsTTY = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
-});
-afterEach(() => {
-    vi.unstubAllEnvs();
-    vi.restoreAllMocks();
-    setRuntime({ json: false, yes: false });
-    if (realIsTTY) {
-        Object.defineProperty(process.stdin, "isTTY", realIsTTY);
-    }
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-function setTTY(value) {
-    Object.defineProperty(process.stdin, "isTTY", { value, configurable: true });
-}
-describe("projects delete — destructive headless contract", () => {
-    it("REGRESSION GUARD: with --yes, does NOT prompt and the DELETE actually proceeds", async () => {
-        // The original bug: headless `--yes` exited 0 having deleted NOTHING.
-        // This is the exact guard — if deleteProject silently skipped the delete,
-        // `del` would never be called and this expectation would fail.
-        setTTY(true); // even on a TTY, --yes must skip the prompt and proceed
-        setRuntime({ yes: true });
-        await deleteProject("proj_123");
-        expect(del).toHaveBeenCalledTimes(1);
-        expect(del).toHaveBeenCalledWith("/v1/projects/proj_123", "test-token", expect.objectContaining({ team_id: "team_test" }));
-    });
-    it("in --json mode, proceeds without prompting and deletes", async () => {
-        setTTY(true);
-        setRuntime({ json: true });
-        await deleteProject("proj_json");
-        expect(del).toHaveBeenCalledTimes(1);
-        expect(del).toHaveBeenCalledWith("/v1/projects/proj_json", "test-token", expect.anything());
-    });
-    it("when stdin is not a TTY (agent / piped / CI), proceeds and deletes without --yes", async () => {
-        // This is the CLI's whole purpose: unattended deletes must go through.
-        setTTY(false);
-        setRuntime({ yes: false, json: false });
-        await deleteProject("proj_pipe");
-        expect(del).toHaveBeenCalledTimes(1);
-        expect(del).toHaveBeenCalledWith("/v1/projects/proj_pipe", "test-token", expect.anything());
-    });
-    it("interactive TTY without --yes WOULD prompt; answering no aborts (no DELETE)", async () => {
-        // Covers the interactive branch of confirmDestructive(): it must ask, and a
-        // "no" answer must NOT call the delete API. The mocked readline (above) is
-        // the seam confirm() -> prompt() uses; we answer "n" to decline.
-        setTTY(true);
-        setRuntime({ yes: false, json: false });
-        readlineQuestion.mockImplementation((_q, cb) => cb("n"));
-        await deleteProject("proj_keep");
-        expect(readlineQuestion).toHaveBeenCalledTimes(1); // it DID prompt
-        expect(readlineQuestion.mock.calls[0][0]).toContain("Delete project");
-        expect(del).not.toHaveBeenCalled(); // declined → no destructive call
-    });
-});