@batadata/cli 0.1.6 → 0.1.7

package/dist/api.d.ts

@@ -14,6 +14,32 @@ export declare function request<T = unknown>(method: string, path: string, optio
  * generic placeholder so agents see what actually went wrong.
  */
 export declare function apiError(res: ApiResponse, fallback?: string): string;
+export interface ResolvedTeam {
+    teamId: string | undefined;
+    /** Set when a configured `defaultTeam` existed but the active credential
+     *  isn't a member of it, so the CLI fell back to the key's first team. */
+    mismatchNote?: string;
+}
+/**
+ * Pure team-resolution policy — no fs/network/process access, so it's
+ * unit-testable without mocking modules.
+ *
+ * - Happy path: the credential IS the stored login (tokenSource === "stored")
+ *   and it has a saved `defaultTeam`. That team was saved BY this login, so
+ *   it's trustworthy by construction — return it with zero requests.
+ * - Otherwise (a `--api-key` flag or `BATA_API_KEY` env may belong to a
+ *   different account/key than whatever last ran `bata login` on this
+ *   machine) — don't trust `defaultTeam` blindly. Fetch the key's actual
+ *   teams and only use `defaultTeam` if the key is really a member; else
+ *   fall back to the key's first team and report the mismatch.
+ */
+export declare function pickTeamId(params: {
+    tokenSource: "flag" | "env" | "stored" | "none";
+    savedDefaultTeam: string | undefined;
+    fetchTeams: () => Promise<Array<{
+        id: string;
+    }> | undefined>;
+}): Promise<ResolvedTeam>;
 export declare function resolveTeamId(token: string): Promise<string | undefined>;
 /**
  * List endpoints return `{ data: [...], pagination }` (not a bare array).

package/dist/api.js

@@ -1,7 +1,8 @@
 import * as https from "node:https";
 import * as http from "node:http";
 import { URL } from "node:url";
-import { getApiUrl, loadConfig } from "./config.js";
+import { getApiUrl, loadConfig, getTokenSource, isJsonMode } from "./config.js";
+import { colors } from "./utils/logger.js";
 export async function request(method, path, options = {}) {
     const baseUrl = getApiUrl();
     const url = new URL(path, baseUrl);
@@ -71,24 +72,65 @@ export function apiError(res, fallback = "Request failed") {
     return `${fallback} (HTTP ${res.status || "?"})`;
 }
 /**
- * Resolve the team id to operate on. Headless agents (just BATA_API_KEY, no
- * prior `bata login`) have no saved defaultTeam, and the API requires a team
- * for project list/create. So fall back to the user's first team. Cached for
- * the process lifetime. Returns undefined only if the user has no teams.
+ * Pure team-resolution policy — no fs/network/process access, so it's
+ * unit-testable without mocking modules.
+ *
+ * - Happy path: the credential IS the stored login (tokenSource === "stored")
+ *   and it has a saved `defaultTeam`. That team was saved BY this login, so
+ *   it's trustworthy by construction — return it with zero requests.
+ * - Otherwise (a `--api-key` flag or `BATA_API_KEY` env may belong to a
+ *   different account/key than whatever last ran `bata login` on this
+ *   machine) — don't trust `defaultTeam` blindly. Fetch the key's actual
+ *   teams and only use `defaultTeam` if the key is really a member; else
+ *   fall back to the key's first team and report the mismatch.
+ */
+export async function pickTeamId(params) {
+    const { tokenSource, savedDefaultTeam, fetchTeams } = params;
+    if (tokenSource === "stored" && savedDefaultTeam) {
+        return { teamId: savedDefaultTeam };
+    }
+    const teams = await fetchTeams();
+    if (!teams)
+        return { teamId: undefined };
+    if (savedDefaultTeam && teams.some((t) => t.id === savedDefaultTeam)) {
+        return { teamId: savedDefaultTeam };
+    }
+    const fallback = teams[0]?.id;
+    if (savedDefaultTeam && fallback) {
+        return {
+            teamId: fallback,
+            mismatchNote: `Configured default team "${savedDefaultTeam}" isn't accessible with this ` +
+                `API key — using "${fallback}" instead.`,
+        };
+    }
+    return { teamId: fallback };
+}
+/**
+ * Resolve the team id to operate on. Cached for the process lifetime (both
+ * the id and whether the mismatch note was already printed), since it never
+ * changes mid-run. Returns undefined only if the credential has no teams.
  */
 let _cachedTeamId;
+let _resolved = false;
 export async function resolveTeamId(token) {
-    const saved = loadConfig().defaultTeam;
-    if (saved)
-        return saved;
-    if (_cachedTeamId)
+    if (_resolved)
         return _cachedTeamId;
-    const res = await request("GET", "/v1/teams", { token });
-    if (!res.ok)
-        return undefined;
-    const data = res.data;
-    const teams = Array.isArray(data) ? data : data?.teams ?? [];
-    _cachedTeamId = teams[0]?.id;
+    const result = await pickTeamId({
+        tokenSource: getTokenSource(),
+        savedDefaultTeam: loadConfig().defaultTeam,
+        fetchTeams: async () => {
+            const res = await request("GET", "/v1/teams", { token });
+            if (!res.ok)
+                return undefined;
+            const data = res.data;
+            return Array.isArray(data) ? data : data?.teams ?? [];
+        },
+    });
+    _cachedTeamId = result.teamId;
+    _resolved = true;
+    if (result.mismatchNote && !isJsonMode()) {
+        console.error(colors.dim(`  ${result.mismatchNote}`));
+    }
     return _cachedTeamId;
 }
 /**

package/dist/commands/projects.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Only surface `defaultProject` if it's actually one of the caller's real
+ * projects — a saved default from another team/key/stale config must never
+ * be echoed back as if it were live data. Returns null otherwise.
+ */
+export declare function validDefaultProject(projects: Array<{
+    id: string;
+}>, defaultProject: string | undefined): string | null;
 export declare function list(): Promise<void>;
 export declare function create(): Promise<void>;
 export declare function info(projectId?: string): Promise<void>;

package/dist/commands/projects.js

@@ -19,6 +19,16 @@ function formatDate(iso) {
     const d = new Date(iso);
     return d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
 }
+/**
+ * Only surface `defaultProject` if it's actually one of the caller's real
+ * projects — a saved default from another team/key/stale config must never
+ * be echoed back as if it were live data. Returns null otherwise.
+ */
+export function validDefaultProject(projects, defaultProject) {
+    if (!defaultProject)
+        return null;
+    return projects.some((p) => p.id === defaultProject) ? defaultProject : null;
+}
 function statusBadge(status) {
     switch (status?.toLowerCase()) {
         case "active":
@@ -55,6 +65,7 @@ export async function list() {
     }
     s?.stop();
     const projects = asList(res.data);
+    const defaultProj = validDefaultProject(projects, config.defaultProject);
     if (jsonMode) {
         json({
             projects: projects.map((p) => ({
@@ -64,7 +75,7 @@ export async function list() {
                 status: p.status,
                 created_at: projectCreatedAt(p),
             })),
-            default_project: config.defaultProject ?? null,
+            default_project: defaultProj,
             count: projects.length,
         });
         return;
@@ -75,7 +86,6 @@ export async function list() {
         log();
         return;
     }
-    const defaultProj = config.defaultProject;
     table(["NAME", "REGION", "STATUS", "CREATED"], projects.map((p) => [
         p.id === defaultProj ? `${p.name} ${colors.cyan("*")}` : p.name,
         p.region || "-",

package/dist/commands/status.js

@@ -8,6 +8,7 @@ import { api, apiError, resolveTeamId } from "../api.js";
 import { requireToken, loadConfig, isJsonMode } from "../config.js";
 import { colors, log, json, spinner, table, heading } from "../utils/logger.js";
 import { emitError } from "../utils/errors.js";
+import { validDefaultProject } from "./projects.js";
 function statusBadge(status) {
     switch (status?.toLowerCase()) {
         case "active":
@@ -55,6 +56,7 @@ export async function status() {
     }
     s?.stop();
     const projects = Array.isArray(res.data) ? res.data : [];
+    const defaultProj = validDefaultProject(projects, config.defaultProject);
     if (jsonMode) {
         json({
             projects: projects.map((p) => ({
@@ -66,7 +68,7 @@ export async function status() {
                 branch_count: p.branches?.length ?? 0,
                 compute_status: p.computes?.[0]?.status ?? p.status ?? null,
             })),
-            default_project: config.defaultProject ?? null,
+            default_project: defaultProj,
             count: projects.length,
         });
         return;
@@ -77,7 +79,6 @@ export async function status() {
         log();
         return;
     }
-    const defaultProj = config.defaultProject;
     // Fetch branch/compute details for each project
     const rows = [];
     for (const p of projects) {

package/dist/config.d.ts

@@ -30,6 +30,14 @@ export declare function clearConfig(): void;
  * Returns undefined if none is available.
  */
 export declare function getToken(): string | undefined;
+export type TokenSource = "flag" | "env" | "stored" | "none";
+/**
+ * Where the active credential came from, in the same priority order as
+ * getToken(). Callers use this to decide whether it's safe to trust
+ * config saved by a *different* credential (e.g. a `defaultTeam` written by
+ * a previous `bata login`) — it only is when the token IS that stored login.
+ */
+export declare function getTokenSource(): TokenSource;
 /**
  * Like getToken() but exits with a clear, agent-friendly error if no
  * credential can be found anywhere.

package/dist/config.js

@@ -68,6 +68,21 @@ export function getToken() {
         return process.env.BATA_API_KEY;
     return loadConfig().token;
 }
+/**
+ * Where the active credential came from, in the same priority order as
+ * getToken(). Callers use this to decide whether it's safe to trust
+ * config saved by a *different* credential (e.g. a `defaultTeam` written by
+ * a previous `bata login`) — it only is when the token IS that stored login.
+ */
+export function getTokenSource() {
+    if (runtime.apiKey)
+        return "flag";
+    if (process.env.BATA_API_KEY)
+        return "env";
+    if (loadConfig().token)
+        return "stored";
+    return "none";
+}
 /**
  * Like getToken() but exits with a clear, agent-friendly error if no
  * credential can be found anywhere.

package/package.json

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