@batadata/cli 0.2.4 → 0.2.5

package/dist/commands/powdb.js

@@ -652,6 +652,106 @@ function renderPullSummary(o) {
     log(`  ${colors.dim("Load it:")} ${colors.cyan(o.loadCommand)}`);
     log();
 }
+/** `--project <id>` / `--project=<id>` only (the positional arg is the query). */
+function powdbProjectFlag(args) {
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--project" && args[i + 1])
+            return args[i + 1];
+        if (args[i].startsWith("--project="))
+            return args[i].slice("--project=".length);
+    }
+    return undefined;
+}
+function resolvePowdbProject(args) {
+    const explicit = powdbProjectFlag(args);
+    if (explicit)
+        return explicit;
+    const { projectId } = resolveProjectId(undefined);
+    if (!projectId) {
+        emitError("MISSING_ARG", "No project specified.", "Pass --project <id>, run `bata link <project>`, or set a default project.");
+    }
+    return projectId;
+}
+async function powdbQuery(args) {
+    const token = requireToken();
+    const jsonMode = isJsonMode();
+    const query = args.find((a) => !a.startsWith("-") && a !== powdbProjectFlag(args));
+    if (!query) {
+        emitError("MISSING_ARG", "Usage: bata powdb query \"<PowQL>\" [--project <id>]", "");
+        return;
+    }
+    const projectId = resolvePowdbProject(args);
+    const res = await api.post(`/v1/powdb/${encodeURIComponent(projectId)}/query`, { query }, token);
+    if (!res.ok) {
+        const code = res.status === 503 ? "RETRYABLE"
+            : res.status === 401 || res.status === 403 ? "INVALID_KEY"
+                : res.status === 404 ? "NOT_FOUND"
+                    : res.status >= 500 || res.status === 0 ? "API_UNAVAILABLE"
+                        : "CLI_ERROR";
+        emitError(code, apiError(res, "PowQL query failed"), code === "RETRYABLE" ? "The database is starting — retry in a few seconds." : "");
+        return;
+    }
+    const data = res.data;
+    if (jsonMode) {
+        json(data);
+        if ("error" in data && data.error)
+            process.exitCode = 1;
+        return;
+    }
+    if ("error" in data && data.error) {
+        // Query executed, PowQL rejected it — surface verbatim, non-zero exit.
+        emitError("QUERY_ERROR", data.error, "");
+        return;
+    }
+    log();
+    if ("kind" in data) {
+        switch (data.kind) {
+            case "rows":
+                if (data.rows.length === 0)
+                    log(`  ${colors.dim("(0 rows)")}`);
+                else {
+                    table(data.columns, data.rows);
+                    log(`  ${colors.dim(`(${data.rows.length} row${data.rows.length === 1 ? "" : "s"})`)}`);
+                }
+                break;
+            case "scalar":
+                log(`  ${data.value}`);
+                break;
+            case "ok":
+                log(`  ${colors.green(">")} ${data.affected} row${data.affected === 1 ? "" : "s"} affected`);
+                break;
+            case "message":
+                log(`  ${data.message}`);
+                break;
+        }
+        if (data.duration_ms !== undefined)
+            log(`  ${colors.dim(`${data.duration_ms}ms`)}`);
+    }
+    log();
+}
+async function powdbLifecycle(action, args) {
+    const token = requireToken();
+    const jsonMode = isJsonMode();
+    const positional = args.find((a) => !a.startsWith("-"));
+    const projectId = powdbProjectFlag(args) ?? positional ?? resolvePowdbProject(args);
+    const res = action === "status"
+        ? await api.get(`/v1/powdb/${encodeURIComponent(projectId)}`, token)
+        : await api.post(`/v1/powdb/${encodeURIComponent(projectId)}/${action}`, {}, token);
+    if (!res.ok) {
+        emitError(res.status === 404 ? "NOT_FOUND"
+            : res.status === 401 || res.status === 403 ? "INVALID_KEY"
+                : res.status >= 500 || res.status === 0 ? "API_UNAVAILABLE"
+                    : "CLI_ERROR", apiError(res, `PowDB ${action} failed`), "");
+        return;
+    }
+    if (jsonMode) {
+        json(res.data);
+        return;
+    }
+    log();
+    log(`  ${colors.green(">")} ${colors.cyan(projectId)} ${colors.dim("engine=powdb state=")}${res.data.state}`);
+    log();
+}
 // ─── Help + dispatch ──────────────────────────────────────────────────────────
 function powdbHelp() {
     log();
@@ -662,7 +762,13 @@ function powdbHelp() {
     log(`  ${colors.dim("BataDB branching / metering / server insights do NOT apply to it.")}`);
     log();
     log(`  ${colors.dim("Commands:")}`);
-    log(`    ${colors.cyan("pull")}    Pull a branch's schema + data into a local PowDB-loadable PowQL script`);
+    log(`    ${colors.cyan("pull")}    Pull a Postgres branch's schema + data into a local PowDB-loadable PowQL script`);
+    log();
+    log(`  ${colors.dim("Hosted PowDB projects (create one with: bata projects create --engine powdb):")}`);
+    log(`    ${colors.cyan("query")}   Run a PowQL statement:  bata powdb query "Note" [--project <id>]`);
+    log(`    ${colors.cyan("status")}  Show the server state (running | parked)  [--project <id>]`);
+    log(`    ${colors.cyan("park")}    Scale the server to zero (WAL is durable)  [--project <id>]`);
+    log(`    ${colors.cyan("wake")}    Start a parked server (~tens of ms)  [--project <id>]`);
     log();
     log(`  ${colors.dim("Options (pull):")}`);
     log(`    ${colors.dim("--project <id>       override the linked/default project")}`);
@@ -688,10 +794,18 @@ export async function handlePowdb(args) {
     switch (sub) {
         case "pull":
             return powdbPull(args.slice(1));
+        case "query":
+            return powdbQuery(args.slice(1));
+        case "status":
+            return powdbLifecycle("status", args.slice(1));
+        case "park":
+            return powdbLifecycle("park", args.slice(1));
+        case "wake":
+            return powdbLifecycle("wake", args.slice(1));
         case undefined:
             powdbHelp();
             return;
         default:
-            emitError("INVALID_FLAG", `Unknown subcommand: powdb ${sub}`, "Available: pull. Run `bata powdb --help`.");
+            emitError("INVALID_FLAG", `Unknown subcommand: powdb ${sub}`, "Available: pull, query, status, park, wake. Run `bata powdb --help`.");
     }
 }

package/dist/commands/projects.d.ts

@@ -23,6 +23,11 @@ export declare function parseCreateComputeArgs(args: string[]): {
 } | {
     error: string;
 };
+/** Parse `--engine postgres|powdb` (default: postgres). PowDB is a different
+ * ENGINE, not a different Postgres — the compute tier/size flags don't apply. */
+export declare function parseEngineArg(args: string[]): "postgres" | "powdb" | {
+    error: string;
+};
 export declare function create(args?: string[]): Promise<void>;
 export declare function info(projectId?: string): Promise<void>;
 export declare function deleteProject(projectId?: string): Promise<void>;

package/dist/commands/projects.js

@@ -160,29 +160,122 @@ export function parseCreateComputeArgs(args) {
     }
     return { tier, sizeCu };
 }
+/** `--flag <value>` / `--flag=<value>` reader. Distinguishes "absent"
+ * (undefined) from "present but missing its value" ({ error }) so a headless
+ * caller's typo fails loudly instead of silently changing behavior. */
+function readFlagValue(args, flag) {
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === flag) {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("-")) {
+                return { error: `${flag} requires a value.` };
+            }
+            return next;
+        }
+        if (args[i].startsWith(`${flag}=`)) {
+            const v = args[i].slice(flag.length + 1);
+            if (!v)
+                return { error: `${flag} requires a value.` };
+            return v;
+        }
+    }
+    return undefined;
+}
+/** Parse `--engine postgres|powdb` (default: postgres). PowDB is a different
+ * ENGINE, not a different Postgres — the compute tier/size flags don't apply. */
+export function parseEngineArg(args) {
+    let raw;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--engine") {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("-")) {
+                return { error: "--engine requires a value (postgres|powdb)." };
+            }
+            raw = next;
+            i++;
+        }
+        else if (args[i].startsWith("--engine="))
+            raw = args[i].slice("--engine=".length);
+    }
+    if (raw === undefined)
+        return "postgres";
+    const normalized = raw.toLowerCase();
+    if (normalized === "postgres" || normalized === "powdb")
+        return normalized;
+    return { error: `Invalid --engine "${raw}". Use "postgres" (default) or "powdb".` };
+}
 export async function create(args = []) {
     const token = requireToken();
     const config = loadConfig();
+    const engine = parseEngineArg(args);
+    if (typeof engine !== "string") {
+        emitError("INVALID_FLAG", engine.error, "");
+        return;
+    }
+    if (engine === "powdb" && args.some((a) => a === "--tier" || a === "--size" || a.startsWith("--tier=") || a.startsWith("--size="))) {
+        emitError("INVALID_FLAG", "--tier/--size do not apply to --engine powdb (PowDB has one serverless shape in this phase).", "");
+        return;
+    }
     const compute = parseCreateComputeArgs(args);
     if ("error" in compute) {
         emitError("INVALID_FLAG", compute.error, "");
         return;
     }
-    heading("Create a new project");
-    const name = await prompt("Project name");
+    const jsonMode = isJsonMode();
+    if (!jsonMode)
+        heading(engine === "powdb" ? "Create a new PowDB project" : "Create a new project");
+    // Agent-native path: --name (+ optional --region) skips the prompts entirely.
+    // Piped stdin cannot drive TWO sequential prompts — each prompt() opens a
+    // fresh readline that swallows the remaining buffered input, so the second
+    // question never resolves and Node exits silently on the unsettled await.
+    // Flags are the contract for headless use; prompts are for humans on a TTY.
+    const nameFlag = readFlagValue(args, "--name");
+    if (typeof nameFlag === "object") {
+        emitError("INVALID_FLAG", nameFlag.error, "");
+        return;
+    }
+    const regionFlag = readFlagValue(args, "--region");
+    if (typeof regionFlag === "object") {
+        emitError("INVALID_FLAG", regionFlag.error, "");
+        return;
+    }
+    if (jsonMode && nameFlag === undefined) {
+        // JSON mode is the machine contract — prompts would pollute stdout and a
+        // headless caller can't answer them anyway.
+        emitError("MISSING_ARG", "--json requires --name <name>.", "");
+        return;
+    }
+    const name = nameFlag ?? (await prompt("Project name"));
     if (!name) {
-        emitError("MISSING_ARG", "Project name is required.", "");
+        emitError("MISSING_ARG", "Project name is required.", "Pass --name <name> for headless use.");
+    }
+    let region;
+    if (regionFlag !== undefined) {
+        if (!REGIONS.some((r) => r.value === regionFlag)) {
+            emitError("INVALID_FLAG", `Invalid --region "${regionFlag}". Use one of: ${REGIONS.map((r) => r.value).join(", ")}.`, "");
+        }
+        region = regionFlag;
+    }
+    else if (nameFlag !== undefined) {
+        // --name without --region: default to the first region rather than opening
+        // a prompt a headless caller can't answer.
+        region = REGIONS[0].value;
+    }
+    else {
+        region = await select("Select a region", REGIONS);
     }
-    const region = await select("Select a region", REGIONS);
     const s = spinner("Creating project");
     const teamId = await resolveTeamId(token);
-    const body = {
-        name,
-        region,
-        // One friendly step: the compute is born on the chosen tier + size (no
-        // follow-up `bata compute set` needed). Defaults to serverless / 1 CU.
-        compute: { tier: compute.tier, size_cu: compute.sizeCu },
-    };
+    const body = engine === "powdb"
+        ? // PowDB: no compute picker — the server rejects pg-only options.
+            { name, region, engine: "powdb" }
+        : {
+            name,
+            region,
+            // One friendly step: the compute is born on the chosen tier + size (no
+            // follow-up `bata compute set` needed). Defaults to serverless / 1 CU.
+            compute: { tier: compute.tier, size_cu: compute.sizeCu },
+        };
     if (teamId) {
         body.team_id = teamId;
     }
@@ -197,19 +290,47 @@ export async function create(args = []) {
     const project = res.data;
     // Set as default project
     saveConfig({ defaultProject: project.id });
+    if (jsonMode) {
+        json({
+            id: project.id,
+            name: project.name,
+            region: project.region,
+            engine,
+            status: project.status,
+            ...(engine === "powdb"
+                ? { pricing: "not metered yet" }
+                : { compute: { tier: compute.tier, size_cu: compute.sizeCu } }),
+            default_project_saved: true,
+        });
+        return;
+    }
     const tierLabel = compute.tier === "always_on" ? "Always-on (dedicated)" : "Serverless";
     log();
     success(`Project ${colors.cyan(project.name)} created`);
     log();
-    kvList([
-        ["ID", colors.dim(project.id)],
-        ["Region", project.region],
-        ["Compute", `${tierLabel} · ${compute.sizeCu} CU`],
-        ["Pricing", colors.dim(computePriceSummary(compute.tier, compute.sizeCu))],
-        ["Status", statusBadge(project.status)],
-    ]);
-    log();
-    log(`  ${colors.dim("Set as default project. Run")} ${colors.cyan("bata db connect")} ${colors.dim("to connect.")}`);
+    if (engine === "powdb") {
+        kvList([
+            ["ID", colors.dim(project.id)],
+            ["Region", project.region],
+            ["Engine", "PowDB (serverless — parks to zero when idle)"],
+            // Honest: PowDB compute isn't in the usage meter yet — say so, never $0.
+            ["Pricing", colors.dim("not metered yet")],
+            ["Status", statusBadge(project.status)],
+        ]);
+        log();
+        log(`  ${colors.dim("Set as default project. Run")} ${colors.cyan('bata powdb query "<PowQL>"')} ${colors.dim("to query it.")}`);
+    }
+    else {
+        kvList([
+            ["ID", colors.dim(project.id)],
+            ["Region", project.region],
+            ["Compute", `${tierLabel} · ${compute.sizeCu} CU`],
+            ["Pricing", colors.dim(computePriceSummary(compute.tier, compute.sizeCu))],
+            ["Status", statusBadge(project.status)],
+        ]);
+        log();
+        log(`  ${colors.dim("Set as default project. Run")} ${colors.cyan("bata db connect")} ${colors.dim("to connect.")}`);
+    }
     log();
 }
 export async function info(projectId) {

package/package.json

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