kolaybase-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1913 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  clearUserConfig: () => clearUserConfig,
+  getAccessToken: () => getAccessToken,
+  getApiUrl: () => getApiUrl,
+  getLocalEnv: () => getLocalEnv,
+  getProjectConfig: () => getProjectConfig,
+  getProjectRoot: () => getProjectRoot,
+  getRefreshToken: () => getRefreshToken,
+  getUserConfig: () => getUserConfig,
+  isLoggedIn: () => isLoggedIn,
+  setAccessToken: () => setAccessToken,
+  setApiUrl: () => setApiUrl,
+  setLocalEnv: () => setLocalEnv,
+  setProjectConfig: () => setProjectConfig,
+  setRefreshToken: () => setRefreshToken,
+  setUserConfig: () => setUserConfig,
+  unsetLocalEnv: () => unsetLocalEnv,
+  writeEnvFile: () => writeEnvFile
+});
+import Conf from "conf";
+import path2 from "path";
+import fs from "fs/promises";
+async function getProjectRoot() {
+  let currentDir = process.cwd();
+  while (currentDir !== path2.parse(currentDir).root) {
+    const configPath = path2.join(currentDir, ".kolaybase");
+    try {
+      await fs.access(configPath);
+      return currentDir;
+    } catch {
+      currentDir = path2.dirname(currentDir);
+    }
+  }
+  return null;
+}
+async function getProjectConfig() {
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) return null;
+  const configPath = path2.join(projectRoot, ".kolaybase", "config.json");
+  try {
+    const data = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function setProjectConfig(config) {
+  const projectRoot = process.cwd();
+  const configDir = path2.join(projectRoot, ".kolaybase");
+  const configPath = path2.join(configDir, "config.json");
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+function getUserConfig() {
+  return userConfig.store;
+}
+function setUserConfig(config) {
+  userConfig.set(config);
+}
+function clearUserConfig() {
+  userConfig.clear();
+}
+function getApiUrl() {
+  return userConfig.get("apiUrl") || DEFAULT_API_URL;
+}
+function getAccessToken() {
+  return userConfig.get("accessToken");
+}
+function setAccessToken(token) {
+  userConfig.set("accessToken", token);
+}
+function getRefreshToken() {
+  return userConfig.get("refreshToken");
+}
+function setRefreshToken(token) {
+  userConfig.set("refreshToken", token);
+}
+function isLoggedIn() {
+  return !!userConfig.get("accessToken");
+}
+function setApiUrl(url) {
+  userConfig.set("apiUrl", url);
+}
+async function writeEnvFile(project) {
+  const lines = [
+    '# Kolaybase \u2014 generated by "kb init" / "kb link"',
+    "",
+    `PROJECT_ID=${project.id}`,
+    `PROJECT_SLUG=${project.slug}`,
+    "",
+    `DB_HOST=${project.dbHost}`,
+    `DB_PORT=${project.dbPort}`,
+    `DB_NAME=${project.dbName}`,
+    `DB_USER=${project.dbUser}`,
+    `DB_PASSWORD=${project.dbPassword}`,
+    `DATABASE_URL=postgresql://${project.dbUser}:${project.dbPassword}@${project.dbHost}:${project.dbPort}/${project.dbName}`,
+    "",
+    `KEYCLOAK_REALM=${project.keycloakRealm}`,
+    `ANON_KEY=${project.anonKey}`,
+    `SERVICE_KEY=${project.serviceKey}`,
+    ""
+  ];
+  await fs.writeFile(".env", lines.join("\n"));
+  try {
+    let gi = "";
+    try {
+      gi = await fs.readFile(".gitignore", "utf-8");
+    } catch {
+    }
+    if (!gi.includes(".env")) {
+      await fs.writeFile(".gitignore", gi + "\n.env\n");
+    }
+  } catch {
+  }
+}
+async function getLocalEnv() {
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) return {};
+  const envPath = path2.join(projectRoot, ".env");
+  try {
+    const content = await fs.readFile(envPath, "utf-8");
+    const env = {};
+    content.split("\n").forEach((line) => {
+      line = line.trim();
+      if (!line || line.startsWith("#")) return;
+      const [key, ...valueParts] = line.split("=");
+      if (key && valueParts.length > 0) {
+        env[key.trim()] = valueParts.join("=").trim();
+      }
+    });
+    return env;
+  } catch {
+    return {};
+  }
+}
+async function setLocalEnv(key, value) {
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) {
+    throw new Error("Not in a Kolaybase project directory");
+  }
+  const envPath = path2.join(projectRoot, ".env");
+  let content = "";
+  try {
+    content = await fs.readFile(envPath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  let found = false;
+  const newLines = lines.map((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(`${key}=`)) {
+      found = true;
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+  if (!found) {
+    newLines.push(`${key}=${value}`);
+  }
+  await fs.writeFile(envPath, newLines.join("\n"));
+}
+async function unsetLocalEnv(key) {
+  const projectRoot = await getProjectRoot();
+  if (!projectRoot) {
+    throw new Error("Not in a Kolaybase project directory");
+  }
+  const envPath = path2.join(projectRoot, ".env");
+  try {
+    const content = await fs.readFile(envPath, "utf-8");
+    const lines = content.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      return !trimmed.startsWith(`${key}=`);
+    });
+    await fs.writeFile(envPath, lines.join("\n"));
+  } catch {
+  }
+}
+var userConfig, DEFAULT_API_URL;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    userConfig = new Conf({
+      projectName: "kolaybase",
+      configName: "config"
+    });
+    DEFAULT_API_URL = "https://api.kolaybase.com";
+  }
+});
+
+// src/lib/api.ts
+import axios from "axios";
+import chalk from "chalk";
+function handleApiError(error2) {
+  if (axios.isAxiosError(error2)) {
+    if (error2.response) {
+      const message = error2.response.data?.message || error2.response.data?.error || error2.message;
+      console.error(chalk.red(`API Error: ${message}`));
+      if (error2.response.status === 401) {
+        console.error(chalk.yellow("Please login first with: kb login"));
+      }
+    } else if (error2.request) {
+      console.error(chalk.red("Network error: Could not connect to Kolaybase API"));
+      console.error(chalk.yellow(`Make sure the API is running at: ${getApiUrl()}`));
+    } else {
+      console.error(chalk.red(`Error: ${error2.message}`));
+    }
+  } else {
+    console.error(chalk.red(`Error: ${error2.message || error2}`));
+  }
+  process.exit(1);
+}
+var ApiClient, apiClient;
+var init_api = __esm({
+  "src/lib/api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    ApiClient = class {
+      client;
+      constructor() {
+        this.client = axios.create({
+          baseURL: getApiUrl(),
+          timeout: 3e4,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        this.client.interceptors.request.use((config) => {
+          const token = getAccessToken();
+          if (token) {
+            config.headers.Authorization = `Bearer ${token}`;
+          }
+          return config;
+        });
+        this.client.interceptors.response.use(
+          (response) => response,
+          async (error2) => {
+            const originalRequest = error2.config;
+            if (error2.response?.status === 401 && originalRequest && !originalRequest._retry) {
+              originalRequest._retry = true;
+              try {
+                const refreshToken = getRefreshToken();
+                if (!refreshToken) {
+                  throw new Error("No refresh token available");
+                }
+                const { data } = await axios.post(`${getApiUrl()}/api/auth/refresh`, {
+                  refreshToken
+                });
+                setAccessToken(data.accessToken);
+                setRefreshToken(data.refreshToken);
+                originalRequest.headers.Authorization = `Bearer ${data.accessToken}`;
+                return this.client(originalRequest);
+              } catch (refreshError) {
+                console.error(chalk.red("Session expired. Please login again with: kb login"));
+                process.exit(1);
+              }
+            }
+            return Promise.reject(error2);
+          }
+        );
+      }
+      // Auth endpoints
+      async login(username, password) {
+        const { data } = await this.client.post("/api/auth/login", { username, password });
+        return data;
+      }
+      async signup(userData) {
+        const { data } = await this.client.post("/api/auth/signup", userData);
+        return data;
+      }
+      // Projects endpoints
+      async getProjects(teamId) {
+        const { data } = await this.client.get("/api/projects", {
+          params: { teamId }
+        });
+        return data;
+      }
+      async getProject(projectId) {
+        const { data } = await this.client.get(`/api/projects/${projectId}`);
+        return data;
+      }
+      async createProject(projectData) {
+        const { data } = await this.client.post("/api/projects", projectData);
+        return data;
+      }
+      async deleteProject(projectId) {
+        const { data } = await this.client.delete(`/api/projects/${projectId}`);
+        return data;
+      }
+      // SQL endpoints
+      async executeSQL(projectId, query) {
+        const { data } = await this.client.post("/api/sql/execute", {
+          projectId,
+          query
+        });
+        return data;
+      }
+      // Teams endpoints
+      async getTeams() {
+        const { data } = await this.client.get("/api/teams");
+        return data;
+      }
+      async getActiveTeam() {
+        const { data } = await this.client.get("/api/teams/active");
+        return data;
+      }
+      // Project data endpoints
+      async getTables(projectId) {
+        const { data } = await this.client.get(`/api/projects/${projectId}/data/tables`);
+        return data;
+      }
+      async getTableSchema(projectId, tableName) {
+        const { data } = await this.client.get(`/api/projects/${projectId}/data/tables/${tableName}/schema`);
+        return data;
+      }
+      async getTableData(projectId, tableName, options) {
+        const { data } = await this.client.get(`/api/projects/${projectId}/data/tables/${tableName}/rows`, {
+          params: options
+        });
+        return data;
+      }
+    };
+    apiClient = new ApiClient();
+  }
+});
+
+// src/lib/ui.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import boxen from "boxen";
+function success(message) {
+  console.log(chalk2.green("\u2713"), message);
+}
+function error(message) {
+  console.log(chalk2.red("\u2717"), message);
+}
+function warning(message) {
+  console.log(chalk2.yellow("\u26A0"), message);
+}
+function info(message) {
+  console.log(chalk2.blue("\u2139"), message);
+}
+function createSpinner(text) {
+  return ora(text).start();
+}
+function printHeader(text) {
+  console.log();
+  console.log(chalk2.bold.cyan(text));
+  console.log(chalk2.cyan("\u2500".repeat(text.length)));
+}
+function printTable(headers, rows) {
+  const columnWidths = headers.map((header, i) => {
+    const maxRowWidth = Math.max(...rows.map((row2) => (row2[i] || "").length));
+    return Math.max(header.length, maxRowWidth);
+  });
+  const headerRow = headers.map(
+    (header, i) => header.padEnd(columnWidths[i])
+  ).join("  ");
+  console.log(chalk2.bold(headerRow));
+  console.log(chalk2.gray("\u2500".repeat(headerRow.length)));
+  rows.forEach((row2) => {
+    const rowStr = row2.map(
+      (cell, i) => (cell || "").padEnd(columnWidths[i])
+    ).join("  ");
+    console.log(rowStr);
+  });
+}
+function printKeyValue(data) {
+  const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
+  Object.entries(data).forEach(([key, value]) => {
+    const paddedKey = chalk2.bold(key.padEnd(maxKeyLength));
+    const displayValue = value ?? chalk2.gray("(not set)");
+    console.log(`${paddedKey}  ${displayValue}`);
+  });
+}
+function printLogo() {
+  const logo = `
+${chalk2.cyan("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")}
+${chalk2.cyan("\u2502")}  ${chalk2.bold.cyan("K O L A Y B A S E")}                ${chalk2.cyan("\u2502")}
+${chalk2.cyan("\u2502")}  ${chalk2.gray("Backend-as-a-Service Platform")}    ${chalk2.cyan("\u2502")}
+${chalk2.cyan("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")}
+  `;
+  console.log(logo);
+}
+var init_ui = __esm({
+  "src/lib/ui.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/db.ts
+var db_exports = {};
+__export(db_exports, {
+  dbCommand: () => dbCommand,
+  dbDiff: () => dbDiff,
+  dbDump: () => dbDump,
+  dbPull: () => dbPull,
+  dbPush: () => dbPush,
+  dbReset: () => dbReset,
+  dbSeed: () => dbSeed
+});
+import inquirer5 from "inquirer";
+import chalk9 from "chalk";
+import { Pool } from "pg";
+import fs3 from "fs/promises";
+import path4 from "path";
+async function dbCommand() {
+  console.log(chalk9.bold.cyan("Database Management\n"));
+  info("Use db subcommands: push, pull, reset, seed, diff");
+}
+async function dbPush() {
+  console.log(chalk9.bold.cyan("Push Database Schema\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  const spinner = createSpinner("Analyzing schema changes...");
+  try {
+    const env = await getLocalEnv();
+    const schemaPath = await findSchemaFile();
+    if (!schemaPath) {
+      spinner.fail("No schema file found");
+      error("Could not find schema.prisma, schema.sql, or migrations directory");
+      process.exit(1);
+    }
+    spinner.text = "Pushing schema to database...";
+    if (schemaPath.endsWith(".prisma")) {
+      const { execa } = await import("execa");
+      await execa("npx", ["prisma", "db", "push"], {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          DATABASE_URL: env.DATABASE_URL
+        }
+      });
+    } else {
+      const sql = await fs3.readFile(schemaPath, "utf-8");
+      await apiClient.executeSQL(config.projectId, sql);
+    }
+    spinner.succeed("Schema pushed successfully");
+    success("Database is up to date");
+  } catch (err) {
+    spinner.fail("Failed to push schema");
+    handleApiError(err);
+  }
+}
+async function dbPull() {
+  console.log(chalk9.bold.cyan("Pull Database Schema\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  const spinner = createSpinner("Pulling schema from database...");
+  try {
+    const env = await getLocalEnv();
+    const prismaPath = path4.join(process.cwd(), "prisma", "schema.prisma");
+    try {
+      await fs3.access(prismaPath);
+      const { execa } = await import("execa");
+      await execa("npx", ["prisma", "db", "pull"], {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          DATABASE_URL: env.DATABASE_URL
+        }
+      });
+      spinner.succeed("Schema pulled successfully");
+    } catch {
+      spinner.text = "Generating SQL dump...";
+      const pool = new Pool({
+        connectionString: env.DATABASE_URL
+      });
+      const client = await pool.connect();
+      try {
+        const { rows } = await client.query(`
+          SELECT table_name 
+          FROM information_schema.tables 
+          WHERE table_schema = 'public'
+          ORDER BY table_name
+        `);
+        const tables = rows.map((r) => r.table_name);
+        let schemaDump = "-- Database schema dump\n\n";
+        for (const table of tables) {
+          const { rows: columns } = await client.query(`
+            SELECT column_name, data_type, is_nullable, column_default
+            FROM information_schema.columns
+            WHERE table_name = $1
+            ORDER BY ordinal_position
+          `, [table]);
+          schemaDump += `CREATE TABLE IF NOT EXISTS ${table} (
+`;
+          schemaDump += columns.map((col) => {
+            let def = `  ${col.column_name} ${col.data_type}`;
+            if (col.is_nullable === "NO") def += " NOT NULL";
+            if (col.column_default) def += ` DEFAULT ${col.column_default}`;
+            return def;
+          }).join(",\n");
+          schemaDump += "\n);\n\n";
+        }
+        await fs3.mkdir("db", { recursive: true });
+        await fs3.writeFile("db/schema.sql", schemaDump);
+        spinner.succeed("Schema pulled successfully");
+        info("Schema saved to db/schema.sql");
+      } finally {
+        client.release();
+        await pool.end();
+      }
+    }
+  } catch (err) {
+    spinner.fail("Failed to pull schema");
+    handleApiError(err);
+  }
+}
+async function dbReset(options) {
+  console.log(chalk9.bold.cyan("Reset Database\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  console.log(chalk9.yellow("\u26A0 WARNING: This will delete all data in the database!"));
+  console.log();
+  if (!options.force) {
+    const answers = await inquirer5.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to reset the database?",
+        default: false
+      }
+    ]);
+    if (!answers.confirm) {
+      info("Reset cancelled");
+      return;
+    }
+  }
+  const spinner = createSpinner("Resetting database...");
+  try {
+    const env = await getLocalEnv();
+    const pool = new Pool({
+      connectionString: env.DATABASE_URL
+    });
+    const client = await pool.connect();
+    try {
+      const { rows } = await client.query(`
+        SELECT tablename 
+        FROM pg_tables 
+        WHERE schemaname = 'public'
+      `);
+      for (const row2 of rows) {
+        await client.query(`DROP TABLE IF EXISTS "${row2.tablename}" CASCADE`);
+      }
+      spinner.succeed("Database reset successfully");
+      success("All tables dropped");
+      console.log();
+      info("To recreate schema, run: kb db push");
+    } finally {
+      client.release();
+      await pool.end();
+    }
+  } catch (err) {
+    spinner.fail("Failed to reset database");
+    handleApiError(err);
+  }
+}
+async function dbSeed() {
+  console.log(chalk9.bold.cyan("Seed Database\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  const spinner = createSpinner("Looking for seed file...");
+  try {
+    const seedPaths = [
+      "prisma/seed.ts",
+      "prisma/seed.js",
+      "db/seed.sql",
+      "seeds/seed.sql"
+    ];
+    let seedPath = null;
+    for (const p of seedPaths) {
+      try {
+        await fs3.access(p);
+        seedPath = p;
+        break;
+      } catch {
+      }
+    }
+    if (!seedPath) {
+      spinner.fail("No seed file found");
+      warning("Create a seed file at prisma/seed.ts or db/seed.sql");
+      return;
+    }
+    spinner.text = "Running seed...";
+    if (seedPath.endsWith(".sql")) {
+      const sql = await fs3.readFile(seedPath, "utf-8");
+      await apiClient.executeSQL(config.projectId, sql);
+    } else {
+      const { execa } = await import("execa");
+      await execa("npx", ["prisma", "db", "seed"], {
+        stdio: "inherit"
+      });
+    }
+    spinner.succeed("Database seeded successfully");
+  } catch (err) {
+    spinner.fail("Failed to seed database");
+    handleApiError(err);
+  }
+}
+async function dbDiff() {
+  console.log(chalk9.bold.cyan("Database Schema Diff\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  info("Checking for schema differences...");
+  try {
+    const { execa } = await import("execa");
+    await execa("npx", ["prisma", "migrate", "diff"], {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    warning("Could not generate diff. Make sure Prisma is configured.");
+  }
+}
+async function dbDump(options) {
+  console.log(chalk9.bold.cyan("Dump Database Schema\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  const spinner = createSpinner("Dumping schema\u2026");
+  try {
+    const env = await getLocalEnv();
+    const pool = new Pool({ connectionString: env.DATABASE_URL });
+    const client = await pool.connect();
+    try {
+      const { rows: tables } = await client.query(`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+        ORDER BY table_name
+      `);
+      let dump = "-- Kolaybase schema dump\n-- Generated: " + (/* @__PURE__ */ new Date()).toISOString() + "\n\n";
+      for (const t of tables) {
+        const { rows: cols } = await client.query(`
+          SELECT column_name, udt_name, is_nullable, column_default, character_maximum_length
+          FROM information_schema.columns
+          WHERE table_name = $1
+          ORDER BY ordinal_position
+        `, [t.table_name]);
+        dump += `CREATE TABLE IF NOT EXISTS "${t.table_name}" (
+`;
+        dump += cols.map((c) => {
+          let def = `  "${c.column_name}" ${c.udt_name}`;
+          if (c.character_maximum_length) def += `(${c.character_maximum_length})`;
+          if (c.is_nullable === "NO") def += " NOT NULL";
+          if (c.column_default) def += ` DEFAULT ${c.column_default}`;
+          return def;
+        }).join(",\n");
+        dump += "\n);\n\n";
+      }
+      const outFile = options.output || "schema.sql";
+      await fs3.writeFile(outFile, dump);
+      spinner.succeed(`Schema dumped to ${chalk9.cyan(outFile)}`);
+    } finally {
+      client.release();
+      await pool.end();
+    }
+  } catch (err) {
+    spinner.fail("Failed to dump schema");
+    handleApiError(err);
+  }
+}
+async function findSchemaFile() {
+  const paths = [
+    "prisma/schema.prisma",
+    "db/schema.sql",
+    "schema.sql",
+    "migrations"
+  ];
+  for (const p of paths) {
+    try {
+      await fs3.access(p);
+      return p;
+    } catch {
+    }
+  }
+  return null;
+}
+var init_db = __esm({
+  "src/commands/db.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_api();
+    init_config();
+    init_ui();
+  }
+});
+
+// src/commands/inspect.ts
+var inspect_exports = {};
+__export(inspect_exports, {
+  inspectCommand: () => inspectCommand
+});
+import chalk10 from "chalk";
+import { Pool as Pool2 } from "pg";
+async function inspectCommand(options) {
+  const config = await getProjectConfig();
+  if (!config?.projectId) {
+    error("Not linked to a project. Run:  kb link  or  kb init");
+    process.exit(1);
+  }
+  const env = await getLocalEnv();
+  if (!env.DATABASE_URL) {
+    error("DATABASE_URL not found in .env \u2014 run  kb link  to refresh credentials");
+    process.exit(1);
+  }
+  const pool = new Pool2({ connectionString: env.DATABASE_URL });
+  try {
+    if (options.table) {
+      await inspectTable(pool, options.table);
+    } else {
+      await inspectAll(pool);
+    }
+  } catch (err) {
+    error(`Database error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+async function inspectAll(pool) {
+  const spinner = createSpinner("Querying database\u2026");
+  const { rows } = await pool.query(`
+    SELECT
+      t.table_name,
+      pg_total_relation_size(quote_ident(t.table_name))  AS total_bytes,
+      pg_size_pretty(pg_total_relation_size(quote_ident(t.table_name))) AS size,
+      (SELECT reltuples::bigint FROM pg_class WHERE relname = t.table_name) AS est_rows
+    FROM information_schema.tables t
+    WHERE t.table_schema = 'public' AND t.table_type = 'BASE TABLE'
+    ORDER BY total_bytes DESC
+  `);
+  spinner.stop();
+  if (!rows.length) {
+    console.log(chalk10.gray("  No tables found. Push a schema first:  kb db push"));
+    return;
+  }
+  printHeader("Tables");
+  console.log();
+  const nameW = Math.max(10, ...rows.map((r) => r.table_name.length));
+  console.log(
+    `  ${chalk10.bold("Table".padEnd(nameW))}  ${chalk10.bold("Rows".padStart(10))}  ${chalk10.bold("Size".padStart(10))}`
+  );
+  console.log(chalk10.gray("  " + "\u2500".repeat(nameW + 24)));
+  for (const r of rows) {
+    const rowCount = Number(r.est_rows) >= 0 ? Number(r.est_rows).toLocaleString() : "\u2014";
+    console.log(
+      `  ${chalk10.cyan(r.table_name.padEnd(nameW))}  ${rowCount.padStart(10)}  ${String(r.size).padStart(10)}`
+    );
+  }
+  console.log();
+  console.log(chalk10.gray(`  ${rows.length} table(s)`));
+  console.log(chalk10.gray("  Inspect a table:  kb inspect --table <name>"));
+}
+async function inspectTable(pool, tableName) {
+  const spinner = createSpinner(`Inspecting ${tableName}\u2026`);
+  const { rows: columns } = await pool.query(`
+    SELECT
+      c.column_name,
+      c.data_type,
+      c.udt_name,
+      c.is_nullable,
+      c.column_default,
+      c.character_maximum_length
+    FROM information_schema.columns c
+    WHERE c.table_schema = 'public' AND c.table_name = $1
+    ORDER BY c.ordinal_position
+  `, [tableName]);
+  if (!columns.length) {
+    spinner.fail(`Table "${tableName}" not found`);
+    process.exit(1);
+  }
+  const { rows: indexes } = await pool.query(`
+    SELECT indexname, indexdef
+    FROM pg_indexes
+    WHERE schemaname = 'public' AND tablename = $1
+  `, [tableName]);
+  const { rows: fkeys } = await pool.query(`
+    SELECT
+      kcu.column_name,
+      ccu.table_name  AS foreign_table,
+      ccu.column_name AS foreign_column
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name
+    JOIN information_schema.constraint_column_usage ccu
+      ON tc.constraint_name = ccu.constraint_name
+    WHERE tc.table_name = $1 AND tc.constraint_type = 'FOREIGN KEY'
+  `, [tableName]);
+  const { rows: meta } = await pool.query(`
+    SELECT
+      pg_size_pretty(pg_total_relation_size(quote_ident($1))) AS size,
+      (SELECT reltuples::bigint FROM pg_class WHERE relname = $1)  AS est_rows
+  `, [tableName]);
+  spinner.stop();
+  printHeader(`Table: ${tableName}`);
+  console.log();
+  if (meta[0]) {
+    console.log(`  ${chalk10.gray("Rows")}   ${Number(meta[0].est_rows).toLocaleString()}`);
+    console.log(`  ${chalk10.gray("Size")}   ${meta[0].size}`);
+    console.log();
+  }
+  console.log(chalk10.bold("  Columns"));
+  const nameW = Math.max(6, ...columns.map((c) => c.column_name.length));
+  const typeW = Math.max(4, ...columns.map((c) => formatType(c).length));
+  console.log(
+    `  ${chalk10.gray("Name".padEnd(nameW))}  ${chalk10.gray("Type".padEnd(typeW))}  ${chalk10.gray("Nullable")}  ${chalk10.gray("Default")}`
+  );
+  console.log(chalk10.gray("  " + "\u2500".repeat(nameW + typeW + 24)));
+  for (const col of columns) {
+    const nullable = col.is_nullable === "YES" ? chalk10.yellow("YES") : chalk10.gray("NO ");
+    const def = col.column_default ? chalk10.gray(truncate2(col.column_default, 30)) : "";
+    const fk = fkeys.find((f) => f.column_name === col.column_name);
+    const fkLabel = fk ? chalk10.blue(` \u2192 ${fk.foreign_table}.${fk.foreign_column}`) : "";
+    console.log(
+      `  ${chalk10.cyan(col.column_name.padEnd(nameW))}  ${formatType(col).padEnd(typeW)}  ${nullable}       ${def}${fkLabel}`
+    );
+  }
+  if (indexes.length) {
+    console.log();
+    console.log(chalk10.bold("  Indexes"));
+    for (const idx of indexes) {
+      console.log(`  ${chalk10.gray("\u2022")} ${idx.indexname}`);
+    }
+  }
+  console.log();
+}
+function formatType(col) {
+  let t = col.udt_name || col.data_type;
+  if (col.character_maximum_length) t += `(${col.character_maximum_length})`;
+  return t;
+}
+function truncate2(s, max) {
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+var init_inspect = __esm({
+  "src/commands/inspect.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_ui();
+  }
+});
+
+// src/commands/gen.ts
+var gen_exports = {};
+__export(gen_exports, {
+  genClient: () => genClient,
+  genTypes: () => genTypes
+});
+import chalk11 from "chalk";
+import fs4 from "fs/promises";
+import path5 from "path";
+import { Pool as Pool3 } from "pg";
+async function genTypes(options) {
+  console.log(chalk11.bold.cyan("Generate TypeScript Types\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  const spinner = createSpinner("Generating types from database schema...");
+  try {
+    const env = await getLocalEnv();
+    const pool = new Pool3({
+      connectionString: env.DATABASE_URL
+    });
+    const client = await pool.connect();
+    try {
+      const { rows: tables } = await client.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = 'public'
+        ORDER BY table_name
+      `);
+      let typesContent = `// Generated by Kolaybase CLI
+// Do not edit manually
+
+export interface Database {
+${tables.map((t) => `  ${t.table_name}: ${toPascalCase(t.table_name)};`).join("\n")}
+}
+
+`;
+      for (const table of tables) {
+        const { rows: columns } = await client.query(`
+          SELECT 
+            column_name, 
+            data_type, 
+            is_nullable,
+            column_default
+          FROM information_schema.columns
+          WHERE table_name = $1
+          ORDER BY ordinal_position
+        `, [table.table_name]);
+        const typeName = toPascalCase(table.table_name);
+        typesContent += `export interface ${typeName} {
+`;
+        columns.forEach((col) => {
+          const tsType = pgTypeToTs(col.data_type);
+          const optional = col.is_nullable === "YES" || col.column_default ? "?" : "";
+          typesContent += `  ${col.column_name}${optional}: ${tsType};
+`;
+        });
+        typesContent += `}
+
+`;
+      }
+      const outputDir = options.output || "types";
+      await fs4.mkdir(outputDir, { recursive: true });
+      const outputPath = path5.join(outputDir, "database.ts");
+      await fs4.writeFile(outputPath, typesContent);
+      spinner.succeed("Types generated successfully");
+      success(`Written to ${chalk11.cyan(outputPath)}`);
+    } finally {
+      client.release();
+      await pool.end();
+    }
+  } catch (err) {
+    spinner.fail("Failed to generate types");
+    handleApiError(err);
+  }
+}
+async function genClient(options) {
+  console.log(chalk11.bold.cyan("Generate API Client\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  const spinner = createSpinner("Generating API client...");
+  try {
+    const lang = options.lang || "typescript";
+    const outputDir = options.output || "lib";
+    if (lang === "typescript") {
+      await generateTsClient(config, outputDir);
+    } else if (lang === "javascript") {
+      await generateJsClient(config, outputDir);
+    } else if (lang === "python") {
+      await generatePyClient(config, outputDir);
+    } else {
+      throw new Error(`Unsupported language: ${lang}`);
+    }
+    spinner.succeed("Client generated successfully");
+    success(`Written to ${chalk11.cyan(outputDir)}`);
+  } catch (err) {
+    spinner.fail("Failed to generate client");
+    handleApiError(err);
+  }
+}
+async function generateTsClient(config, outputDir) {
+  const clientContent = `// Generated by Kolaybase CLI
+import axios, { AxiosInstance } from 'axios';
+
+export interface KolaybaseConfig {
+  url?: string;
+  anonKey?: string;
+  serviceKey?: string;
+}
+
+export class KolaybaseClient {
+  private client: AxiosInstance;
+  private projectId: string;
+
+  constructor(config: KolaybaseConfig = {}) {
+    this.projectId = '${config.projectId}';
+    
+    this.client = axios.create({
+      baseURL: config.url || process.env.NEXT_PUBLIC_API_URL || 'http://localhost:4000',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${config.anonKey || process.env.ANON_KEY}\`,
+      },
+    });
+  }
+
+  // Execute raw SQL
+  async sql<T = any>(query: string): Promise<T[]> {
+    const { data } = await this.client.post('/sql/execute', {
+      projectId: this.projectId,
+      query,
+    });
+    return data.rows;
+  }
+
+  // Table operations
+  table<T = any>(tableName: string) {
+    return {
+      select: async (columns = '*', options?: {
+        where?: Record<string, any>;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+      }): Promise<T[]> => {
+        let query = \`SELECT \${columns} FROM \${tableName}\`;
+        
+        if (options?.where) {
+          const conditions = Object.entries(options.where)
+            .map(([k, v]) => \`\${k} = '\${v}'\`)
+            .join(' AND ');
+          query += \` WHERE \${conditions}\`;
+        }
+        
+        if (options?.orderBy) {
+          query += \` ORDER BY \${options.orderBy}\`;
+        }
+        
+        if (options?.limit) {
+          query += \` LIMIT \${options.limit}\`;
+        }
+        
+        if (options?.offset) {
+          query += \` OFFSET \${options.offset}\`;
+        }
+
+        return this.sql<T>(query);
+      },
+
+      insert: async (data: Partial<T> | Partial<T>[]): Promise<T[]> => {
+        const rows = Array.isArray(data) ? data : [data];
+        const keys = Object.keys(rows[0]);
+        const values = rows.map(row => 
+          \`(\${keys.map(k => \`'\${(row as any)[k]}'\`).join(', ')})\`
+        ).join(', ');
+
+        const query = \`
+          INSERT INTO \${tableName} (\${keys.join(', ')}) 
+          VALUES \${values}
+          RETURNING *
+        \`;
+
+        return this.sql<T>(query);
+      },
+
+      update: async (data: Partial<T>, where: Record<string, any>): Promise<T[]> => {
+        const sets = Object.entries(data)
+          .map(([k, v]) => \`\${k} = '\${v}'\`)
+          .join(', ');
+        
+        const conditions = Object.entries(where)
+          .map(([k, v]) => \`\${k} = '\${v}'\`)
+          .join(' AND ');
+
+        const query = \`
+          UPDATE \${tableName} 
+          SET \${sets} 
+          WHERE \${conditions}
+          RETURNING *
+        \`;
+
+        return this.sql<T>(query);
+      },
+
+      delete: async (where: Record<string, any>): Promise<T[]> => {
+        const conditions = Object.entries(where)
+          .map(([k, v]) => \`\${k} = '\${v}'\`)
+          .join(' AND ');
+
+        const query = \`DELETE FROM \${tableName} WHERE \${conditions} RETURNING *\`;
+        return this.sql<T>(query);
+      },
+    };
+  }
+}
+
+export function createClient(config?: KolaybaseConfig): KolaybaseClient {
+  return new KolaybaseClient(config);
+}
+`;
+  await fs4.mkdir(outputDir, { recursive: true });
+  await fs4.writeFile(path5.join(outputDir, "kolaybase.ts"), clientContent);
+}
+async function generateJsClient(config, outputDir) {
+  const clientContent = `// Generated by Kolaybase CLI
+const axios = require('axios');
+
+class KolaybaseClient {
+  constructor(config = {}) {
+    this.projectId = '${config.projectId}';
+    
+    this.client = axios.create({
+      baseURL: config.url || process.env.API_URL || 'http://localhost:4000',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': \`Bearer \${config.anonKey || process.env.ANON_KEY}\`,
+      },
+    });
+  }
+
+  async sql(query) {
+    const { data } = await this.client.post('/sql/execute', {
+      projectId: this.projectId,
+      query,
+    });
+    return data.rows;
+  }
+
+  table(tableName) {
+    return {
+      select: async (columns = '*', options = {}) => {
+        let query = \`SELECT \${columns} FROM \${tableName}\`;
+        
+        if (options.where) {
+          const conditions = Object.entries(options.where)
+            .map(([k, v]) => \`\${k} = '\${v}'\`)
+            .join(' AND ');
+          query += \` WHERE \${conditions}\`;
+        }
+
+        return this.sql(query);
+      },
+
+      insert: async (data) => {
+        const rows = Array.isArray(data) ? data : [data];
+        const keys = Object.keys(rows[0]);
+        const values = rows.map(row => 
+          \`(\${keys.map(k => \`'\${row[k]}'\`).join(', ')})\`
+        ).join(', ');
+
+        const query = \`INSERT INTO \${tableName} (\${keys.join(', ')}) VALUES \${values} RETURNING *\`;
+        return this.sql(query);
+      },
+    };
+  }
+}
+
+function createClient(config) {
+  return new KolaybaseClient(config);
+}
+
+module.exports = { KolaybaseClient, createClient };
+`;
+  await fs4.mkdir(outputDir, { recursive: true });
+  await fs4.writeFile(path5.join(outputDir, "kolaybase.js"), clientContent);
+}
+async function generatePyClient(config, outputDir) {
+  const clientContent = `# Generated by Kolaybase CLI
+import os
+import requests
+from typing import List, Dict, Any, Optional
+
+class KolaybaseClient:
+    def __init__(self, config: Optional[Dict[str, str]] = None):
+        config = config or {}
+        self.project_id = '${config.projectId}'
+        self.base_url = config.get('url', os.getenv('API_URL', 'http://localhost:4000'))
+        self.anon_key = config.get('anon_key', os.getenv('ANON_KEY'))
+        
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Content-Type': 'application/json',
+            'Authorization': f'Bearer {self.anon_key}'
+        })
+    
+    def sql(self, query: str) -> List[Dict[str, Any]]:
+        response = self.session.post(
+            f'{self.base_url}/sql/execute',
+            json={'projectId': self.project_id, 'query': query}
+        )
+        response.raise_for_status()
+        return response.json()['rows']
+    
+    def table(self, table_name: str):
+        class TableOperations:
+            def __init__(self, client, table):
+                self.client = client
+                self.table = table
+            
+            def select(self, columns='*', where=None, limit=None):
+                query = f'SELECT {columns} FROM {self.table}'
+                
+                if where:
+                    conditions = ' AND '.join([f"{k} = '{v}'" for k, v in where.items()])
+                    query += f' WHERE {conditions}'
+                
+                if limit:
+                    query += f' LIMIT {limit}'
+                
+                return self.client.sql(query)
+        
+        return TableOperations(self, table_name)
+
+def create_client(config: Optional[Dict[str, str]] = None) -> KolaybaseClient:
+    return KolaybaseClient(config)
+`;
+  await fs4.mkdir(outputDir, { recursive: true });
+  await fs4.writeFile(path5.join(outputDir, "kolaybase.py"), clientContent);
+}
+function toPascalCase(str) {
+  return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function pgTypeToTs(pgType) {
+  const typeMap = {
+    "integer": "number",
+    "bigint": "number",
+    "smallint": "number",
+    "decimal": "number",
+    "numeric": "number",
+    "real": "number",
+    "double precision": "number",
+    "serial": "number",
+    "bigserial": "number",
+    "character varying": "string",
+    "varchar": "string",
+    "character": "string",
+    "char": "string",
+    "text": "string",
+    "boolean": "boolean",
+    "date": "string",
+    "timestamp": "string",
+    "timestamp without time zone": "string",
+    "timestamp with time zone": "string",
+    "time": "string",
+    "json": "any",
+    "jsonb": "any",
+    "uuid": "string",
+    "bytea": "Buffer"
+  };
+  return typeMap[pgType.toLowerCase()] || "any";
+}
+var init_gen = __esm({
+  "src/commands/gen.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_api();
+    init_config();
+    init_ui();
+  }
+});
+
+// src/commands/secrets.ts
+var secrets_exports = {};
+__export(secrets_exports, {
+  listSecrets: () => listSecrets,
+  setSecret: () => setSecret,
+  unsetSecret: () => unsetSecret
+});
+import chalk12 from "chalk";
+async function listSecrets() {
+  console.log(chalk12.bold.cyan("Environment Secrets\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  try {
+    const env = await getLocalEnv();
+    if (Object.keys(env).length === 0) {
+      info("No secrets configured");
+      console.log();
+      console.log(chalk12.gray("Add a secret with:"), chalk12.cyan("kb secrets set KEY VALUE"));
+      return;
+    }
+    const masked = Object.entries(env).reduce((acc, [key, value]) => {
+      const sensitive = ["PASSWORD", "SECRET", "KEY", "TOKEN"].some(
+        (s) => key.toUpperCase().includes(s)
+      );
+      acc[key] = sensitive ? maskValue(value) : value;
+      return acc;
+    }, {});
+    printKeyValue(masked);
+    console.log();
+    console.log(chalk12.gray(`Total: ${Object.keys(env).length} secret(s)`));
+  } catch (err) {
+    error(`Failed to list secrets: ${err.message}`);
+  }
+}
+async function setSecret(key, value) {
+  console.log(chalk12.bold.cyan("Set Secret\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  try {
+    await setLocalEnv(key, value);
+    success(`Secret ${chalk12.cyan(key)} set successfully`);
+    console.log();
+    info("Secret saved to .env file");
+  } catch (err) {
+    error(`Failed to set secret: ${err.message}`);
+  }
+}
+async function unsetSecret(key) {
+  console.log(chalk12.bold.cyan("Remove Secret\n"));
+  const config = await getProjectConfig();
+  if (!config) {
+    error("Not in a Kolaybase project. Run: kb init");
+    process.exit(1);
+  }
+  try {
+    await unsetLocalEnv(key);
+    success(`Secret ${chalk12.cyan(key)} removed successfully`);
+  } catch (err) {
+    error(`Failed to remove secret: ${err.message}`);
+  }
+}
+function maskValue(value) {
+  if (value.length <= 8) {
+    return "*".repeat(value.length);
+  }
+  return value.substring(0, 4) + "*".repeat(value.length - 8) + value.substring(value.length - 4);
+}
+var init_secrets = __esm({
+  "src/commands/secrets.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_ui();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/commands/login.ts
+init_esm_shims();
+init_api();
+init_config();
+init_ui();
+import inquirer from "inquirer";
+import chalk3 from "chalk";
+async function loginCommand(options) {
+  printLogo();
+  if (options.apiUrl) {
+    setApiUrl(options.apiUrl);
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "username",
+      message: "Username:",
+      validate: (v) => v.length > 0 || "Required"
+    },
+    {
+      type: "password",
+      name: "password",
+      message: "Password:",
+      mask: "*",
+      validate: (v) => v.length > 0 || "Required"
+    }
+  ]);
+  const spinner = createSpinner("Authenticating\u2026");
+  try {
+    const data = await apiClient.login(answers.username, answers.password);
+    setAccessToken(data.accessToken);
+    setRefreshToken(data.refreshToken);
+    setUserConfig({ username: answers.username });
+    spinner.succeed("Logged in");
+    console.log();
+    success(`Welcome, ${chalk3.cyan(answers.username)}`);
+    console.log(chalk3.gray("  Run  kb init  to create a project or  kb link  to connect to one"));
+  } catch (err) {
+    spinner.fail("Authentication failed");
+    handleApiError(err);
+  }
+}
+
+// src/commands/init.ts
+init_esm_shims();
+init_api();
+init_config();
+init_ui();
+import inquirer2 from "inquirer";
+import chalk4 from "chalk";
+import path3 from "path";
+async function initCommand(options) {
+  if (!isLoggedIn()) {
+    error("Not logged in. Run:  kb login");
+    process.exit(1);
+  }
+  const existingConfig = await getProjectConfig();
+  if (existingConfig?.projectId) {
+    warning(`This directory is already linked to project "${existingConfig.projectName}"`);
+    console.log(chalk4.gray(`  ID: ${existingConfig.projectId}`));
+    console.log();
+    console.log(chalk4.gray("  To link to a different project run:  kb link"));
+    console.log(chalk4.gray("  To unlink first:                     kb unlink"));
+    return;
+  }
+  const spinner = createSpinner("Loading teams\u2026");
+  try {
+    const teams = await apiClient.getTeams();
+    spinner.stop();
+    if (!teams?.length) {
+      error("No teams found. Create an account first via the Admin UI.");
+      process.exit(1);
+    }
+    const answers = await inquirer2.prompt([
+      {
+        type: "list",
+        name: "teamId",
+        message: "Team:",
+        choices: teams.map((t) => ({
+          name: t.personalForUserId ? `${t.name} ${chalk4.gray("(personal)")}` : t.name,
+          value: t.id
+        })),
+        when: teams.length > 1
+      },
+      {
+        type: "input",
+        name: "name",
+        message: "Project name:",
+        default: options.name || path3.basename(process.cwd()),
+        validate: (v) => v.trim().length > 0 || "Required"
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Description (optional):"
+      }
+    ]);
+    const teamId = answers.teamId || teams[0].id;
+    const createSpinnerInstance = createSpinner("Creating project\u2026");
+    const project = await apiClient.createProject({
+      name: answers.name,
+      description: answers.description || void 0,
+      teamId
+    });
+    createSpinnerInstance.succeed("Project created");
+    await setProjectConfig({
+      projectId: project.id,
+      projectName: project.name,
+      projectSlug: project.slug,
+      teamId: project.teamId,
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await writeEnvFile(project);
+    console.log();
+    printHeader("Project ready");
+    console.log();
+    console.log(`    ${chalk4.gray("Name")}          ${project.name}`);
+    console.log(`    ${chalk4.gray("ID")}            ${project.id}`);
+    console.log(`    ${chalk4.gray("Database")}      ${project.dbName}`);
+    console.log(`    ${chalk4.gray("Realm")}         ${project.keycloakRealm}`);
+    console.log();
+    success("Configuration saved to .kolaybase/config.json");
+    success("Credentials saved to .env");
+    console.log();
+    console.log(chalk4.gray("  Next steps:"));
+    console.log(chalk4.gray("    kb status          \u2014 view full connection details"));
+    console.log(chalk4.gray("    kb inspect         \u2014 list database tables"));
+    console.log(chalk4.gray("    kb gen types       \u2014 generate TypeScript types"));
+    console.log(chalk4.gray("    kb db push         \u2014 push a local schema"));
+  } catch (err) {
+    handleApiError(err);
+  }
+}
+
+// src/commands/projects.ts
+init_esm_shims();
+init_api();
+init_config();
+init_ui();
+import inquirer3 from "inquirer";
+import chalk5 from "chalk";
+async function projectsCommand() {
+  if (!isLoggedIn()) {
+    error("You must be logged in to view projects");
+    console.log(chalk5.gray("Run: kb login"));
+    process.exit(1);
+  }
+  const spinner = createSpinner("Loading projects...");
+  try {
+    const teams = await apiClient.getTeams();
+    const team = teams[0];
+    const projects = await apiClient.getProjects(team.id);
+    spinner.stop();
+    if (!projects || projects.length === 0) {
+      info("No projects found");
+      console.log();
+      console.log(chalk5.gray("Create your first project with:"), chalk5.cyan("kb init"));
+      return;
+    }
+    printHeader("Your Projects");
+    console.log();
+    const rows = projects.map((project) => [
+      chalk5.cyan(project.name),
+      project.slug,
+      project.status,
+      new Date(project.createdAt).toLocaleDateString(),
+      project.id
+    ]);
+    printTable(
+      ["Name", "Slug", "Status", "Created", "ID"],
+      rows
+    );
+    console.log();
+    console.log(chalk5.gray(`Total: ${projects.length} project(s)`));
+  } catch (err) {
+    spinner.fail("Failed to load projects");
+    handleApiError(err);
+  }
+}
+async function createProject(options) {
+  if (!isLoggedIn()) {
+    error("You must be logged in to create a project");
+    console.log(chalk5.gray("Run: kb login"));
+    process.exit(1);
+  }
+  try {
+    const teams = await apiClient.getTeams();
+    const team = teams[0];
+    let name = options.name;
+    let description = options.description;
+    if (!name) {
+      const answers = await inquirer3.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Project name:",
+          validate: (input) => input.length > 0 || "Project name is required"
+        },
+        {
+          type: "input",
+          name: "description",
+          message: "Description (optional):"
+        }
+      ]);
+      name = answers.name;
+      description = answers.description;
+    }
+    const spinner = createSpinner("Creating project...");
+    const project = await apiClient.createProject({
+      name,
+      description,
+      teamId: team.id
+    });
+    spinner.succeed("Project created successfully");
+    console.log();
+    console.log(chalk5.gray("Name:"), chalk5.cyan(project.name));
+    console.log(chalk5.gray("ID:"), project.id);
+    console.log(chalk5.gray("Slug:"), project.slug);
+    console.log(chalk5.gray("Database:"), project.dbName);
+    console.log();
+    console.log(chalk5.gray("To start working with this project:"));
+    console.log(chalk5.cyan("  kb init --link"));
+  } catch (err) {
+    handleApiError(err);
+  }
+}
+async function deleteProject(projectId) {
+  if (!isLoggedIn()) {
+    error("You must be logged in to delete a project");
+    console.log(chalk5.gray("Run: kb login"));
+    process.exit(1);
+  }
+  try {
+    const spinner = createSpinner("Loading project...");
+    const project = await apiClient.getProject(projectId);
+    spinner.stop();
+    console.log();
+    console.log(chalk5.yellow("\u26A0 WARNING: This action cannot be undone!"));
+    console.log();
+    console.log(chalk5.gray("Project:"), chalk5.cyan(project.name));
+    console.log(chalk5.gray("Database:"), project.dbName);
+    console.log();
+    const answers = await inquirer3.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to delete this project?",
+        default: false
+      },
+      {
+        type: "input",
+        name: "confirmName",
+        message: `Type the project name "${project.name}" to confirm:`,
+        when: (answers2) => answers2.confirm,
+        validate: (input) => input === project.name || `You must type "${project.name}" exactly`
+      }
+    ]);
+    if (!answers.confirm) {
+      info("Deletion cancelled");
+      return;
+    }
+    const deleteSpinner = createSpinner("Deleting project...");
+    await apiClient.deleteProject(projectId);
+    deleteSpinner.succeed("Project deleted successfully");
+  } catch (err) {
+    handleApiError(err);
+  }
+}
+
+// src/commands/status.ts
+init_esm_shims();
+init_api();
+init_config();
+init_ui();
+import chalk6 from "chalk";
+async function statusCommand(options) {
+  const config = await getProjectConfig();
+  if (!config?.projectId) {
+    error("Not linked to a project. Run:  kb link  or  kb init");
+    process.exit(1);
+  }
+  if (!isLoggedIn()) {
+    error("Not logged in. Run:  kb login");
+    process.exit(1);
+  }
+  const spinner = createSpinner("Fetching project details\u2026");
+  try {
+    const project = await apiClient.getProject(config.projectId);
+    spinner.stop();
+    const mask = (val) => options.showKeys ? val : val.slice(0, 6) + "\u2022".repeat(Math.max(0, val.length - 10)) + val.slice(-4);
+    printHeader(`Project: ${project.name}`);
+    console.log();
+    section("General");
+    row("Project ID", project.id);
+    row("Name", project.name);
+    row("Slug", project.slug);
+    row("Status", statusBadge(project.status));
+    row("Created", new Date(project.createdAt).toLocaleString());
+    console.log();
+    section("Database");
+    row("Host", project.dbHost);
+    row("Port", String(project.dbPort));
+    row("Database", project.dbName);
+    row("User", project.dbUser);
+    row("Password", mask(project.dbPassword));
+    console.log();
+    const connStr = `postgresql://${project.dbUser}:${options.showKeys ? project.dbPassword : "\u2022\u2022\u2022\u2022\u2022\u2022"}@${project.dbHost}:${project.dbPort}/${project.dbName}`;
+    row("Connection string", chalk6.cyan(connStr));
+    console.log();
+    section("Authentication (Keycloak)");
+    row("Realm", project.keycloakRealm);
+    row("Anon Key", mask(project.anonKey));
+    row("Service Key", mask(project.serviceKey));
+    console.log();
+    if (!options.showKeys) {
+      console.log(chalk6.gray("  Tip: use  kb status --show-keys  to reveal secrets"));
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail("Could not fetch project");
+    handleApiError(err);
+  }
+}
+function section(title) {
+  console.log(chalk6.bold(`  ${title}`));
+}
+function row(label, value) {
+  console.log(`    ${chalk6.gray(label.padEnd(20))} ${value}`);
+}
+function statusBadge(status) {
+  switch (status) {
+    case "ACTIVE":
+      return chalk6.green("\u25CF ACTIVE");
+    case "PAUSED":
+      return chalk6.yellow("\u25CF PAUSED");
+    case "DELETED":
+      return chalk6.red("\u25CF DELETED");
+    default:
+      return status;
+  }
+}
+
+// src/commands/link.ts
+init_esm_shims();
+init_api();
+init_config();
+init_ui();
+import inquirer4 from "inquirer";
+import chalk7 from "chalk";
+import fs2 from "fs/promises";
+async function linkCommand(options) {
+  if (!isLoggedIn()) {
+    error("Not logged in. Run:  kb login");
+    process.exit(1);
+  }
+  try {
+    let projectId = options.projectId;
+    if (!projectId) {
+      const spinner2 = createSpinner("Loading projects\u2026");
+      const teams = await apiClient.getTeams();
+      let allProjects = [];
+      for (const team of teams) {
+        const projects = await apiClient.getProjects(team.id);
+        allProjects.push(
+          ...projects.map((p) => ({ ...p, teamName: team.name }))
+        );
+      }
+      spinner2.stop();
+      if (!allProjects.length) {
+        error("No projects found. Create one first:  kb init");
+        process.exit(1);
+      }
+      const { selected } = await inquirer4.prompt([
+        {
+          type: "list",
+          name: "selected",
+          message: "Select a project to link:",
+          choices: allProjects.map((p) => ({
+            name: `${p.name}  ${chalk7.gray(p.slug)}  ${chalk7.gray("\u2014 " + p.teamName)}`,
+            value: p.id
+          }))
+        }
+      ]);
+      projectId = selected;
+    }
+    const spinner = createSpinner("Linking\u2026");
+    const project = await apiClient.getProject(projectId);
+    await setProjectConfig({
+      projectId: project.id,
+      projectName: project.name,
+      projectSlug: project.slug,
+      teamId: project.teamId,
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await writeEnvFile(project);
+    spinner.succeed(`Linked to ${chalk7.cyan(project.name)}`);
+    console.log();
+    console.log(`    ${chalk7.gray("Database")}      ${project.dbName}`);
+    console.log(`    ${chalk7.gray("Realm")}         ${project.keycloakRealm}`);
+    console.log();
+    success("Credentials saved to .env");
+    console.log(chalk7.gray("  Run  kb status  to see full connection details"));
+  } catch (err) {
+    handleApiError(err);
+  }
+}
+async function unlinkProject() {
+  try {
+    await fs2.rm(".kolaybase", { recursive: true, force: true });
+    success("Project unlinked");
+  } catch (err) {
+    error(`Failed to unlink: ${err.message}`);
+  }
+}
+
+// src/commands/logs.ts
+init_esm_shims();
+init_api();
+init_config();
+init_ui();
+import chalk8 from "chalk";
+async function logsCommand(options) {
+  const config = await getProjectConfig();
+  if (!config?.projectId) {
+    error("Not linked to a project. Run:  kb link  or  kb init");
+    process.exit(1);
+  }
+  if (!isLoggedIn()) {
+    error("Not logged in. Run:  kb login");
+    process.exit(1);
+  }
+  const limit = parseInt(options.tail || "50", 10);
+  const spinner = createSpinner("Fetching SQL audit logs\u2026");
+  try {
+    const result = await apiClient.executeSQL(
+      config.projectId,
+      `SELECT 1`
+      // quick connectivity test
+    );
+  } catch {
+  }
+  try {
+    const { Pool: Pool4 } = await import("pg");
+    const { getLocalEnv: getLocalEnv2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const env = await getLocalEnv2();
+    const host = env.DB_HOST || "localhost";
+    const port = env.DB_PORT || "5432";
+    const platformUrl = `postgresql://kolaybase:kolaybase_secret@${host}:${port}/kolaybase`;
+    const pool = new Pool4({ connectionString: platformUrl });
+    const client = await pool.connect();
+    try {
+      const { rows } = await client.query(
+        `SELECT created_at, user_id, query, row_count, duration, error
+         FROM sql_audit_logs
+         WHERE project_id = $1
+         ORDER BY created_at DESC
+         LIMIT $2`,
+        [config.projectId, limit]
+      );
+      spinner.stop();
+      if (!rows.length) {
+        console.log(chalk8.gray("  No SQL logs yet for this project."));
+        return;
+      }
+      printHeader("SQL Audit Logs");
+      console.log();
+      rows.reverse().forEach((r) => {
+        const ts = new Date(r.created_at).toLocaleString();
+        const dur = r.duration != null ? `${r.duration}ms` : "";
+        const badge = r.error ? chalk8.red("ERR") : chalk8.green("OK ");
+        console.log(`  ${chalk8.gray(ts)}  ${badge}  ${chalk8.gray(dur)}`);
+        console.log(`  ${chalk8.cyan(truncate(r.query, 100))}`);
+        if (r.error) {
+          console.log(`  ${chalk8.red(r.error)}`);
+        } else if (r.row_count != null) {
+          console.log(chalk8.gray(`  ${r.row_count} row(s)`));
+        }
+        console.log();
+      });
+      console.log(chalk8.gray(`  Showing ${rows.length} entries`));
+    } finally {
+      client.release();
+      await pool.end();
+    }
+  } catch (err) {
+    spinner.fail("Could not fetch logs");
+    console.log(chalk8.gray(`  ${err.message}`));
+    console.log(chalk8.gray("  Make sure the platform database is accessible."));
+  }
+}
+function truncate(s, max) {
+  const oneLine = s.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("kb").description("Kolaybase CLI \u2014 manage your Kolaybase projects").version("0.1.0");
+program.command("login").description("Authenticate with the Kolaybase platform").option("--api-url <url>", "Platform API URL (default: http://localhost:4000)").action(loginCommand);
+program.command("init").description("Create a new Kolaybase project and link it to the current directory").option("-n, --name <name>", "Project name").action(initCommand);
+program.command("link").description("Link current directory to an existing remote project").option("--project-id <id>", "Project ID to link directly").action(linkCommand);
+program.command("unlink").description("Remove the project link from the current directory").action(unlinkProject);
+program.command("status").description("Show credentials, keys, and connection info for the linked project").option("--show-keys", "Reveal secret values instead of masking them").action(statusCommand);
+program.command("projects").alias("list").description("List all projects in your team").action(projectsCommand);
+program.command("projects:create").description("Create a new project without linking").option("-n, --name <name>", "Project name").option("-d, --description <description>", "Project description").action(createProject);
+program.command("projects:delete <projectId>").description("Delete a remote project (requires confirmation)").action(deleteProject);
+var db = program.command("db").description("Manage the project database");
+db.command("push").description("Push local schema to the project database").action(async () => {
+  const { dbPush: dbPush2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+  await dbPush2();
+});
+db.command("pull").description("Introspect the remote database and save schema locally").action(async () => {
+  const { dbPull: dbPull2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+  await dbPull2();
+});
+db.command("reset").description("Drop all tables in the project database").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+  const { dbReset: dbReset2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+  await dbReset2(options);
+});
+db.command("seed").description("Run the seed file against the project database").action(async () => {
+  const { dbSeed: dbSeed2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+  await dbSeed2();
+});
+db.command("dump").description("Dump the full database schema to SQL").option("-o, --output <file>", "Output file", "schema.sql").action(async (options) => {
+  const { dbDump: dbDump2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+  await dbDump2(options);
+});
+program.command("inspect").description("Show database tables, columns, sizes, and row counts").option("-t, --table <name>", "Inspect a specific table").action(async (options) => {
+  const { inspectCommand: inspectCommand2 } = await Promise.resolve().then(() => (init_inspect(), inspect_exports));
+  await inspectCommand2(options);
+});
+var gen = program.command("gen").description("Generate code from the project database");
+gen.command("types").description("Generate TypeScript types from the database schema").option("-o, --output <path>", "Output directory", "./types").action(async (options) => {
+  const { genTypes: genTypes2 } = await Promise.resolve().then(() => (init_gen(), gen_exports));
+  await genTypes2(options);
+});
+gen.command("client").description("Generate a ready-to-use API client").option("-l, --lang <language>", "Language: typescript | javascript | python", "typescript").option("-o, --output <path>", "Output directory", "./lib").action(async (options) => {
+  const { genClient: genClient2 } = await Promise.resolve().then(() => (init_gen(), gen_exports));
+  await genClient2(options);
+});
+program.command("logs").description("Show SQL audit logs for the linked project").option("-n, --tail <lines>", "Number of recent entries", "50").action(logsCommand);
+var secrets = program.command("secrets").description("Manage local .env variables for the linked project");
+secrets.command("list").description("List all variables (sensitive values masked)").action(async () => {
+  const { listSecrets: listSecrets2 } = await Promise.resolve().then(() => (init_secrets(), secrets_exports));
+  await listSecrets2();
+});
+secrets.command("set <key> <value>").description("Set or update a variable").action(async (key, value) => {
+  const { setSecret: setSecret2 } = await Promise.resolve().then(() => (init_secrets(), secrets_exports));
+  await setSecret2(key, value);
+});
+secrets.command("unset <key>").description("Remove a variable").action(async (key) => {
+  const { unsetSecret: unsetSecret2 } = await Promise.resolve().then(() => (init_secrets(), secrets_exports));
+  await unsetSecret2(key);
+});
+program.parse();
+//# sourceMappingURL=index.js.map