@basictech/cli 0.0.29 → 0.0.31

package/dist/index.js

@@ -1,243 +1,3499 @@
 #!/usr/bin/env node
-import { program } from 'commander';
-import { MESSAGES } from './lib/constants.js';
-import { getVersion } from './lib/version.js';
-import { formatError, handleError } from './lib/errors.js';
-import { findSimilarCommands } from './lib/platform.js';
-// Set up global error handlers
-process.on('uncaughtException', (error) => {
-    console.error('Fatal error:', error.message);
+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 });
+};
+
+// dist/lib/constants.js
+var CONSTANTS, COMMANDS, MESSAGES;
+var init_constants = __esm({
+  "dist/lib/constants.js"() {
+    "use strict";
+    CONSTANTS = {
+      CLI_DIR: ".basic-cli",
+      TOKEN_FILE: "token.json",
+      API_BASE: "https://api.basic.tech",
+      OAUTH_CLIENT_ID: "9c3f6704-87e7-4af9-8dd0-36dcb9b5c18c",
+      OAUTH_REDIRECT: "http://localhost:8080/callback",
+      OAUTH_SCOPES: "profile,admin",
+      MAX_WIDTH: 80,
+      SIMILARITY_THRESHOLD: 0.4,
+      GITHUB_REPO: "basicdb/basic-cli"
+    };
+    COMMANDS = [
+      "account",
+      "login",
+      "logout",
+      "status",
+      "projects",
+      "teams",
+      "init",
+      "version",
+      "help",
+      "push",
+      "pull",
+      "debug",
+      "update"
+    ];
+    MESSAGES = {
+      OFFLINE: "you are offline. please check your internet connection.",
+      LOGGED_OUT: "you are not logged in. please login with 'basic login'",
+      WELCOME: "welcome to basic-cli! use 'basic help' to see all commands"
+    };
+  }
+});
+
+// dist/lib/version.js
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+function getVersion() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    cachedVersion = packageJson.version;
+    return cachedVersion;
+  } catch (error) {
+    console.error("Error reading version:", error);
+    const fallbackVersion = "0.0.22";
+    cachedVersion = fallbackVersion;
+    return fallbackVersion;
+  }
+}
+var cachedVersion;
+var init_version = __esm({
+  "dist/lib/version.js"() {
+    "use strict";
+    cachedVersion = null;
+  }
+});
+
+// dist/lib/errors.js
+function handleError(error) {
+  if (error instanceof BasicCliError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    if (error.message.includes("ENOTFOUND") || error.message.includes("network")) {
+      return new NetworkError();
+    }
+    if (error.message.includes("unauthorized") || error.message.includes("401")) {
+      return new AuthError("Authentication failed", [
+        "Try logging in again with 'basic login'",
+        "Check if your token has expired"
+      ]);
+    }
+    if (error.message.includes("invalid character")) {
+      return new SchemaError("Invalid schema format", [
+        "Check for trailing commas in your schema",
+        "Ensure valid JSON syntax"
+      ]);
+    }
+    return new BasicCliError(error.message, "UNKNOWN_ERROR");
+  }
+  return new BasicCliError("An unknown error occurred", "UNKNOWN_ERROR");
+}
+function formatError(error) {
+  let output = `Error: ${error.message}`;
+  if (error.suggestions && error.suggestions.length > 0) {
+    output += "\n\nSuggestions:";
+    error.suggestions.forEach((suggestion) => {
+      output += `
+  - ${suggestion}`;
+    });
+  }
+  return output;
+}
+var BasicCliError, AuthError, ApiError, SchemaError, NetworkError;
+var init_errors = __esm({
+  "dist/lib/errors.js"() {
+    "use strict";
+    BasicCliError = class extends Error {
+      code;
+      suggestions;
+      constructor(message, code, suggestions) {
+        super(message);
+        this.code = code;
+        this.suggestions = suggestions;
+        this.name = "BasicCliError";
+      }
+    };
+    AuthError = class extends BasicCliError {
+      constructor(message, suggestions) {
+        super(message, "AUTH_ERROR", suggestions);
+        this.name = "AuthError";
+      }
+    };
+    ApiError = class extends BasicCliError {
+      statusCode;
+      constructor(message, statusCode, suggestions) {
+        super(message, "API_ERROR", suggestions);
+        this.statusCode = statusCode;
+        this.name = "ApiError";
+      }
+    };
+    SchemaError = class extends BasicCliError {
+      constructor(message, suggestions) {
+        super(message, "SCHEMA_ERROR", suggestions);
+        this.name = "SchemaError";
+      }
+    };
+    NetworkError = class extends BasicCliError {
+      constructor(message = "Network connection failed") {
+        super(message, "NETWORK_ERROR", [
+          "Check your internet connection",
+          "Try again in a moment"
+        ]);
+        this.name = "NetworkError";
+      }
+    };
+  }
+});
+
+// dist/lib/platform.js
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as os from "os";
+import * as path from "path";
+function getConfigPath() {
+  const home = os.homedir();
+  return path.join(home, CONSTANTS.CLI_DIR, CONSTANTS.TOKEN_FILE);
+}
+function getConfigDir() {
+  const home = os.homedir();
+  return path.join(home, CONSTANTS.CLI_DIR);
+}
+async function openBrowser(url) {
+  const platform = process.platform;
+  const commands = {
+    darwin: "open",
+    win32: "start",
+    linux: "xdg-open"
+  };
+  const command = commands[platform];
+  if (!command) {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+  try {
+    if (platform === "win32") {
+      await execAsync(`${command} "" "${url}"`);
+    } else {
+      await execAsync(`${command} "${url}"`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to open browser: ${error}`);
+  }
+}
+async function copyToClipboard(text) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      await execAsync(`echo "${text}" | pbcopy`);
+    } else if (platform === "win32") {
+      await execAsync(`echo ${text} | clip`);
+    } else {
+      try {
+        await execAsync(`echo "${text}" | xclip -selection clipboard`);
+      } catch {
+        await execAsync(`echo "${text}" | xsel --clipboard --input`);
+      }
+    }
+  } catch (error) {
+    throw new Error(`Failed to copy to clipboard: ${error}`);
+  }
+}
+function isOnline() {
+  return fetch(CONSTANTS.API_BASE, { method: "HEAD" }).then(() => true).catch(() => false);
+}
+function similarity(s1, s2) {
+  const d = levenshteinDistance(s1, s2);
+  const maxLen = Math.max(s1.length, s2.length);
+  if (maxLen === 0)
+    return 1;
+  return 1 - d / maxLen;
+}
+function levenshteinDistance(s1, s2) {
+  if (s1.length === 0)
+    return s2.length;
+  if (s2.length === 0)
+    return s1.length;
+  const matrix = [];
+  for (let i = 0; i <= s1.length; i++) {
+    matrix[i] = [];
+    matrix[i][0] = i;
+  }
+  for (let j = 0; j <= s2.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= s1.length; i++) {
+    for (let j = 1; j <= s2.length; j++) {
+      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+  return matrix[s1.length][s2.length];
+}
+function findSimilarCommands(input) {
+  const commands = COMMANDS.filter((cmd) => cmd !== input);
+  const suggestions = [];
+  for (const command of commands) {
+    const sim = similarity(input, command);
+    if (sim >= CONSTANTS.SIMILARITY_THRESHOLD) {
+      suggestions.push({ command, similarity: sim });
+    }
+  }
+  return suggestions.sort((a, b) => b.similarity - a.similarity).slice(0, 3).map((s) => s.command);
+}
+function generateSlug(name) {
+  return name.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+var execAsync;
+var init_platform = __esm({
+  "dist/lib/platform.js"() {
+    "use strict";
+    init_constants();
+    execAsync = promisify(exec);
+  }
+});
+
+// dist/lib/auth.js
+import { createServer } from "http";
+import { promises as fs } from "fs";
+var AuthService;
+var init_auth = __esm({
+  "dist/lib/auth.js"() {
+    "use strict";
+    init_constants();
+    init_platform();
+    init_errors();
+    AuthService = class _AuthService {
+      static instance;
+      static getInstance() {
+        if (!_AuthService.instance) {
+          _AuthService.instance = new _AuthService();
+        }
+        return _AuthService.instance;
+      }
+      async login() {
+        try {
+          const token = await this.startOAuthFlow();
+          await this.saveToken(token);
+        } catch (error) {
+          throw handleError(error);
+        }
+      }
+      async logout() {
+        try {
+          await this.deleteToken();
+        } catch (error) {
+          throw handleError(error);
+        }
+      }
+      async getToken() {
+        try {
+          const tokenPath = getConfigPath();
+          const tokenData = await fs.readFile(tokenPath, "utf8");
+          const token = JSON.parse(tokenData);
+          if (token.expires_at && Date.now() > token.expires_at) {
+            const refreshedToken = await this.refreshToken(token);
+            await this.saveToken(refreshedToken);
+            return refreshedToken;
+          }
+          return token;
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            return null;
+          }
+          throw handleError(error);
+        }
+      }
+      async getUserInfo() {
+        const token = await this.getToken();
+        if (!token) {
+          throw new AuthError("Not logged in");
+        }
+        const response = await fetch(`${CONSTANTS.API_BASE}/auth/userInfo`, {
+          headers: {
+            Authorization: `Bearer ${token.access_token}`
+          }
+        });
+        if (!response.ok) {
+          throw new AuthError("Failed to fetch user info");
+        }
+        return await response.json();
+      }
+      async startOAuthFlow() {
+        return new Promise((resolve, reject) => {
+          const server = createServer((req, res) => {
+            if (req.url?.startsWith("/callback")) {
+              const url = new URL(req.url, CONSTANTS.OAUTH_REDIRECT);
+              const code = url.searchParams.get("code");
+              const state = url.searchParams.get("state");
+              if (!code) {
+                res.writeHead(400);
+                res.end("Authorization code not found");
+                server.close();
+                reject(new AuthError("Authorization code not found"));
+                return;
+              }
+              this.exchangeCodeForToken(code).then((token) => {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(this.getSuccessHtml());
+                server.close();
+                resolve(token);
+              }).catch((error) => {
+                res.writeHead(500);
+                res.end("Authentication failed");
+                server.close();
+                reject(error);
+              });
+            } else {
+              res.writeHead(404);
+              res.end("Not found");
+            }
+          });
+          server.listen(8080, async () => {
+            const state = this.generateState();
+            const authUrl = `${CONSTANTS.API_BASE}/auth/authorize?client_id=${CONSTANTS.OAUTH_CLIENT_ID}&redirect_uri=${encodeURIComponent(CONSTANTS.OAUTH_REDIRECT)}&response_type=code&scope=${encodeURIComponent(CONSTANTS.OAUTH_SCOPES)}&state=${state}`;
+            try {
+              await openBrowser(authUrl);
+            } catch (error) {
+              console.log(`Please visit this URL to log in: ${authUrl}`);
+            }
+          });
+          setTimeout(() => {
+            server.close();
+            reject(new AuthError("Authentication timeout"));
+          }, 5 * 60 * 1e3);
+        });
+      }
+      async exchangeCodeForToken(code) {
+        const response = await fetch(`${CONSTANTS.API_BASE}/auth/token`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded"
+          },
+          body: new URLSearchParams({
+            grant_type: "authorization_code",
+            client_id: CONSTANTS.OAUTH_CLIENT_ID,
+            code,
+            redirect_uri: CONSTANTS.OAUTH_REDIRECT
+          })
+        });
+        if (!response.ok) {
+          throw new AuthError("Failed to exchange code for token");
+        }
+        const data = await response.json();
+        return {
+          access_token: data.access_token,
+          refresh_token: data.refresh_token,
+          expires_at: Date.now() + data.expires_in * 1e3,
+          token_type: data.token_type || "Bearer"
+        };
+      }
+      async refreshToken(token) {
+        const response = await fetch(`${CONSTANTS.API_BASE}/auth/token`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded"
+          },
+          body: new URLSearchParams({
+            grant_type: "refresh_token",
+            client_id: CONSTANTS.OAUTH_CLIENT_ID,
+            code: token.refresh_token
+          })
+        });
+        if (!response.ok) {
+          throw new AuthError("Failed to refresh token", [
+            "Try logging in again with 'basic login'"
+          ]);
+        }
+        const data = await response.json();
+        return {
+          access_token: data.access_token,
+          refresh_token: data.refresh_token || token.refresh_token,
+          expires_at: Date.now() + data.expires_in * 1e3,
+          token_type: data.token_type || "Bearer"
+        };
+      }
+      async saveToken(token) {
+        const tokenPath = getConfigPath();
+        const configDir = getConfigDir();
+        await fs.mkdir(configDir, { recursive: true });
+        await fs.writeFile(tokenPath, JSON.stringify(token, null, 2), { mode: 384 });
+      }
+      async deleteToken() {
+        const tokenPath = getConfigPath();
+        try {
+          await fs.unlink(tokenPath);
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+      generateState() {
+        const array = new Uint8Array(24);
+        crypto.getRandomValues(array);
+        return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+      }
+      getSuccessHtml() {
+        return `
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <meta charset="UTF-8">
+        <title>Basic CLI Authentication</title>
+        <style>
+          :root { color-scheme: light dark; }
+          @media (prefers-color-scheme: light) {
+            :root {
+              --bg-color: #f5f5f5;
+              --container-bg: #ffffff;
+              --text-color: #000000;
+              --shadow: 0 2px 4px rgba(0,0,0,0.1);
+            }
+          }
+          @media (prefers-color-scheme: dark) {
+            :root {
+              --bg-color: #1a1a1a;
+              --container-bg: #2d2d2d;
+              --text-color: #ffffff;
+              --shadow: 0 2px 4px rgba(0,0,0,0.3);
+            }
+          }
+          body {
+            font-family: monospace;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            margin: 0;
+            background-color: var(--bg-color);
+            color: var(--text-color);
+          }
+          .container {
+            text-align: center;
+            padding: 2rem;
+            background: var(--container-bg);
+            border-radius: 8px;
+            box-shadow: var(--shadow);
+          }
+          .success-icon {
+            color: #AE87FF;
+            font-size: 32px;
+            margin-bottom: 1rem;
+          }
+          h2 { margin: 0 0 1rem 0; }
+          p { margin: 0; opacity: 0.8; }
+          .help-text {
+            margin-top: 1.5rem;
+            font-size: 0.9em;
+            opacity: 0.7;
+            text-align: left;
+          }
+          .help-text ol {
+            margin: 0;
+            padding-left: 1.5rem;
+          }
+          .help-text li { margin: 0.3rem 0; }
+          code {
+            background: var(--bg-color);
+            padding: 0.2em 0.4em;
+            border-radius: 4px;
+            font-family: monospace;
+            font-size: 0.9em;
+          }
+          a {
+            color: #AE87FF;
+            text-decoration: none;
+          }
+          a:hover { text-decoration: underline; }
+        </style>
+      </head>
+      <body>
+        <div class="container">
+          <div class="success-icon">\u2705</div>
+          <h2>Authentication Successful!</h2>
+          <p>You can close this window and return to the CLI.</p>
+          <div class="help-text">
+            <ol>
+              <li>Use command <code>basic help</code> to get started with the CLI</li>
+              <li>Visit the <a href="https://docs.basic.tech" target="_blank">Basic docs</a> for more info</li>
+            </ol>
+          </div>
+        </div>
+        <script>
+          setTimeout(() => window.close(), 3000);
+        </script>
+      </body>
+      </html>
+    `;
+      }
+    };
+  }
+});
+
+// dist/commands/login.js
+var login_exports = {};
+__export(login_exports, {
+  LoginCommand: () => LoginCommand
+});
+async function LoginCommand() {
+  if (!await isOnline()) {
+    throw new Error(MESSAGES.OFFLINE);
+  }
+  const authService = AuthService.getInstance();
+  const existingToken = await authService.getToken();
+  if (existingToken) {
+    console.log("Already logged in with a valid token.");
+    return;
+  }
+  console.log("\u{1F510} Opening browser for login...");
+  await authService.login();
+  console.log("\u2705 Login successful! Hello :)");
+}
+var init_login = __esm({
+  "dist/commands/login.js"() {
+    "use strict";
+    init_auth();
+    init_platform();
+    init_constants();
+  }
+});
+
+// dist/commands/logout.js
+var logout_exports = {};
+__export(logout_exports, {
+  LogoutCommand: () => LogoutCommand
+});
+async function LogoutCommand() {
+  const authService = AuthService.getInstance();
+  await authService.logout();
+  console.log("Logged out successfully");
+}
+var init_logout = __esm({
+  "dist/commands/logout.js"() {
+    "use strict";
+    init_auth();
+  }
+});
+
+// dist/commands/account.js
+var account_exports = {};
+__export(account_exports, {
+  AccountCommand: () => AccountCommand
+});
+async function AccountCommand() {
+  if (!await isOnline()) {
+    throw new Error(MESSAGES.OFFLINE);
+  }
+  const authService = AuthService.getInstance();
+  const token = await authService.getToken();
+  if (!token) {
+    throw new Error(MESSAGES.LOGGED_OUT);
+  }
+  const userInfo = await authService.getUserInfo();
+  console.log("Logged in user:", userInfo.email);
+}
+var init_account = __esm({
+  "dist/commands/account.js"() {
+    "use strict";
+    init_auth();
+    init_platform();
+    init_constants();
+  }
+});
+
+// dist/lib/api.js
+var ApiClient;
+var init_api = __esm({
+  "dist/lib/api.js"() {
+    "use strict";
+    init_constants();
+    init_auth();
+    init_errors();
+    ApiClient = class _ApiClient {
+      static instance;
+      authService;
+      constructor() {
+        this.authService = AuthService.getInstance();
+      }
+      static getInstance() {
+        if (!_ApiClient.instance) {
+          _ApiClient.instance = new _ApiClient();
+        }
+        return _ApiClient.instance;
+      }
+      async request(endpoint, options = {}) {
+        try {
+          const token = await this.authService.getToken();
+          const response = await fetch(`${CONSTANTS.API_BASE}${endpoint}`, {
+            ...options,
+            headers: {
+              "Content-Type": "application/json",
+              ...token && { Authorization: `Bearer ${token.access_token}` },
+              ...options.headers
+            }
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new ApiError(`API Error: ${response.status} - ${errorText}`, response.status);
+          }
+          return response.json();
+        } catch (error) {
+          throw handleError(error);
+        }
+      }
+      async getProjects() {
+        const response = await this.request("/project");
+        return response.data;
+      }
+      async createProject(data) {
+        const response = await this.request("/project", {
+          method: "POST",
+          body: JSON.stringify(data)
+        });
+        return response.data;
+      }
+      async createProjectWithTeam(name, slug, teamId) {
+        const response = await this.request("/project", {
+          method: "POST",
+          body: JSON.stringify({
+            name,
+            slug,
+            team_id: teamId
+          })
+        });
+        return response.data;
+      }
+      async getProject(projectId) {
+        const response = await this.request(`/project/${projectId}`);
+        return response.data;
+      }
+      async getTeams() {
+        const response = await this.request("/team");
+        return response.data;
+      }
+      async createTeam(name, slug) {
+        const response = await this.request("/team", {
+          method: "POST",
+          body: JSON.stringify({ name, slug })
+        });
+        return response.data;
+      }
+      async checkTeamSlugAvailability(slug) {
+        try {
+          const response = await this.request(`/team/slug?slug=${encodeURIComponent(slug)}`);
+          return response.available;
+        } catch (error) {
+          return false;
+        }
+      }
+      async getProjectSchema(projectId) {
+        try {
+          const response = await this.request(`/project/${projectId}/schema`);
+          if (response.data.length === 0) {
+            return null;
+          }
+          return response.data[0].schema;
+        } catch (error) {
+          if (error instanceof ApiError && error.statusCode === 404) {
+            return null;
+          }
+          throw error;
+        }
+      }
+      async pushProjectSchema(projectId, schema) {
+        await this.request(`/project/${projectId}/schema`, {
+          method: "POST",
+          body: JSON.stringify({ schema })
+        });
+      }
+      async validateSchema(schema) {
+        const response = await this.request("/utils/schema/verifyUpdateSchema", {
+          method: "POST",
+          body: JSON.stringify({ schema })
+        });
+        return response;
+      }
+      async compareSchema(schema) {
+        const response = await this.request("/utils/schema/compareSchema", {
+          method: "POST",
+          body: JSON.stringify({ schema })
+        });
+        return response;
+      }
+      async checkLatestRelease() {
+        try {
+          const response = await fetch(`https://registry.npmjs.org/@basictech/cli/latest`);
+          if (!response.ok) {
+            throw new Error("Failed to check for updates");
+          }
+          const data = await response.json();
+          return data.version;
+        } catch (error) {
+          throw handleError(error);
+        }
+      }
+    };
+  }
+});
+
+// dist/commands/version.js
+var version_exports = {};
+__export(version_exports, {
+  VersionCommand: () => VersionCommand
+});
+async function VersionCommand() {
+  const currentVersion = getVersion();
+  console.log(`basic-cli version ${currentVersion}`);
+  try {
+    const apiClient = ApiClient.getInstance();
+    const latestVersion = await apiClient.checkLatestRelease();
+    if (latestVersion !== currentVersion) {
+      console.log(`New version available: ${latestVersion}`);
+      console.log("\nPlease update with 'basic update'");
+    } else {
+      console.log("You are running the latest version!");
+    }
+  } catch (error) {
+    console.log("\nOopsy - could not check if new version is available.");
+  }
+}
+var init_version2 = __esm({
+  "dist/commands/version.js"() {
+    "use strict";
+    init_version();
+    init_api();
+  }
+});
+
+// dist/commands/update.js
+var update_exports = {};
+__export(update_exports, {
+  UpdateCommand: () => UpdateCommand
+});
+import { spawn } from "child_process";
+async function UpdateCommand() {
+  try {
+    if (!await isOnline()) {
+      console.error(MESSAGES.OFFLINE);
+      process.exit(1);
+    }
+    const currentVersion = getVersion();
+    console.log(`Current version: ${currentVersion}`);
+    console.log("Checking for updates...");
+    const apiClient = ApiClient.getInstance();
+    const latestVersion = await apiClient.checkLatestRelease();
+    if (latestVersion === currentVersion) {
+      console.log("\u2705 You are already running the latest version!");
+      return;
+    }
+    console.log(`\u{1F680} New version available: ${latestVersion}`);
+    console.log("Updating...");
+    await updatePackage();
+  } catch (error) {
+    console.error("\u274C Error checking for updates:", error instanceof Error ? error.message : "Unknown error");
+    console.log("\n\u{1F4A1} You can try updating manually:");
+    console.log("   npm update -g @basictech/cli");
+    console.log("\n\u{1F4DA} Or visit: https://docs.basic.tech");
     process.exit(1);
+  }
+}
+async function updatePackage() {
+  return new Promise((resolve, reject) => {
+    const updateProcess = spawn("npm", ["update", "-g", "@basictech/cli"], {
+      stdio: "pipe",
+      shell: true
+    });
+    let output = "";
+    let errorOutput = "";
+    updateProcess.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    updateProcess.stderr?.on("data", (data) => {
+      errorOutput += data.toString();
+    });
+    updateProcess.on("close", (code) => {
+      if (code === 0) {
+        console.log("\u2705 Update successful!");
+        console.log("\n\u{1F389} Basic CLI has been updated to the latest version.");
+        console.log("\u{1F4A1} Run `basic version` to verify the update.");
+        resolve();
+      } else {
+        console.error("\u274C Error updating CLI");
+        console.log("\n\u{1F4A1} Please try updating manually:");
+        console.log("   npm update -g @basictech/cli");
+        console.log("\n\u{1F4DA} Or visit: https://docs.basic.tech");
+        if (errorOutput) {
+          console.log("\nError details:", errorOutput);
+        }
+        reject(new Error(`Update process exited with code ${code}`));
+      }
+    });
+    updateProcess.on("error", (error) => {
+      console.error("\u274C Failed to start update process");
+      console.log("\n\u{1F4A1} Please try updating manually:");
+      console.log("   npm update -g @basictech/cli");
+      console.log("\n\u{1F4DA} Or visit: https://docs.basic.tech");
+      reject(error);
+    });
+  });
+}
+var init_update = __esm({
+  "dist/commands/update.js"() {
+    "use strict";
+    init_version();
+    init_api();
+    init_platform();
+    init_constants();
+  }
 });
-process.on('SIGINT', () => {
-    console.log('\nOperation cancelled');
-    process.exit(0);
+
+// dist/commands/debug.js
+var debug_exports = {};
+__export(debug_exports, {
+  DebugCommand: () => DebugCommand
 });
-// Configure the CLI
-program
-    .name('basic')
-    .description('Basic CLI for creating & managing your projects')
-    .version(getVersion());
-// Login command
-program
-    .command('login')
-    .description('Login to your Basic account')
-    .action(async () => {
-    try {
-        const { LoginCommand } = await import('./commands/login.js');
-        await LoginCommand();
+async function DebugCommand() {
+  const configDir = getConfigDir();
+  console.log(`Basic CLI config directory: ${configDir}`);
+}
+var init_debug = __esm({
+  "dist/commands/debug.js"() {
+    "use strict";
+    init_platform();
+  }
+});
+
+// dist/components/Table.js
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+function Table({ columns, rows, onSelect, onCopy, onOpen, onNew, onExit, helpText }) {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [notification, setNotification] = useState("");
+  const defaultHelpText = {
+    copyAction: "'c' to copy project ID",
+    openAction: "'o' to open in browser",
+    newAction: void 0
+  };
+  const currentHelpText = helpText || defaultHelpText;
+  useInput((input, key) => {
+    if (key.upArrow && rows.length > 0) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow && rows.length > 0) {
+      setSelectedIndex((prev) => Math.min(rows.length - 1, prev + 1));
+    } else if (key.return && rows[selectedIndex] && onSelect) {
+      onSelect(rows[selectedIndex], selectedIndex);
+    } else if (input === "c" && rows[selectedIndex] && onCopy) {
+      onCopy(rows[selectedIndex], selectedIndex);
+      const itemType = helpText?.copyAction.includes("team") ? "Team ID" : "Project ID";
+      setNotification(`${itemType} copied to clipboard!`);
+      setTimeout(() => setNotification(""), 3e3);
+    } else if (input === "o" && rows[selectedIndex] && onOpen) {
+      onOpen(rows[selectedIndex], selectedIndex);
+    } else if (input === "n" && onNew) {
+      onNew();
+    } else if (key.escape || key.ctrl && input === "c") {
+      if (onExit) {
+        onExit();
+      } else {
         process.exit(0);
+      }
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+  });
+  useEffect(() => {
+    if (selectedIndex >= rows.length) {
+      setSelectedIndex(Math.max(0, rows.length - 1));
     }
+  }, [rows.length, selectedIndex]);
+  const renderHeader = () => _jsx(Box, { borderStyle: "single", borderBottom: true, paddingX: 1, children: _jsx(Box, { children: columns.map((column, index) => _jsx(Box, { width: column.width, marginRight: index < columns.length - 1 ? 1 : 0, children: _jsx(Text, { bold: true, children: column.title }) }, column.key)) }) });
+  const renderRow = (row, index) => {
+    const isSelected = index === selectedIndex;
+    return _jsx(Box, { children: _jsx(Box, { paddingX: 1, children: columns.map((column, colIndex) => _jsx(Box, { width: column.width, marginRight: colIndex < columns.length - 1 ? 1 : 0, children: _jsx(Text, { color: isSelected ? "black" : void 0, backgroundColor: isSelected ? "magenta" : void 0, children: (row[column.key] || "").substring(0, column.width - 1) }) }, column.key)) }) }, index);
+  };
+  const renderHelp = () => {
+    const mainActionsText = [
+      currentHelpText.copyAction,
+      currentHelpText.openAction
+    ].filter(Boolean).join(" \u2022 ");
+    return _jsxs(Box, { marginTop: 2, children: [notification && _jsx(Box, { marginBottom: 2, children: _jsx(Text, { color: "blue", children: notification }) }), _jsxs(Box, { flexDirection: "column", children: [currentHelpText.newAction && _jsx(Text, { color: "gray", children: currentHelpText.newAction }), _jsx(Text, { color: "gray", children: mainActionsText }), _jsx(Text, { color: "gray", children: "\u2191/\u2193 to navigate \u2022 esc to quit" })] })] });
+  };
+  if (rows.length === 0) {
+    const itemType = helpText?.copyAction.includes("team") ? "teams" : "projects";
+    return _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["No ", itemType, " found."] }), _jsxs(Box, { marginTop: 2, flexDirection: "column", children: [currentHelpText.newAction && _jsx(Text, { color: "gray", children: currentHelpText.newAction }), _jsx(Text, { color: "gray", children: "Press esc to quit" })] })] });
+  }
+  return _jsxs(Box, { flexDirection: "column", children: [renderHeader(), _jsx(Box, { flexDirection: "column", children: rows.map((row, index) => renderRow(row, index)) }), renderHelp()] });
+}
+var init_Table = __esm({
+  "dist/components/Table.js"() {
+    "use strict";
+  }
 });
-// Logout command
-program
-    .command('logout')
-    .description('Logout from your Basic account')
-    .action(async () => {
+
+// dist/components/Spinner.js
+import { jsx as _jsx2, jsxs as _jsxs2 } from "react/jsx-runtime";
+import React from "react";
+import { Text as Text2 } from "ink";
+var spinnerFrames, Spinner;
+var init_Spinner = __esm({
+  "dist/components/Spinner.js"() {
+    "use strict";
+    spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    Spinner = ({ text = "Loading..." }) => {
+      const [frame, setFrame] = React.useState(0);
+      React.useEffect(() => {
+        const timer = setInterval(() => {
+          setFrame((prev) => (prev + 1) % spinnerFrames.length);
+        }, 80);
+        return () => clearInterval(timer);
+      }, []);
+      return _jsxs2(Text2, { children: [_jsx2(Text2, { color: "cyan", children: spinnerFrames[frame] }), " ", text] });
+    };
+  }
+});
+
+// dist/commands/projects.js
+var projects_exports = {};
+__export(projects_exports, {
+  ProjectsCommand: () => ProjectsCommand
+});
+import { jsx as _jsx3 } from "react/jsx-runtime";
+import React2 from "react";
+import { render, Text as Text3 } from "ink";
+function ProjectsApp() {
+  const [state, setState] = React2.useState({
+    loading: true,
+    projects: [],
+    error: null
+  });
+  React2.useEffect(() => {
+    async function loadProjects() {
+      try {
+        if (!await isOnline()) {
+          setState((prev) => ({ ...prev, loading: false, error: MESSAGES.OFFLINE }));
+          return;
+        }
+        const authService = AuthService.getInstance();
+        const token = await authService.getToken();
+        if (!token) {
+          setState((prev) => ({ ...prev, loading: false, error: MESSAGES.LOGGED_OUT }));
+          return;
+        }
+        const apiClient = ApiClient.getInstance();
+        const projects = await apiClient.getProjects();
+        setState({
+          loading: false,
+          projects,
+          error: null
+        });
+      } catch (error) {
+        setState({
+          loading: false,
+          projects: [],
+          error: error instanceof Error ? error.message : "Failed to load projects"
+        });
+      }
+    }
+    loadProjects();
+  }, []);
+  const handleCopy = async (row) => {
     try {
-        const { LogoutCommand } = await import('./commands/logout.js');
-        await LogoutCommand();
-        process.exit(0);
+      await copyToClipboard(row.id);
+    } catch (error) {
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+  };
+  const handleOpen = async (row) => {
+    try {
+      await openBrowser(`https://app.basic.tech/project/${row.id}`);
+    } catch (error) {
     }
+  };
+  const handleExit = () => {
+    process.exit(0);
+  };
+  if (state.loading) {
+    return _jsx3(Spinner, { text: "Loading projects..." });
+  }
+  if (state.error) {
+    return _jsx3(Text3, { color: "red", children: state.error });
+  }
+  const columns = [
+    { title: "ID", width: 38, key: "id" },
+    { title: "Name", width: 25, key: "name" },
+    { title: "Team", width: 30, key: "team_name" }
+  ];
+  const rows = state.projects.map((project) => ({
+    id: project.id,
+    name: project.name,
+    team_name: project.team_name
+  }));
+  return _jsx3(Table, { columns, rows, onCopy: handleCopy, onOpen: handleOpen, onExit: handleExit });
+}
+async function ProjectsCommand() {
+  render(_jsx3(ProjectsApp, {}));
+}
+var init_projects = __esm({
+  "dist/commands/projects.js"() {
+    "use strict";
+    init_Table();
+    init_Spinner();
+    init_api();
+    init_auth();
+    init_platform();
+    init_constants();
+  }
 });
-// Account command
-program
-    .command('account')
-    .description('Show account information')
-    .action(async () => {
-    try {
-        const { AccountCommand } = await import('./commands/account.js');
-        await AccountCommand();
-        process.exit(0);
+
+// dist/components/TeamForm.js
+import { jsx as _jsx4, jsxs as _jsxs3 } from "react/jsx-runtime";
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Box as Box2, Text as Text4, useInput as useInput2 } from "ink";
+function TeamForm({ title, onSubmit, onCancel }) {
+  const [state, setState] = useState2({
+    teamName: "",
+    teamSlug: "",
+    currentField: "name",
+    isCheckingSlug: false,
+    slugAvailable: null,
+    error: null
+  });
+  useEffect2(() => {
+    if (state.teamName.trim()) {
+      const newSlug = generateSlug(state.teamName);
+      setState((prev) => ({
+        ...prev,
+        teamSlug: newSlug,
+        slugAvailable: null,
+        error: null
+      }));
+    } else {
+      setState((prev) => ({
+        ...prev,
+        teamSlug: "",
+        slugAvailable: null,
+        error: null
+      }));
+    }
+  }, [state.teamName]);
+  useEffect2(() => {
+    if (state.teamSlug.trim() && (state.currentField === "name" || state.currentField === "slug")) {
+      const checkAvailability = async () => {
+        setState((prev) => ({ ...prev, isCheckingSlug: true, error: null }));
+        try {
+          const apiClient = ApiClient.getInstance();
+          const available = await apiClient.checkTeamSlugAvailability(state.teamSlug);
+          setState((prev) => ({
+            ...prev,
+            isCheckingSlug: false,
+            slugAvailable: available,
+            error: available ? null : "Team slug is already taken"
+          }));
+        } catch (error) {
+          setState((prev) => ({
+            ...prev,
+            isCheckingSlug: false,
+            slugAvailable: false,
+            error: "Error checking slug availability"
+          }));
+        }
+      };
+      const timeoutId = setTimeout(checkAvailability, 500);
+      return () => clearTimeout(timeoutId);
+    }
+  }, [state.teamSlug, state.currentField]);
+  useInput2((input, key) => {
+    if (state.currentField === "submitting") {
+      return;
+    }
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      if (state.currentField === "name") {
+        if (!state.teamName.trim()) {
+          setState((prev) => ({ ...prev, error: "Team name is required" }));
+          return;
+        }
+        setState((prev) => ({ ...prev, currentField: "slug", error: null }));
+        return;
+      }
+      if (state.currentField === "slug") {
+        if (!state.teamSlug.trim()) {
+          setState((prev) => ({ ...prev, error: "Team slug is required" }));
+          return;
+        }
+        if (!state.slugAvailable) {
+          setState((prev) => ({ ...prev, error: "Please wait for slug availability check or choose a different name" }));
+          return;
+        }
+        setState((prev) => ({ ...prev, currentField: "submitting", error: null }));
+        const result = onSubmit({ teamName: state.teamName, teamSlug: state.teamSlug });
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            setState((prev) => ({
+              ...prev,
+              currentField: "slug",
+              error: error.message || "Failed to create team"
+            }));
+          });
+        }
+        return;
+      }
+    }
+    if (key.backspace || key.delete) {
+      if (state.currentField === "name") {
+        setState((prev) => ({
+          ...prev,
+          teamName: prev.teamName.slice(0, -1),
+          error: null
+        }));
+      } else if (state.currentField === "slug") {
+        setState((prev) => ({
+          ...prev,
+          teamSlug: prev.teamSlug.slice(0, -1),
+          error: null
+        }));
+      }
+      return;
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+    if (input && input.length === 1) {
+      if (state.currentField === "name") {
+        setState((prev) => ({
+          ...prev,
+          teamName: prev.teamName + input,
+          error: null
+        }));
+      } else if (state.currentField === "slug") {
+        setState((prev) => ({
+          ...prev,
+          teamSlug: prev.teamSlug + input,
+          error: null
+        }));
+      }
     }
+  });
+  const getSlugStatus = () => {
+    if (!state.teamSlug.trim())
+      return null;
+    if (state.isCheckingSlug)
+      return "checking";
+    if (state.slugAvailable === true)
+      return "available";
+    if (state.slugAvailable === false)
+      return "unavailable";
+    return null;
+  };
+  const getSlugStatusText = () => {
+    const status = getSlugStatus();
+    switch (status) {
+      case "checking":
+        return "\u23F3 Checking availability...";
+      case "available":
+        return "\u2705 Slug available";
+      case "unavailable":
+        return "\u274C Slug not available";
+      default:
+        return "";
+    }
+  };
+  const getSlugStatusColor = () => {
+    const status = getSlugStatus();
+    switch (status) {
+      case "checking":
+        return "yellow";
+      case "available":
+        return "green";
+      case "unavailable":
+        return "red";
+      default:
+        return "gray";
+    }
+  };
+  const canSubmit = state.teamName.trim() && state.slugAvailable === true && !state.isCheckingSlug;
+  const getHelpText = () => {
+    if (state.currentField === "name") {
+      return state.teamName.trim() ? "Enter to edit slug \u2022 esc to cancel" : "Type team name \u2022 esc to cancel";
+    } else if (state.currentField === "slug") {
+      return canSubmit ? "Enter to create team \u2022 esc to cancel" : "Edit team slug \u2022 esc to cancel";
+    }
+    return "esc to cancel";
+  };
+  return _jsxs3(Box2, { flexDirection: "column", padding: 1, children: [_jsx4(Box2, { marginBottom: 2, children: _jsx4(Text4, { bold: true, color: "blue", children: title }) }), _jsxs3(Box2, { flexDirection: "column", marginBottom: 1, children: [_jsx4(Box2, { children: _jsxs3(Text4, { color: state.currentField === "name" ? "blue" : "gray", children: [state.currentField === "name" ? ">" : "\u2713", " Team Name:"] }) }), _jsx4(Box2, { marginLeft: 2, children: _jsxs3(Text4, { children: [state.teamName, state.currentField === "name" && _jsx4(Text4, { backgroundColor: "white", color: "black", children: "\u2588" })] }) })] }), state.teamSlug && _jsxs3(Box2, { flexDirection: "column", marginBottom: 1, children: [_jsx4(Box2, { children: _jsxs3(Text4, { color: state.currentField === "slug" ? "blue" : "gray", children: [state.currentField === "slug" ? ">" : "\u2713", " Team Slug", state.currentField === "name" ? " (auto-generated)" : "", ":"] }) }), _jsx4(Box2, { marginLeft: 2, children: _jsxs3(Text4, { children: [state.teamSlug, state.currentField === "slug" && _jsx4(Text4, { backgroundColor: "white", color: "black", children: "\u2588" })] }) }), getSlugStatus() && _jsx4(Box2, { marginLeft: 2, children: _jsx4(Text4, { color: getSlugStatusColor(), children: getSlugStatusText() }) })] }), state.error && _jsx4(Box2, { marginLeft: 2, marginBottom: 1, children: _jsxs3(Text4, { color: "red", children: ["Error: ", state.error] }) }), _jsx4(Box2, { marginTop: 2, children: _jsx4(Text4, { color: "gray", children: getHelpText() }) })] });
+}
+var init_TeamForm = __esm({
+  "dist/components/TeamForm.js"() {
+    "use strict";
+    init_api();
+    init_platform();
+  }
+});
+
+// dist/commands/teams.js
+var teams_exports = {};
+__export(teams_exports, {
+  TeamsCommand: () => TeamsCommand
 });
-// Version command (override default to show update info)
-program
-    .command('version')
-    .description('Show CLI version')
-    .action(async () => {
+import { jsx as _jsx5, jsxs as _jsxs4 } from "react/jsx-runtime";
+import React3 from "react";
+import { render as render2, Box as Box3, Text as Text5 } from "ink";
+function TeamsApp() {
+  const [state, setState] = React3.useState({
+    loading: true,
+    teams: [],
+    error: null
+  });
+  React3.useEffect(() => {
+    async function loadTeams() {
+      try {
+        if (!await isOnline()) {
+          setState((prev) => ({ ...prev, loading: false, error: MESSAGES.OFFLINE }));
+          return;
+        }
+        const authService = AuthService.getInstance();
+        const token = await authService.getToken();
+        if (!token) {
+          setState((prev) => ({ ...prev, loading: false, error: MESSAGES.LOGGED_OUT }));
+          return;
+        }
+        const apiClient = ApiClient.getInstance();
+        const teams = await apiClient.getTeams();
+        setState({
+          loading: false,
+          teams,
+          error: null
+        });
+      } catch (error) {
+        setState({
+          loading: false,
+          teams: [],
+          error: error instanceof Error ? error.message : "Failed to load teams"
+        });
+      }
+    }
+    loadTeams();
+  }, []);
+  const handleCopy = async (row) => {
     try {
-        const { VersionCommand } = await import('./commands/version.js');
-        await VersionCommand();
-        process.exit(0);
+      await copyToClipboard(row.id);
+    } catch (error) {
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+  };
+  const handleOpen = async (row) => {
+    try {
+      await openBrowser(`https://app.basic.tech/team/${row.slug}`);
+    } catch (error) {
     }
-});
-// Update command
-program
-    .command('update')
-    .description('Update CLI to the latest version')
-    .action(async () => {
+  };
+  const handleExit = () => {
+    process.exit(0);
+  };
+  const handleNew = () => {
+    render2(_jsx5(NewTeamApp, {}));
+  };
+  if (state.loading) {
+    return _jsx5(Spinner, { text: "Loading teams..." });
+  }
+  if (state.error) {
+    return _jsx5(Text5, { color: "red", children: state.error });
+  }
+  const columns = [
+    { title: "ID", width: 38, key: "id" },
+    { title: "Name", width: 25, key: "name" },
+    { title: "Role", width: 20, key: "role_name" }
+  ];
+  const rows = state.teams.map((team) => ({
+    id: team.id,
+    name: team.name,
+    role_name: team.role_name || "Member",
+    slug: team.slug
+  }));
+  return _jsx5(Table, { columns, rows, onCopy: handleCopy, onOpen: handleOpen, onExit: handleExit, onNew: handleNew, helpText: {
+    copyAction: "'c' to copy team ID",
+    openAction: "'o' to open in browser",
+    newAction: "'n' to create a new team"
+  } });
+}
+function NewTeamApp() {
+  const [state, setState] = React3.useState({
+    loading: false,
+    error: null,
+    success: false,
+    teamName: "",
+    teamSlug: ""
+  });
+  const handleSubmit = async (data) => {
+    setState((prev) => ({ ...prev, loading: true, error: null }));
     try {
-        const { UpdateCommand } = await import('./commands/update.js');
-        await UpdateCommand();
+      if (!await isOnline()) {
+        setState((prev) => ({ ...prev, loading: false, error: MESSAGES.OFFLINE }));
+        return;
+      }
+      const authService = AuthService.getInstance();
+      const token = await authService.getToken();
+      if (!token) {
+        setState((prev) => ({ ...prev, loading: false, error: MESSAGES.LOGGED_OUT }));
+        return;
+      }
+      const apiClient = ApiClient.getInstance();
+      await apiClient.createTeam(data.teamName, data.teamSlug);
+      setState({
+        loading: false,
+        error: null,
+        success: true,
+        teamName: data.teamName,
+        teamSlug: data.teamSlug
+      });
+      setTimeout(() => {
         process.exit(0);
+      }, 2e3);
+    } catch (error) {
+      setState((prev) => ({
+        ...prev,
+        loading: false,
+        error: error instanceof Error ? error.message : "Failed to create team"
+      }));
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
-    }
+  };
+  if (state.loading) {
+    return _jsx5(Spinner, { text: "Creating team..." });
+  }
+  if (state.success) {
+    return _jsxs4(Box3, { flexDirection: "column", children: [_jsxs4(Text5, { color: "green", children: ['\u2705 Team "', state.teamName, '" created successfully!'] }), _jsxs4(Text5, { children: ["Team slug: ", state.teamSlug] })] });
+  }
+  if (state.error) {
+    return _jsx5(Text5, { color: "red", children: state.error });
+  }
+  return _jsx5(TeamForm, { title: "Create New Team", onSubmit: handleSubmit, onCancel: () => process.exit(0) });
+}
+async function TeamsCommand(action) {
+  if (action === "new") {
+    render2(_jsx5(NewTeamApp, {}));
+  } else {
+    render2(_jsx5(TeamsApp, {}));
+  }
+}
+var init_teams = __esm({
+  "dist/commands/teams.js"() {
+    "use strict";
+    init_Table();
+    init_Spinner();
+    init_TeamForm();
+    init_api();
+    init_auth();
+    init_platform();
+    init_constants();
+  }
 });
-// Help command
-program
-    .command('help')
-    .description('Show help information')
-    .action(() => {
-    program.help();
+
+// dist/lib/schema.js
+var schema_exports = {};
+__export(schema_exports, {
+  compareVersions: () => compareVersions,
+  parseSchemaFile: () => parseSchemaFile,
+  readSchemaFromConfig: () => readSchemaFromConfig,
+  saveSchemaToConfig: () => saveSchemaToConfig
 });
-// Debug command
-program
-    .command('debug')
-    .description('Show Basic config directory location')
-    .action(async () => {
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { parse } from "@babel/parser";
+async function readSchemaFromConfig(targetDir = process.cwd()) {
+  const possibleFiles = [
+    "basic.config.ts",
+    "basic.config.js",
+    "basic.config.json"
+  ];
+  for (const filename of possibleFiles) {
+    const filePath = path2.join(targetDir, filename);
     try {
-        const { DebugCommand } = await import('./commands/debug.js');
-        await DebugCommand();
-        process.exit(0);
+      await fs2.access(filePath);
+      const content = await fs2.readFile(filePath, "utf8");
+      let schema;
+      if (filename.endsWith(".json")) {
+        schema = JSON.parse(content);
+      } else {
+        schema = extractSchemaFromCode(content);
+      }
+      if (!schema.project_id) {
+        throw new Error("No project_id found in schema");
+      }
+      return {
+        schema,
+        projectId: schema.project_id,
+        filePath
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        continue;
+      }
+      throw new Error(`Error reading ${filename}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  return null;
+}
+function extractSchemaFromCode(content) {
+  try {
+    const ast = parse(content, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"]
+    });
+    const schemaExport = ast.program.body.find((node) => {
+      if (node.type === "ExportNamedDeclaration") {
+        const declaration = node.declaration;
+        if (declaration?.type === "VariableDeclaration") {
+          const variable = declaration.declarations[0];
+          return variable.id.type === "Identifier" && variable.id.name === "schema";
+        }
+      }
+      return false;
+    });
+    if (!schemaExport) {
+      throw new Error("Could not find schema export in config file");
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+    const schemaNode = schemaExport.declaration.declarations[0].init;
+    if (!schemaNode || schemaNode.type !== "ObjectExpression") {
+      throw new Error("Schema export must be an object");
     }
+    const schema = convertAstToObject(schemaNode);
+    if (!schema.project_id || typeof schema.project_id !== "string") {
+      throw new Error("Schema must have a project_id string field");
+    }
+    if (typeof schema.version !== "number") {
+      throw new Error("Schema must have a version number field");
+    }
+    if (!schema.tables || typeof schema.tables !== "object") {
+      throw new Error("Schema must have a tables object field");
+    }
+    return schema;
+  } catch (error) {
+    throw new Error(`Error parsing schema: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+function convertAstToObject(node) {
+  if (node.type === "ObjectExpression") {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (prop.type === "ObjectProperty") {
+        const key = getPropertyKey(prop);
+        obj[key] = convertAstToObject(prop.value);
+      }
+    }
+    return obj;
+  }
+  if (node.type === "ArrayExpression") {
+    return node.elements.map((element) => element ? convertAstToObject(element) : null);
+  }
+  if (node.type === "StringLiteral") {
+    return node.value;
+  }
+  if (node.type === "NumericLiteral") {
+    return node.value;
+  }
+  if (node.type === "BooleanLiteral") {
+    return node.value;
+  }
+  if (node.type === "NullLiteral") {
+    return null;
+  }
+  if (node.type === "Identifier") {
+    if (node.name === "true")
+      return true;
+    if (node.name === "false")
+      return false;
+    if (node.name === "null")
+      return null;
+    throw new Error(`Unexpected identifier: ${node.name}`);
+  }
+  throw new Error(`Unsupported node type: ${node.type}`);
+}
+function getPropertyKey(prop) {
+  if (prop.key.type === "Identifier") {
+    return prop.key.name;
+  }
+  if (prop.key.type === "StringLiteral") {
+    return prop.key.value;
+  }
+  throw new Error(`Unsupported property key type: ${prop.key.type}`);
+}
+async function saveSchemaToConfig(schema, targetDir = process.cwd()) {
+  const existing = await readSchemaFromConfig(targetDir);
+  if (existing) {
+    const content = await fs2.readFile(existing.filePath, "utf8");
+    const updatedContent = updateSchemaInCode(content, schema);
+    await fs2.writeFile(existing.filePath, updatedContent, "utf8");
+    return existing.filePath;
+  } else {
+    const filePath = path2.join(targetDir, "basic.config.ts");
+    const content = generateConfigContent(schema);
+    await fs2.writeFile(filePath, content, "utf8");
+    return filePath;
+  }
+}
+function updateSchemaInCode(content, newSchema) {
+  const schemaStr = JSON.stringify(newSchema, null, 2);
+  const patterns = [
+    /(const\s+schema\s*=\s*)({[^;]+})(;)/g,
+    /(export\s+const\s+schema\s*=\s*)({[^;]+})(;)/g,
+    /(schema\s*=\s*)({[^;]+})(;)/g
+  ];
+  for (const pattern of patterns) {
+    if (pattern.test(content)) {
+      return content.replace(pattern, `$1${schemaStr}$3`);
+    }
+  }
+  throw new Error("Could not update schema in config file");
+}
+function generateConfigContent(schema) {
+  return `// Basic Project Configuration
+// see the docs for more info: https://docs.basic.tech
+
+const schema = ${JSON.stringify(schema, null, 2)};
+
+export default schema;
+`;
+}
+function compareVersions(local, remote) {
+  const localVersion = local.version || 0;
+  const remoteVersion = remote.version || 0;
+  let status;
+  if (localVersion === remoteVersion) {
+    status = "equal";
+  } else if (localVersion > remoteVersion) {
+    status = "ahead";
+  } else {
+    status = "behind";
+  }
+  return {
+    status,
+    localVersion,
+    remoteVersion
+  };
+}
+async function parseSchemaFile(filePath) {
+  const content = await fs2.readFile(filePath, "utf8");
+  const ast = parse(content, {
+    sourceType: "module",
+    plugins: ["typescript"]
+  });
+}
+var init_schema = __esm({
+  "dist/lib/schema.js"() {
+    "use strict";
+  }
 });
-// Projects command
-program
-    .command('projects')
-    .description('List and browse your projects')
-    .action(async () => {
-    try {
-        const { ProjectsCommand } = await import('./commands/projects.js');
-        await ProjectsCommand();
+
+// dist/commands/status.js
+var status_exports = {};
+__export(status_exports, {
+  StatusCommand: () => StatusCommand
+});
+import { jsx as _jsx6, jsxs as _jsxs5 } from "react/jsx-runtime";
+import React4 from "react";
+import { render as render3, Box as Box4, Text as Text6 } from "ink";
+function StatusApp() {
+  const [state, setState] = React4.useState({
+    loading: true,
+    error: null
+  });
+  React4.useEffect(() => {
+    async function checkStatus() {
+      try {
+        if (!await isOnline()) {
+          setState({
+            loading: false,
+            error: MESSAGES.OFFLINE
+          });
+          return;
+        }
+        const authService = AuthService.getInstance();
+        const token = await authService.getToken();
+        if (!token) {
+          setState({
+            loading: false,
+            error: MESSAGES.LOGGED_OUT
+          });
+          return;
+        }
+        const localConfig = await readSchemaFromConfig();
+        if (!localConfig) {
+          setState({
+            loading: false,
+            error: null,
+            result: {
+              status: "no-schema",
+              projectId: "",
+              localVersion: 0,
+              remoteVersion: 0,
+              message: ["No schema found in config files"],
+              suggestions: [
+                "Run 'basic init' to create a new project or import an existing project",
+                "Make sure you're in a directory with a basic.config.ts/js file",
+                "Check if your config file has the correct name and format"
+              ]
+            }
+          });
+          return;
+        }
+        const apiClient = ApiClient.getInstance();
+        let remoteSchema = null;
+        try {
+          remoteSchema = await apiClient.getProjectSchema(localConfig.projectId);
+        } catch (error) {
+          setState({
+            loading: false,
+            error: null,
+            result: {
+              status: "invalid",
+              projectId: localConfig.projectId,
+              localVersion: localConfig.schema.version || 0,
+              remoteVersion: 0,
+              message: [
+                `Project ID: ${localConfig.projectId}`,
+                `Error fetching remote schema: ${error instanceof Error ? error.message : "Unknown error"}`
+              ],
+              suggestions: [
+                "Check if the project ID is correct",
+                "Ensure you have access to this project",
+                "Verify your internet connection",
+                "Try running 'basic login' if authentication has expired"
+              ]
+            }
+          });
+          return;
+        }
+        if (!remoteSchema) {
+          remoteSchema = {
+            project_id: localConfig.projectId,
+            version: 0,
+            tables: {}
+          };
+        }
+        const comparison = compareVersions(localConfig.schema, remoteSchema);
+        const result = await analyzeStatus(localConfig, remoteSchema, comparison);
+        setState({
+          loading: false,
+          error: null,
+          result
+        });
+      } catch (error) {
+        setState({
+          loading: false,
+          error: error instanceof Error ? error.message : "Failed to check status"
+        });
+      }
+    }
+    checkStatus();
+  }, []);
+  if (state.loading) {
+    return _jsx6(Spinner, { text: "Checking status..." });
+  }
+  if (state.error) {
+    return _jsx6(Box4, { flexDirection: "column", children: _jsxs5(Text6, { color: "red", children: ["Error: ", state.error] }) });
+  }
+  if (state.result) {
+    return _jsx6(StatusDisplay, { result: state.result });
+  }
+  return _jsx6(Text6, { children: "Unknown status" });
+}
+async function analyzeStatus(localConfig, remoteSchema, comparison) {
+  const apiClient = ApiClient.getInstance();
+  const { schema: localSchema, projectId } = localConfig;
+  const baseResult = {
+    projectId,
+    localVersion: comparison.localVersion,
+    remoteVersion: comparison.remoteVersion,
+    message: [`Project ID: ${projectId}`],
+    suggestions: []
+  };
+  if (comparison.remoteVersion > 0) {
+    baseResult.message.push(`Remote schema version: ${comparison.remoteVersion}`);
+  }
+  switch (comparison.status) {
+    case "behind":
+      return {
+        ...baseResult,
+        status: "behind",
+        message: [
+          ...baseResult.message,
+          `Schema is out of date! Current: ${comparison.localVersion}, Latest: ${comparison.remoteVersion}`
+        ],
+        suggestions: [
+          "Run 'basic pull' to update your local schema",
+          "Review the changes before pulling if you have local modifications",
+          "Consider backing up your current schema if you have unsaved work"
+        ]
+      };
+    case "ahead":
+      try {
+        const validation = await apiClient.validateSchema(localSchema);
+        if (validation.valid === false && validation.errors) {
+          return {
+            ...baseResult,
+            status: "invalid",
+            message: [
+              ...baseResult.message,
+              `Changes found: Local schema version ${comparison.localVersion} is ahead of remote version ${comparison.remoteVersion}`,
+              "Errors found in schema! Please fix:"
+            ],
+            validationErrors: validation.errors,
+            suggestions: [
+              "Fix the validation errors shown below",
+              "Run 'basic status' again after fixing errors",
+              "Review your schema syntax and field definitions"
+            ]
+          };
+        }
+        return {
+          ...baseResult,
+          status: "ahead",
+          message: [
+            ...baseResult.message,
+            `Changes found: Local schema version ${comparison.localVersion} is ahead of remote version ${comparison.remoteVersion}`,
+            "Schema changes are valid!"
+          ],
+          suggestions: [
+            "Run 'basic push' to publish your changes",
+            "Review your changes before publishing",
+            "Test your schema locally if possible"
+          ]
+        };
+      } catch (error) {
+        return {
+          ...baseResult,
+          status: "invalid",
+          message: [
+            ...baseResult.message,
+            `Error validating schema: ${error instanceof Error ? error.message : "Unknown error"}`
+          ],
+          suggestions: [
+            "Check your schema for syntax errors",
+            "Ensure all required fields are present",
+            "Verify your basic.config file is valid JSON/JavaScript"
+          ]
+        };
+      }
+    case "equal":
+      if (comparison.localVersion === 0 && comparison.remoteVersion === 0) {
+        try {
+          const validation = await apiClient.validateSchema(localSchema);
+          if (validation.valid === false && validation.errors) {
+            return {
+              ...baseResult,
+              status: "invalid",
+              message: [
+                ...baseResult.message,
+                "Errors found in schema! Please fix:"
+              ],
+              validationErrors: validation.errors,
+              suggestions: [
+                "Fix the validation errors shown below",
+                "Run 'basic status' again after fixing errors"
+              ]
+            };
+          }
+          return {
+            ...baseResult,
+            status: "ahead",
+            message: [
+              ...baseResult.message,
+              "",
+              "Schema changes are valid!",
+              "Please increment your version number to 1",
+              "and run 'basic push' if you are ready to publish your changes."
+            ],
+            suggestions: [
+              "Update the version field in your schema from 0 to 1",
+              "Run 'basic push' after incrementing the version",
+              "Ensure your schema changes are tested and ready for production"
+            ]
+          };
+        } catch (error) {
+          return {
+            ...baseResult,
+            status: "invalid",
+            message: [
+              ...baseResult.message,
+              `Error validating schema: ${error instanceof Error ? error.message : "Unknown error"}`
+            ],
+            suggestions: [
+              "Check your schema for syntax errors"
+            ]
+          };
+        }
+      } else {
+        try {
+          const comparison2 = await apiClient.compareSchema(localSchema);
+          if (comparison2.valid) {
+            return {
+              ...baseResult,
+              status: "current",
+              message: [
+                ...baseResult.message,
+                "Schema is up to date!"
+              ],
+              suggestions: [
+                "Continue working on your project",
+                "Make schema modifications if needed",
+                "Run 'basic status' again after making changes"
+              ]
+            };
+          } else {
+            return {
+              ...baseResult,
+              status: "conflict",
+              message: [
+                ...baseResult.message,
+                "",
+                "Schema conflicts found! Your local schema is different from the remote schema."
+              ],
+              suggestions: [
+                "Run 'basic pull' to override local changes with remote schema",
+                "Or increment the version number in your local schema",
+                "Compare your local changes with the remote version before deciding",
+                "Consider creating a backup of your local changes"
+              ]
+            };
+          }
+        } catch (error) {
+          return {
+            ...baseResult,
+            status: "invalid",
+            message: [
+              ...baseResult.message,
+              `Error checking schema conflict: ${error instanceof Error ? error.message : "Unknown error"}`
+            ],
+            suggestions: [
+              "Check your network connection",
+              "Ensure the project ID is correct"
+            ]
+          };
+        }
+      }
+    default:
+      return {
+        ...baseResult,
+        status: "invalid",
+        message: [
+          ...baseResult.message,
+          "Unknown schema status"
+        ],
+        suggestions: [
+          "Try running 'basic status' again"
+        ]
+      };
+  }
+}
+function StatusDisplay({ result }) {
+  const getStatusColor = () => {
+    switch (result.status) {
+      case "current":
+        return "green";
+      case "ahead":
+        return "blue";
+      case "behind":
+        return "yellow";
+      case "conflict":
+        return "magenta";
+      case "invalid":
+        return "red";
+      case "no-schema":
+        return "gray";
+      default:
+        return "white";
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+  };
+  const getStatusIcon = () => {
+    switch (result.status) {
+      case "current":
+        return "\u2705";
+      case "ahead":
+        return "\u{1F680}";
+      case "behind":
+        return "\u2B07\uFE0F";
+      case "conflict":
+        return "\u26A0\uFE0F";
+      case "invalid":
+        return "\u274C";
+      case "no-schema":
+        return "\u{1F4C4}";
+      default:
+        return "\u2753";
     }
+  };
+  const getStatusDescription = () => {
+    switch (result.status) {
+      case "current":
+        return "Schema is up to date";
+      case "ahead":
+        return "Schema is ready to push";
+      case "behind":
+        return "Schema is out of date";
+      case "conflict":
+        return "Schema conflicts detected";
+      case "invalid":
+        return "Schema has validation errors";
+      case "no-schema":
+        return "No schema file found";
+      default:
+        return "Unknown status";
+    }
+  };
+  const statusMessages = result.message.filter((msg) => !msg.startsWith("Project ID:") && !msg.startsWith("Remote schema version:"));
+  return _jsxs5(Box4, { flexDirection: "column", children: [result.projectId && _jsxs5(Box4, { flexDirection: "column", marginBottom: 1, children: [_jsxs5(Text6, { color: "cyan", children: ["Project ID: ", result.projectId] }), _jsxs5(Box4, { children: [_jsxs5(Text6, { color: "gray", children: ["Local version: ", result.localVersion] }), result.remoteVersion > 0 && _jsxs5(Text6, { color: "gray", children: [" \u2022 Remote version: ", result.remoteVersion] })] })] }), _jsxs5(Box4, { flexDirection: "column", marginBottom: 1, children: [_jsx6(Box4, { marginBottom: 1, children: _jsxs5(Text6, { color: getStatusColor(), children: [getStatusIcon(), " ", getStatusDescription()] }) }), statusMessages.length > 0 && _jsx6(Box4, { flexDirection: "column", children: statusMessages.map((line, index) => _jsx6(Text6, { children: line }, index)) })] }), result.validationErrors && result.validationErrors.length > 0 && _jsxs5(Box4, { flexDirection: "column", marginBottom: 1, children: [_jsx6(Text6, { color: "red", children: "Validation errors:" }), result.validationErrors.map((error, index) => _jsxs5(Text6, { color: "red", children: ["\u2022 ", error.message, " at ", error.instancePath || "root"] }, index))] }), result.suggestions.length > 0 && _jsxs5(Box4, { flexDirection: "column", marginTop: 1, children: [_jsx6(Text6, { color: "blue", children: "Next steps:" }), result.suggestions.map((suggestion, index) => _jsxs5(Text6, { color: "gray", children: ["\u2022 ", suggestion] }, index))] })] });
+}
+async function StatusCommand() {
+  const { waitUntilExit } = render3(_jsx6(StatusApp, {}));
+  await waitUntilExit();
+  process.exit(0);
+}
+var init_status = __esm({
+  "dist/commands/status.js"() {
+    "use strict";
+    init_Spinner();
+    init_api();
+    init_auth();
+    init_schema();
+    init_platform();
+    init_constants();
+  }
+});
+
+// dist/commands/pull.js
+var pull_exports = {};
+__export(pull_exports, {
+  PullCommand: () => PullCommand
 });
-// Teams command
-program
-    .command('teams')
-    .argument('[action]', 'Teams action (new)', 'list')
-    .description('List teams or create a new team')
-    .action(async (action) => {
+import { jsx as _jsx7, jsxs as _jsxs6, Fragment as _Fragment } from "react/jsx-runtime";
+import React5 from "react";
+import { render as render4, Box as Box5, Text as Text7, useInput as useInput3 } from "ink";
+function PullApp() {
+  const [state, setState] = React5.useState({
+    phase: "checking",
+    error: null
+  });
+  const [selectedOption, setSelectedOption] = React5.useState("yes");
+  React5.useEffect(() => {
+    async function checkPullStatus() {
+      try {
+        if (!await isOnline()) {
+          setState({
+            phase: "error",
+            error: MESSAGES.OFFLINE
+          });
+          return;
+        }
+        const authService = AuthService.getInstance();
+        const token = await authService.getToken();
+        if (!token) {
+          setState({
+            phase: "error",
+            error: MESSAGES.LOGGED_OUT
+          });
+          return;
+        }
+        const localConfig = await readSchemaFromConfig();
+        if (!localConfig) {
+          setState({
+            phase: "no-action",
+            error: null,
+            statusResult: {
+              status: "no-schema",
+              projectId: "",
+              localVersion: 0,
+              remoteVersion: 0,
+              message: [
+                "No schema found in config files",
+                "Run 'basic init' to create a new project or import an existing project"
+              ],
+              needsConfirmation: false,
+              confirmationTitle: "",
+              confirmationMessage: ""
+            }
+          });
+          return;
+        }
+        const apiClient = ApiClient.getInstance();
+        let remoteSchema = null;
+        try {
+          remoteSchema = await apiClient.getProjectSchema(localConfig.projectId);
+        } catch (error) {
+          setState({
+            phase: "error",
+            error: `Error fetching remote schema: ${error instanceof Error ? error.message : "Unknown error"}`
+          });
+          return;
+        }
+        if (!remoteSchema) {
+          remoteSchema = {
+            project_id: localConfig.projectId,
+            version: 0,
+            tables: {}
+          };
+        }
+        const comparison = compareVersions(localConfig.schema, remoteSchema);
+        const result = await analyzePullAction(localConfig, remoteSchema, comparison, apiClient);
+        setState({
+          phase: result.needsConfirmation ? "confirming" : "no-action",
+          error: null,
+          statusResult: result
+        });
+      } catch (error) {
+        setState({
+          phase: "error",
+          error: error instanceof Error ? error.message : "Failed to check pull status"
+        });
+      }
+    }
+    checkPullStatus();
+  }, []);
+  useInput3((input, key) => {
+    if (state.phase === "confirming") {
+      if (key.upArrow || key.downArrow) {
+        setSelectedOption((prev) => prev === "yes" ? "no" : "yes");
+      } else if (key.return) {
+        if (selectedOption === "yes") {
+          handlePull();
+        } else {
+          setState((prev) => ({ ...prev, phase: "no-action" }));
+        }
+      } else if (key.escape || input === "q") {
+        setState((prev) => ({ ...prev, phase: "no-action" }));
+      }
+    }
+  });
+  const handlePull = async () => {
+    setState((prev) => ({ ...prev, phase: "pulling" }));
     try {
-        const { TeamsCommand } = await import('./commands/teams.js');
-        await TeamsCommand(action);
+      if (!state.statusResult) {
+        throw new Error("No status result available");
+      }
+      const localConfig = await readSchemaFromConfig();
+      if (!localConfig) {
+        throw new Error("Local schema not found");
+      }
+      const apiClient = ApiClient.getInstance();
+      const remoteSchema = await apiClient.getProjectSchema(localConfig.projectId);
+      if (!remoteSchema) {
+        throw new Error("Remote schema not found");
+      }
+      const filePath = await saveSchemaToConfig(remoteSchema);
+      setState({
+        phase: "success",
+        error: null,
+        pullResult: {
+          projectId: localConfig.projectId,
+          oldVersion: localConfig.schema.version || 0,
+          newVersion: remoteSchema.version || 0,
+          filePath
+        }
+      });
+    } catch (error) {
+      setState({
+        phase: "error",
+        error: error instanceof Error ? error.message : "Failed to pull schema"
+      });
+    }
+  };
+  if (state.phase === "checking") {
+    return _jsx7(Spinner, { text: "Checking pull status..." });
+  }
+  if (state.phase === "pulling") {
+    return _jsx7(Spinner, { text: "Pulling latest schema..." });
+  }
+  if (state.phase === "error") {
+    setTimeout(() => process.exit(1), 0);
+    return _jsxs6(Box5, { flexDirection: "column", children: [_jsxs6(Text7, { color: "red", children: ["Error: ", state.error] }), _jsxs6(Box5, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [_jsx7(Text7, { color: "blue", children: "Next steps:" }), state.error?.includes("offline") || state.error?.includes("network") ? _jsxs6(_Fragment, { children: [_jsx7(Text7, { color: "gray", children: "\u2022 Check your internet connection" }), _jsx7(Text7, { color: "gray", children: "\u2022 Try again in a moment" })] }) : state.error?.includes("logged") || state.error?.includes("auth") ? _jsxs6(_Fragment, { children: [_jsx7(Text7, { color: "gray", children: "\u2022 Run 'basic login' to authenticate" }), _jsx7(Text7, { color: "gray", children: "\u2022 Ensure you have a valid account" })] }) : state.error?.includes("schema") || state.error?.includes("project") ? _jsxs6(_Fragment, { children: [_jsx7(Text7, { color: "gray", children: "\u2022 Check if the project ID is correct" }), _jsx7(Text7, { color: "gray", children: "\u2022 Ensure you have access to this project" }), _jsx7(Text7, { color: "gray", children: "\u2022 Run 'basic status' for more details" })] }) : _jsxs6(_Fragment, { children: [_jsx7(Text7, { color: "gray", children: "\u2022 Try running the command again" }), _jsx7(Text7, { color: "gray", children: "\u2022 Run 'basic status' to check your project state" }), _jsx7(Text7, { color: "gray", children: "\u2022 Check the Basic documentation if the issue persists" })] })] })] });
+  }
+  if (state.phase === "success" && state.pullResult) {
+    setTimeout(() => process.exit(0), 0);
+    return _jsx7(PullSuccessDisplay, { result: state.pullResult });
+  }
+  if (state.phase === "confirming" && state.statusResult) {
+    return _jsx7(PullConfirmationDialog, { statusResult: state.statusResult, selectedOption });
+  }
+  if (state.phase === "no-action" && state.statusResult) {
+    setTimeout(() => process.exit(0), 0);
+    return _jsx7(PullStatusDisplay, { result: state.statusResult });
+  }
+  return _jsx7(Text7, { children: "Unknown state" });
+}
+async function analyzePullAction(localConfig, remoteSchema, comparison, apiClient) {
+  const { projectId } = localConfig;
+  const baseResult = {
+    projectId,
+    localVersion: comparison.localVersion,
+    remoteVersion: comparison.remoteVersion,
+    message: [],
+    needsConfirmation: false,
+    confirmationTitle: "",
+    confirmationMessage: ""
+  };
+  switch (comparison.status) {
+    case "behind":
+      return {
+        ...baseResult,
+        status: "behind",
+        message: [
+          "Your local schema is behind the remote version.",
+          "Pull the latest changes?"
+        ],
+        needsConfirmation: true,
+        confirmationTitle: "Pull Remote Schema",
+        confirmationMessage: "This will update your local schema to the latest version."
+      };
+    case "equal":
+      if (comparison.localVersion === 0 && comparison.remoteVersion === 0) {
+        return {
+          ...baseResult,
+          status: "current",
+          message: [
+            "Schema is up to date!",
+            "No pull needed."
+          ]
+        };
+      }
+      try {
+        const comparisonResult = await apiClient.compareSchema(localConfig.schema);
+        if (comparisonResult.valid) {
+          return {
+            ...baseResult,
+            status: "current",
+            message: [
+              "Schema is up to date!",
+              "No pull needed."
+            ]
+          };
+        } else {
+          return {
+            ...baseResult,
+            status: "conflict",
+            message: [
+              "Schema conflicts detected!",
+              "Your local schema differs from the remote schema at the same version.",
+              "Pull the remote version to override local changes?"
+            ],
+            needsConfirmation: true,
+            confirmationTitle: "Override Local Changes",
+            confirmationMessage: "This will replace your local schema with the remote version."
+          };
+        }
+      } catch (error) {
+        return {
+          ...baseResult,
+          status: "current",
+          message: [
+            "Schema is up to date!",
+            "No pull needed.",
+            "(Unable to verify schema content - assuming current)"
+          ]
+        };
+      }
+    case "ahead":
+      return {
+        ...baseResult,
+        status: "ahead",
+        message: [
+          "Your local schema is ahead of the remote version.",
+          "Did you mean to push instead?",
+          "Use 'basic push' to publish your changes."
+        ]
+      };
+    default:
+      return {
+        ...baseResult,
+        status: "current",
+        message: [
+          "Schema is up to date!",
+          "No pull needed."
+        ]
+      };
+  }
+}
+function PullConfirmationDialog({ statusResult, selectedOption }) {
+  const getStatusIcon = () => {
+    switch (statusResult.status) {
+      case "behind":
+        return "\u2B07\uFE0F";
+      case "conflict":
+        return "\u26A0\uFE0F";
+      default:
+        return "\u{1F4E5}";
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+  };
+  const getStatusText = () => {
+    switch (statusResult.status) {
+      case "behind":
+        return "Schema is out of date";
+      case "conflict":
+        return "Schema conflicts detected";
+      default:
+        return "Schema update available";
+    }
+  };
+  const getStatusColor = () => {
+    switch (statusResult.status) {
+      case "behind":
+        return "yellow";
+      case "conflict":
+        return "magenta";
+      default:
+        return "blue";
+    }
+  };
+  return _jsxs6(Box5, { flexDirection: "column", children: [_jsxs6(Box5, { flexDirection: "column", marginBottom: 1, children: [_jsxs6(Text7, { color: "cyan", children: ["Project ID: ", statusResult.projectId] }), _jsxs6(Box5, { children: [_jsxs6(Text7, { color: "gray", children: ["Local version: ", statusResult.localVersion] }), statusResult.remoteVersion > 0 && _jsxs6(Text7, { color: "gray", children: [" \u2022 Remote version: ", statusResult.remoteVersion] })] })] }), _jsx7(Box5, { marginBottom: 1, children: _jsxs6(Text7, { color: getStatusColor(), children: [getStatusIcon(), " ", getStatusText()] }) }), _jsx7(Box5, { flexDirection: "column", marginBottom: 2, children: statusResult.message.map((line, index) => _jsx7(Text7, { children: line }, index)) }), _jsxs6(Box5, { flexDirection: "column", children: [_jsx7(Box5, { children: _jsxs6(Text7, { color: selectedOption === "yes" ? "green" : "gray", children: [selectedOption === "yes" ? "\u276F" : " ", " Yes, pull changes"] }) }), _jsx7(Box5, { children: _jsxs6(Text7, { color: selectedOption === "no" ? "green" : "gray", children: [selectedOption === "no" ? "\u276F" : " ", " No, cancel"] }) })] }), _jsx7(Box5, { marginTop: 1, children: _jsx7(Text7, { color: "gray", children: "Use \u2191\u2193 to navigate, Enter to confirm, Esc to cancel" }) })] });
+}
+function PullStatusDisplay({ result }) {
+  const getStatusColor = () => {
+    switch (result.status) {
+      case "current":
+        return "green";
+      case "ahead":
+        return "blue";
+      case "conflict":
+        return "magenta";
+      case "no-schema":
+        return "gray";
+      default:
+        return "white";
     }
+  };
+  const getStatusIcon = () => {
+    switch (result.status) {
+      case "current":
+        return "\u2705";
+      case "ahead":
+        return "\u{1F680}";
+      case "conflict":
+        return "\u26A0\uFE0F";
+      case "no-schema":
+        return "\u{1F4C4}";
+      default:
+        return "\u2753";
+    }
+  };
+  const getStatusDescription = () => {
+    switch (result.status) {
+      case "current":
+        return "Schema is up to date";
+      case "ahead":
+        return "Local schema is ahead";
+      case "conflict":
+        return "Schema conflicts detected";
+      case "no-schema":
+        return "No schema file found";
+      default:
+        return "Unknown status";
+    }
+  };
+  const getNextSteps = () => {
+    switch (result.status) {
+      case "current":
+        return [
+          "Continue working on your project",
+          "Run 'basic status' to check for changes",
+          "Make schema modifications if needed"
+        ];
+      case "ahead":
+        return [
+          "Run 'basic push' to publish your changes",
+          "Or run 'basic status' for more details"
+        ];
+      case "conflict":
+        return [
+          "Run 'basic pull' again to override local changes",
+          "Or run 'basic status' to understand the differences",
+          "Consider backing up your local changes first"
+        ];
+      case "no-schema":
+        return [
+          "Run 'basic init' to create a new project or import an existing project",
+          "Make sure you're in a directory with a basic.config.ts/js file"
+        ];
+      default:
+        return [];
+    }
+  };
+  return _jsxs6(Box5, { flexDirection: "column", children: [result.projectId && _jsxs6(Box5, { flexDirection: "column", marginBottom: 1, children: [_jsxs6(Text7, { color: "cyan", children: ["Project ID: ", result.projectId] }), _jsxs6(Box5, { children: [_jsxs6(Text7, { color: "gray", children: ["Local version: ", result.localVersion] }), result.remoteVersion > 0 && _jsxs6(Text7, { color: "gray", children: [" \u2022 Remote version: ", result.remoteVersion] })] })] }), _jsx7(Box5, { marginBottom: 1, children: _jsxs6(Text7, { color: getStatusColor(), children: [getStatusIcon(), " ", getStatusDescription()] }) }), _jsx7(Box5, { flexDirection: "column", marginBottom: 1, children: result.message.map((line, index) => _jsx7(Text7, { children: line }, index)) }), getNextSteps().length > 0 && _jsxs6(Box5, { flexDirection: "column", marginBottom: 1, children: [_jsx7(Text7, { color: "blue", children: "Next steps:" }), getNextSteps().map((step, index) => _jsxs6(Text7, { color: "gray", children: ["\u2022 ", step] }, index))] })] });
+}
+function PullSuccessDisplay({ result }) {
+  return _jsxs6(Box5, { flexDirection: "column", children: [_jsx7(Box5, { marginBottom: 1, children: _jsx7(Text7, { color: "green", children: "\u2705 Schema updated successfully!" }) }), _jsxs6(Box5, { flexDirection: "column", marginBottom: 1, children: [_jsxs6(Text7, { children: ["Updated: ", result.filePath.split("/").pop()] }), _jsxs6(Text7, { children: ["Version: ", result.oldVersion, " \u2192 ", result.newVersion] }), _jsxs6(Text7, { children: ["Project: ", result.projectId] })] }), _jsxs6(Box5, { flexDirection: "column", marginTop: 1, children: [_jsx7(Text7, { color: "blue", children: "Next steps:" }), _jsx7(Text7, { color: "gray", children: "\u2022 Review the updated schema changes" }), _jsx7(Text7, { color: "gray", children: "\u2022 Continue working on your project" }), _jsx7(Text7, { color: "gray", children: "\u2022 Run 'basic status' to check your project state" })] })] });
+}
+async function PullCommand() {
+  render4(_jsx7(PullApp, {}));
+}
+var init_pull = __esm({
+  "dist/commands/pull.js"() {
+    "use strict";
+    init_Spinner();
+    init_api();
+    init_auth();
+    init_schema();
+    init_platform();
+    init_constants();
+  }
 });
-// Status command
-program
-    .command('status')
-    .description('Show project status')
-    .action(async () => {
+
+// dist/commands/push.js
+var push_exports = {};
+__export(push_exports, {
+  PushCommand: () => PushCommand
+});
+import { jsx as _jsx8, jsxs as _jsxs7, Fragment as _Fragment2 } from "react/jsx-runtime";
+import React6 from "react";
+import { render as render5, Box as Box6, Text as Text8, useInput as useInput4 } from "ink";
+function PushApp() {
+  const [state, setState] = React6.useState({
+    phase: "checking",
+    error: null
+  });
+  const [selectedOption, setSelectedOption] = React6.useState("yes");
+  React6.useEffect(() => {
+    async function checkPushStatus() {
+      try {
+        if (!await isOnline()) {
+          setState({
+            phase: "error",
+            error: MESSAGES.OFFLINE
+          });
+          return;
+        }
+        const authService = AuthService.getInstance();
+        const token = await authService.getToken();
+        if (!token) {
+          setState({
+            phase: "error",
+            error: MESSAGES.LOGGED_OUT
+          });
+          return;
+        }
+        const localConfig = await readSchemaFromConfig();
+        if (!localConfig) {
+          setState({
+            phase: "no-action",
+            error: null,
+            statusResult: {
+              status: "no-schema",
+              projectId: "",
+              localVersion: 0,
+              remoteVersion: 0,
+              message: [
+                "No schema found in config files",
+                "Run 'basic init' to create a new project or import an existing project"
+              ],
+              needsConfirmation: false,
+              confirmationTitle: "",
+              confirmationMessage: ""
+            }
+          });
+          return;
+        }
+        const apiClient = ApiClient.getInstance();
+        let remoteSchema = null;
+        try {
+          remoteSchema = await apiClient.getProjectSchema(localConfig.projectId);
+        } catch (error) {
+          setState({
+            phase: "error",
+            error: `Error fetching remote schema: ${error instanceof Error ? error.message : "Unknown error"}`
+          });
+          return;
+        }
+        if (!remoteSchema) {
+          remoteSchema = {
+            project_id: localConfig.projectId,
+            version: 0,
+            tables: {}
+          };
+        }
+        const comparison = compareVersions(localConfig.schema, remoteSchema);
+        const result = await analyzePushAction(localConfig, remoteSchema, comparison, apiClient);
+        setState({
+          phase: result.needsConfirmation ? "confirming" : "no-action",
+          error: null,
+          statusResult: result
+        });
+      } catch (error) {
+        setState({
+          phase: "error",
+          error: error instanceof Error ? error.message : "Failed to check push status"
+        });
+      }
+    }
+    checkPushStatus();
+  }, []);
+  useInput4((input, key) => {
+    if (state.phase === "confirming") {
+      if (key.upArrow || key.downArrow) {
+        setSelectedOption((prev) => prev === "yes" ? "no" : "yes");
+      } else if (key.return) {
+        if (selectedOption === "yes") {
+          handlePush();
+        } else {
+          setState((prev) => ({ ...prev, phase: "no-action" }));
+        }
+      } else if (key.escape || input === "q") {
+        setState((prev) => ({ ...prev, phase: "no-action" }));
+      }
+    }
+  });
+  const handlePush = async () => {
+    setState((prev) => ({ ...prev, phase: "pushing" }));
     try {
-        const { StatusCommand } = await import('./commands/status.js');
-        await StatusCommand();
+      if (!state.statusResult) {
+        throw new Error("No status result available");
+      }
+      const localConfig = await readSchemaFromConfig();
+      if (!localConfig) {
+        throw new Error("Local schema not found");
+      }
+      const apiClient = ApiClient.getInstance();
+      await apiClient.pushProjectSchema(localConfig.projectId, localConfig.schema);
+      setState({
+        phase: "success",
+        error: null,
+        pushResult: {
+          projectId: localConfig.projectId,
+          oldVersion: state.statusResult.remoteVersion,
+          newVersion: localConfig.schema.version || 0,
+          filePath: localConfig.filePath
+        }
+      });
+    } catch (error) {
+      setState({
+        phase: "error",
+        error: error instanceof Error ? error.message : "Failed to push schema"
+      });
+    }
+  };
+  if (state.phase === "checking") {
+    return _jsx8(Spinner, { text: "Checking push status..." });
+  }
+  if (state.phase === "pushing") {
+    return _jsx8(Spinner, { text: "Pushing schema to remote..." });
+  }
+  if (state.phase === "error") {
+    setTimeout(() => process.exit(1), 0);
+    return _jsxs7(Box6, { flexDirection: "column", children: [_jsxs7(Text8, { color: "red", children: ["Error: ", state.error] }), _jsxs7(Box6, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [_jsx8(Text8, { color: "blue", children: "Next steps:" }), state.error?.includes("offline") || state.error?.includes("network") ? _jsxs7(_Fragment2, { children: [_jsx8(Text8, { color: "gray", children: "\u2022 Check your internet connection" }), _jsx8(Text8, { color: "gray", children: "\u2022 Try again in a moment" })] }) : state.error?.includes("logged") || state.error?.includes("auth") ? _jsxs7(_Fragment2, { children: [_jsx8(Text8, { color: "gray", children: "\u2022 Run 'basic login' to authenticate" }), _jsx8(Text8, { color: "gray", children: "\u2022 Ensure you have a valid account" })] }) : state.error?.includes("schema") || state.error?.includes("project") ? _jsxs7(_Fragment2, { children: [_jsx8(Text8, { color: "gray", children: "\u2022 Check if the project ID is correct" }), _jsx8(Text8, { color: "gray", children: "\u2022 Ensure you have access to this project" }), _jsx8(Text8, { color: "gray", children: "\u2022 Run 'basic status' for more details" })] }) : _jsxs7(_Fragment2, { children: [_jsx8(Text8, { color: "gray", children: "\u2022 Try running the command again" }), _jsx8(Text8, { color: "gray", children: "\u2022 Run 'basic status' to check your project state" }), _jsx8(Text8, { color: "gray", children: "\u2022 Check the Basic documentation if the issue persists" })] })] })] });
+  }
+  if (state.phase === "success" && state.pushResult) {
+    setTimeout(() => process.exit(0), 0);
+    return _jsx8(PushSuccessDisplay, { result: state.pushResult });
+  }
+  if (state.phase === "confirming" && state.statusResult) {
+    return _jsx8(PushConfirmationDialog, { statusResult: state.statusResult, selectedOption });
+  }
+  if (state.phase === "no-action" && state.statusResult) {
+    setTimeout(() => process.exit(0), 0);
+    return _jsx8(PushStatusDisplay, { result: state.statusResult });
+  }
+  return _jsx8(Text8, { children: "Unknown state" });
+}
+async function analyzePushAction(localConfig, remoteSchema, comparison, apiClient) {
+  const { projectId } = localConfig;
+  const baseResult = {
+    projectId,
+    localVersion: comparison.localVersion,
+    remoteVersion: comparison.remoteVersion,
+    message: [],
+    needsConfirmation: false,
+    confirmationTitle: "",
+    confirmationMessage: ""
+  };
+  switch (comparison.status) {
+    case "ahead":
+      try {
+        const validation = await apiClient.validateSchema(localConfig.schema);
+        if (validation.valid === false && validation.errors) {
+          return {
+            ...baseResult,
+            status: "invalid",
+            message: [
+              "Errors found in schema! Please fix:",
+              "Your local schema has validation errors that must be resolved before pushing."
+            ],
+            validationErrors: validation.errors
+          };
+        }
+        return {
+          ...baseResult,
+          status: "ahead",
+          message: [
+            "Your local schema is ahead of the remote version.",
+            "Push your changes to publish them?"
+          ],
+          needsConfirmation: true,
+          confirmationTitle: "Push Schema Changes",
+          confirmationMessage: "This will publish your local schema changes to the remote project."
+        };
+      } catch (error) {
+        return {
+          ...baseResult,
+          status: "invalid",
+          message: [
+            `Error validating schema: ${error instanceof Error ? error.message : "Unknown error"}`,
+            "Please check your schema for syntax errors."
+          ]
+        };
+      }
+    case "equal":
+      if (comparison.localVersion === 0 && comparison.remoteVersion === 0) {
+        try {
+          const validation = await apiClient.validateSchema(localConfig.schema);
+          if (validation.valid === false && validation.errors) {
+            return {
+              ...baseResult,
+              status: "invalid",
+              message: [
+                "Errors found in schema! Please fix:"
+              ],
+              validationErrors: validation.errors
+            };
+          }
+          return {
+            ...baseResult,
+            status: "invalid",
+            message: [
+              "Schema changes are valid!",
+              "Please increment your version number to 1",
+              "and run 'basic push' if you are ready to publish your changes."
+            ]
+          };
+        } catch (error) {
+          return {
+            ...baseResult,
+            status: "invalid",
+            message: [
+              `Error validating schema: ${error instanceof Error ? error.message : "Unknown error"}`
+            ]
+          };
+        }
+      }
+      try {
+        const comparisonResult = await apiClient.compareSchema(localConfig.schema);
+        if (comparisonResult.valid) {
+          return {
+            ...baseResult,
+            status: "current",
+            message: [
+              "Schema is up to date!",
+              "No push needed."
+            ]
+          };
+        } else {
+          return {
+            ...baseResult,
+            status: "invalid",
+            message: [
+              "Your local schema differs from the remote schema.",
+              "Please increment your version number before pushing changes."
+            ]
+          };
+        }
+      } catch (error) {
+        return {
+          ...baseResult,
+          status: "current",
+          message: [
+            "Schema appears to be up to date.",
+            "(Unable to verify schema content - assuming current)"
+          ]
+        };
+      }
+    case "behind":
+      return {
+        ...baseResult,
+        status: "behind",
+        message: [
+          "Your local schema is behind the remote version.",
+          "Did you mean to pull instead?",
+          "Use 'basic pull' to get the latest changes."
+        ]
+      };
+    default:
+      return {
+        ...baseResult,
+        status: "current",
+        message: [
+          "Schema is up to date!",
+          "No push needed."
+        ]
+      };
+  }
+}
+function PushConfirmationDialog({ statusResult, selectedOption }) {
+  const getStatusIcon = () => {
+    switch (statusResult.status) {
+      case "ahead":
+        return "\u2B06\uFE0F";
+      default:
+        return "\u{1F4E4}";
+    }
+  };
+  const getStatusText = () => {
+    switch (statusResult.status) {
+      case "ahead":
+        return "Ready to push changes";
+      default:
+        return "Schema update ready";
+    }
+  };
+  const getStatusColor = () => {
+    switch (statusResult.status) {
+      case "ahead":
+        return "green";
+      default:
+        return "blue";
+    }
+  };
+  return _jsxs7(Box6, { flexDirection: "column", children: [_jsxs7(Box6, { flexDirection: "column", marginBottom: 1, children: [_jsxs7(Text8, { color: "cyan", children: ["Project ID: ", statusResult.projectId] }), _jsxs7(Box6, { children: [_jsxs7(Text8, { color: "gray", children: ["Local version: ", statusResult.localVersion] }), statusResult.remoteVersion > 0 && _jsxs7(Text8, { color: "gray", children: [" \u2022 Remote version: ", statusResult.remoteVersion] })] })] }), _jsx8(Box6, { marginBottom: 1, children: _jsxs7(Text8, { color: getStatusColor(), children: [getStatusIcon(), " ", getStatusText()] }) }), _jsx8(Box6, { flexDirection: "column", marginBottom: 2, children: statusResult.message.map((line, index) => _jsx8(Text8, { children: line }, index)) }), _jsxs7(Box6, { flexDirection: "column", children: [_jsx8(Box6, { children: _jsxs7(Text8, { color: selectedOption === "yes" ? "green" : "gray", children: [selectedOption === "yes" ? "\u276F" : " ", " Yes, push changes"] }) }), _jsx8(Box6, { children: _jsxs7(Text8, { color: selectedOption === "no" ? "green" : "gray", children: [selectedOption === "no" ? "\u276F" : " ", " No, cancel"] }) })] }), _jsx8(Box6, { marginTop: 1, children: _jsx8(Text8, { color: "gray", children: "Use \u2191\u2193 to navigate, Enter to confirm, Esc to cancel" }) })] });
+}
+function PushStatusDisplay({ result }) {
+  const getStatusColor = () => {
+    switch (result.status) {
+      case "current":
+        return "green";
+      case "behind":
+        return "yellow";
+      case "invalid":
+        return "red";
+      case "no-schema":
+        return "gray";
+      default:
+        return "white";
+    }
+  };
+  const getStatusIcon = () => {
+    switch (result.status) {
+      case "current":
+        return "\u2705";
+      case "behind":
+        return "\u2B07\uFE0F";
+      case "invalid":
+        return "\u274C";
+      case "no-schema":
+        return "\u{1F4C4}";
+      default:
+        return "\u2753";
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+  };
+  const getStatusDescription = () => {
+    switch (result.status) {
+      case "current":
+        return "Schema is up to date";
+      case "behind":
+        return "Local schema is behind remote";
+      case "invalid":
+        return "Schema has validation errors";
+      case "no-schema":
+        return "No schema file found";
+      default:
+        return "Unknown status";
     }
+  };
+  const getNextSteps = () => {
+    switch (result.status) {
+      case "current":
+        return [
+          "Continue working on your project",
+          "Run 'basic status' to check for changes",
+          "Make schema modifications if needed"
+        ];
+      case "behind":
+        return [
+          "Run 'basic pull' to get the latest changes",
+          "Or run 'basic status' for more details"
+        ];
+      case "invalid":
+        return [
+          "Fix the validation errors shown below",
+          "Run 'basic status' again after fixing errors",
+          "Review your schema syntax and field definitions"
+        ];
+      case "no-schema":
+        return [
+          "Run 'basic init' to create a new project or import an existing project",
+          "Make sure you're in a directory with a basic.config.ts/js file"
+        ];
+      default:
+        return [];
+    }
+  };
+  return _jsxs7(Box6, { flexDirection: "column", children: [result.projectId && _jsxs7(Box6, { flexDirection: "column", marginBottom: 1, children: [_jsxs7(Text8, { color: "cyan", children: ["Project ID: ", result.projectId] }), _jsxs7(Box6, { children: [_jsxs7(Text8, { color: "gray", children: ["Local version: ", result.localVersion] }), result.remoteVersion > 0 && _jsxs7(Text8, { color: "gray", children: [" \u2022 Remote version: ", result.remoteVersion] })] })] }), _jsx8(Box6, { marginBottom: 1, children: _jsxs7(Text8, { color: getStatusColor(), children: [getStatusIcon(), " ", getStatusDescription()] }) }), _jsx8(Box6, { flexDirection: "column", marginBottom: 1, children: result.message.map((line, index) => _jsx8(Text8, { children: line }, index)) }), result.validationErrors && result.validationErrors.length > 0 && _jsx8(Box6, { flexDirection: "column", marginBottom: 1, children: result.validationErrors.map((error, index) => _jsxs7(Text8, { color: "red", children: ["\u2022 ", error.message, " at ", error.instancePath || "root"] }, index)) }), getNextSteps().length > 0 && _jsxs7(Box6, { flexDirection: "column", marginBottom: 1, children: [_jsx8(Text8, { color: "blue", children: "Next steps:" }), getNextSteps().map((step, index) => _jsxs7(Text8, { color: "gray", children: ["\u2022 ", step] }, index))] })] });
+}
+function PushSuccessDisplay({ result }) {
+  return _jsxs7(Box6, { flexDirection: "column", children: [_jsx8(Box6, { marginBottom: 1, children: _jsx8(Text8, { color: "green", children: "\u2705 Schema pushed successfully!" }) }), _jsxs7(Box6, { flexDirection: "column", marginBottom: 1, children: [_jsxs7(Text8, { children: ["Source: ", result.filePath.split("/").pop()] }), _jsxs7(Text8, { children: ["Version: ", result.oldVersion, " \u2192 ", result.newVersion] }), _jsxs7(Text8, { children: ["Project: ", result.projectId] })] }), _jsxs7(Box6, { flexDirection: "column", marginTop: 1, children: [_jsx8(Text8, { color: "blue", children: "Next steps:" }), _jsx8(Text8, { color: "gray", children: "\u2022 Your schema changes are now live" }), _jsx8(Text8, { color: "gray", children: "\u2022 Continue working on your project" }), _jsx8(Text8, { color: "gray", children: "\u2022 Run 'basic status' to check your project state" })] })] });
+}
+async function PushCommand() {
+  render5(_jsx8(PushApp, {}));
+}
+var init_push = __esm({
+  "dist/commands/push.js"() {
+    "use strict";
+    init_Spinner();
+    init_api();
+    init_auth();
+    init_schema();
+    init_platform();
+    init_constants();
+  }
 });
-// Pull command
-program
-    .command('pull')
-    .description('Pull schema from remote')
-    .action(async () => {
+
+// dist/lib/config-templates.js
+var config_templates_exports = {};
+__export(config_templates_exports, {
+  CONFIG_TEMPLATES: () => CONFIG_TEMPLATES,
+  checkForExistingConfig: () => checkForExistingConfig,
+  createConfigFile: () => createConfigFile,
+  generateConfigContent: () => generateConfigContent2,
+  readExistingConfig: () => readExistingConfig
+});
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+function generateConfigContent2(template, projectId, projectName) {
+  const baseConfig = {
+    project_id: projectId,
+    version: 0,
+    tables: {
+      example: {
+        type: "collection",
+        fields: {
+          value: {
+            type: "string"
+          }
+        }
+      }
+    }
+  };
+  switch (template) {
+    case "typescript":
+      return `// Basic Project Configuration
+// see the docs for more info: https://docs.basic.tech
+
+const schema = ${JSON.stringify(baseConfig, null, 2)};
+
+export default schema;
+`;
+    case "javascript":
+      return `// Basic Project Configuration
+// see the docs for more info: https://docs.basic.tech
+
+const schema = ${JSON.stringify(baseConfig, null, 2)};
+
+module.exports = schema;
+`;
+    case "none":
+      return "";
+    default:
+      throw new Error(`Unknown template: ${template}`);
+  }
+}
+async function createConfigFile(template, projectId, projectName, targetDir = process.cwd()) {
+  if (template === "none") {
+    return null;
+  }
+  const templateInfo = CONFIG_TEMPLATES[template];
+  const configPath = path3.join(targetDir, templateInfo.filename);
+  const content = generateConfigContent2(template, projectId, projectName);
+  try {
+    await fs3.writeFile(configPath, content, "utf8");
+    return configPath;
+  } catch (error) {
+    throw new Error(`Failed to create config file: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function checkForExistingConfig(targetDir = process.cwd()) {
+  const possibleConfigs = [
+    "basic.config.ts",
+    "basic.config.js",
+    "basic.config.json"
+  ];
+  for (const filename of possibleConfigs) {
+    const filePath = path3.join(targetDir, filename);
     try {
-        const { PullCommand } = await import('./commands/pull.js');
-        await PullCommand();
+      await fs3.access(filePath);
+      return filePath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function readExistingConfig(targetDir = process.cwd()) {
+  const configPath = await checkForExistingConfig(targetDir);
+  if (!configPath) {
+    return null;
+  }
+  try {
+    const content = await fs3.readFile(configPath, "utf8");
+    if (configPath.endsWith(".json")) {
+      const config = JSON.parse(content);
+      return { projectId: config.project_id };
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+    const projectIdMatch = content.match(/["']?project_id["']?\s*:\s*["']([^"']+)["']/);
+    if (projectIdMatch) {
+      return { projectId: projectIdMatch[1] };
     }
+    return null;
+  } catch (error) {
+    throw new Error(`Failed to read existing config: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+var CONFIG_TEMPLATES;
+var init_config_templates = __esm({
+  "dist/lib/config-templates.js"() {
+    "use strict";
+    CONFIG_TEMPLATES = {
+      typescript: {
+        name: "TypeScript",
+        description: "",
+        filename: "basic.config.ts",
+        extension: "ts"
+      },
+      javascript: {
+        name: "JavaScript",
+        description: "",
+        filename: "basic.config.js",
+        extension: "js"
+      },
+      none: {
+        name: "None",
+        description: "No configuration file",
+        filename: "",
+        extension: ""
+      }
+    };
+  }
 });
-// Push command
-program
-    .command('push')
-    .description('Push schema to remote')
-    .action(async () => {
+
+// dist/components/InitForm.js
+import { jsx as _jsx9, jsxs as _jsxs8, Fragment as _Fragment3 } from "react/jsx-runtime";
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { Box as Box7, Text as Text9, useInput as useInput5 } from "ink";
+function InitForm({ onSuccess, onCancel, initialData }) {
+  const [state, setState] = useState3({
+    step: initialData?.source ? initialData.source === "new" ? "project-details" : "existing-selection" : "source",
+    source: initialData?.source || null,
+    projectName: initialData?.projectName || "",
+    projectSlug: initialData?.projectName ? generateSlug(initialData.projectName) : "",
+    selectedTeamId: null,
+    selectedProjectId: initialData?.projectId || null,
+    configTemplate: initialData?.configTemplate || null,
+    availableTeams: [],
+    availableProjects: [],
+    isLoading: false,
+    error: null
+  });
+  const [selectedOptionIndex, setSelectedOptionIndex] = useState3(0);
+  const [showTeamForm, setShowTeamForm] = useState3(false);
+  useEffect3(() => {
+    async function loadData() {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      try {
+        const apiClient = ApiClient.getInstance();
+        const [teams, projects] = await Promise.all([
+          apiClient.getTeams(),
+          apiClient.getProjects()
+        ]);
+        setState((prev) => ({
+          ...prev,
+          availableTeams: teams,
+          availableProjects: projects,
+          isLoading: false,
+          selectedTeamId: teams.length > 0 ? teams[0].id : null
+        }));
+      } catch (error) {
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: error instanceof Error ? error.message : "Failed to load data"
+        }));
+      }
+    }
+    loadData();
+  }, []);
+  useEffect3(() => {
+    if (state.projectName.trim()) {
+      const newSlug = generateSlug(state.projectName);
+      setState((prev) => ({ ...prev, projectSlug: newSlug }));
+    }
+  }, [state.projectName]);
+  useInput5((input, key) => {
+    if (showTeamForm) {
+      return;
+    }
+    if (key.escape) {
+      if (state.step === "source") {
+        onCancel();
+      } else {
+        goToPreviousStep();
+      }
+      return;
+    }
+    if (state.step === "project-details") {
+      handleProjectDetailsInput(input, key);
+    } else if (state.step === "source" || state.step === "team-selection" || state.step === "existing-selection" || state.step === "config-template" || state.step === "confirmation") {
+      handleSelectionInput(input, key);
+    }
+  });
+  const handleProjectDetailsInput = (input, key) => {
+    if (key.return) {
+      if (state.projectName.trim()) {
+        setState((prev) => ({ ...prev, step: "team-selection" }));
+        setSelectedOptionIndex(0);
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setState((prev) => ({
+        ...prev,
+        projectName: prev.projectName.slice(0, -1)
+      }));
+      return;
+    }
+    if (input && input.length === 1) {
+      setState((prev) => ({
+        ...prev,
+        projectName: prev.projectName + input
+      }));
+    }
+  };
+  const handleSelectionInput = (input, key) => {
+    const options = getOptionsForCurrentStep();
+    if (key.upArrow) {
+      setSelectedOptionIndex((prev) => prev > 0 ? prev - 1 : options.length - 1);
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedOptionIndex((prev) => prev < options.length - 1 ? prev + 1 : 0);
+      return;
+    }
+    if (key.return) {
+      handleOptionSelection();
+    }
+  };
+  const getOptionsForCurrentStep = () => {
+    switch (state.step) {
+      case "source":
+        return [
+          { label: "Create new project", value: "new" },
+          { label: "Import existing project", value: "existing" }
+        ];
+      case "team-selection":
+        const teamOptions = state.availableTeams.map((team) => ({
+          label: `${team.name} (${team.slug})`,
+          value: team.id
+        }));
+        teamOptions.push({ label: "Create new team...", value: "new" });
+        return teamOptions;
+      case "existing-selection":
+        return state.availableProjects.map((project) => ({
+          label: `${project.name} (${project.team_name || "Unknown team"})`,
+          value: project.id
+        }));
+      case "config-template":
+        return Object.entries(CONFIG_TEMPLATES).map(([key, template]) => ({
+          label: `${template.name} - ${template.description}`,
+          value: key
+        }));
+      case "confirmation":
+        return [
+          {
+            label: state.source === "new" ? "Yes, create project" : "Yes, import project",
+            value: "confirm"
+          },
+          { label: "No, go back", value: "back" }
+        ];
+      default:
+        return [];
+    }
+  };
+  const handleOptionSelection = () => {
+    const options = getOptionsForCurrentStep();
+    const selectedOption = options[selectedOptionIndex];
+    switch (state.step) {
+      case "source":
+        setState((prev) => ({
+          ...prev,
+          source: selectedOption.value,
+          step: selectedOption.value === "new" ? "project-details" : "existing-selection"
+        }));
+        setSelectedOptionIndex(0);
+        break;
+      case "team-selection":
+        if (selectedOption.value === "new") {
+          setShowTeamForm(true);
+        } else {
+          setState((prev) => ({
+            ...prev,
+            selectedTeamId: selectedOption.value,
+            step: "config-template"
+          }));
+          setSelectedOptionIndex(0);
+        }
+        break;
+      case "existing-selection":
+        setState((prev) => ({
+          ...prev,
+          selectedProjectId: selectedOption.value,
+          step: "config-template"
+        }));
+        setSelectedOptionIndex(0);
+        break;
+      case "config-template":
+        setState((prev) => ({
+          ...prev,
+          configTemplate: selectedOption.value,
+          step: "confirmation"
+        }));
+        setSelectedOptionIndex(0);
+        break;
+      case "confirmation":
+        if (selectedOption.value === "confirm") {
+          handleSubmit();
+        } else {
+          goToPreviousStep();
+        }
+        break;
+    }
+  };
+  const goToPreviousStep = () => {
+    switch (state.step) {
+      case "project-details":
+        setState((prev) => ({ ...prev, step: "source" }));
+        break;
+      case "team-selection":
+        setState((prev) => ({ ...prev, step: "project-details" }));
+        break;
+      case "existing-selection":
+        setState((prev) => ({ ...prev, step: "source" }));
+        break;
+      case "config-template":
+        setState((prev) => ({
+          ...prev,
+          step: state.source === "new" ? "team-selection" : "existing-selection"
+        }));
+        break;
+      case "confirmation":
+        setState((prev) => ({ ...prev, step: "config-template" }));
+        break;
+    }
+    setSelectedOptionIndex(0);
+  };
+  const handleTeamCreated = async (teamData) => {
+    setState((prev) => ({ ...prev, isLoading: true }));
     try {
-        const { PushCommand } = await import('./commands/push.js');
-        await PushCommand();
-    }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
-    }
-});
-// Init command
-program
-    .command('init')
-    .description('Create a new project or import an existing project')
-    .option('--new', 'Create a new project (skip project type selection)')
-    .option('--existing', 'Import an existing project')
-    .option('--name <name>', 'Project name for new projects')
-    .option('--project <id>', 'Project ID for existing projects')
-    .option('--ts', 'Use TypeScript configuration template')
-    .option('--js', 'Use JavaScript configuration template')
-    .action(async (options) => {
+      const apiClient = ApiClient.getInstance();
+      const newTeam = await apiClient.createTeam(teamData.teamName, teamData.teamSlug);
+      setState((prev) => ({
+        ...prev,
+        availableTeams: [...prev.availableTeams, newTeam],
+        selectedTeamId: newTeam.id,
+        step: "config-template",
+        isLoading: false
+      }));
+      setShowTeamForm(false);
+      setSelectedOptionIndex(0);
+    } catch (error) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: error instanceof Error ? error.message : "Failed to create team"
+      }));
+    }
+  };
+  const handleSubmit = async () => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
     try {
-        const { InitCommand } = await import('./commands/init.js');
-        await InitCommand(options);
+      const apiClient = ApiClient.getInstance();
+      let projectId;
+      let projectName;
+      if (state.source === "new") {
+        if (!state.selectedTeamId || !state.configTemplate) {
+          throw new Error("Missing required data for project creation");
+        }
+        const project = await apiClient.createProjectWithTeam(state.projectName, state.projectSlug, state.selectedTeamId);
+        projectId = project.id;
+        projectName = project.name;
+      } else {
+        if (!state.selectedProjectId) {
+          throw new Error("No project selected");
+        }
+        const project = await apiClient.getProject(state.selectedProjectId);
+        projectId = project.id;
+        projectName = project.name;
+      }
+      let configPath = null;
+      if (state.configTemplate && state.configTemplate !== "none") {
+        const { createConfigFile: createConfigFile2 } = await Promise.resolve().then(() => (init_config_templates(), config_templates_exports));
+        configPath = await createConfigFile2(state.configTemplate, projectId, projectName);
+        try {
+          const remoteSchema = await apiClient.getProjectSchema(projectId);
+          if (remoteSchema && remoteSchema.version > 0) {
+            const { saveSchemaToConfig: saveSchemaToConfig2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+            await saveSchemaToConfig2(remoteSchema);
+          }
+        } catch (error) {
+          console.warn("Failed to pull latest schema during init:", error);
+        }
+      }
+      onSuccess({ projectId, projectName, configPath });
+    } catch (error) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        error: error instanceof Error ? error.message : "Failed to create project"
+      }));
     }
-    catch (error) {
-        const cliError = handleError(error);
-        console.error(formatError(cliError));
-        process.exit(1);
+  };
+  if (showTeamForm) {
+    return _jsx9(TeamForm, { title: "Create New Team", onSubmit: handleTeamCreated, onCancel: () => setShowTeamForm(false) });
+  }
+  if (state.isLoading) {
+    return _jsx9(Spinner, { text: "Loading..." });
+  }
+  if (state.error) {
+    return _jsxs8(Box7, { flexDirection: "column", children: [_jsxs8(Text9, { color: "red", children: ["Error: ", state.error] }), _jsx9(Text9, { color: "gray", children: "Press Esc to go back" })] });
+  }
+  return _jsx9(Box7, { flexDirection: "column", padding: 1, children: renderCurrentStep() });
+  function renderCurrentStep() {
+    const stepNumber = getStepNumber();
+    const totalSteps = getTotalSteps();
+    switch (state.step) {
+      case "source":
+        return _jsxs8(_Fragment3, { children: [_jsxs8(Text9, { bold: true, color: "blue", children: ["Project Setup (", stepNumber, "/", totalSteps, ")"] }), _jsx9(Box7, { marginTop: 1, marginBottom: 2, children: _jsx9(Text9, { children: "How would you like to proceed?" }) }), renderOptions(), _jsx9(Box7, { marginTop: 2, children: _jsx9(Text9, { color: "gray", children: "\u2191/\u2193 select \u2022 enter to continue \u2022 esc to cancel" }) })] });
+      case "project-details":
+        return _jsxs8(_Fragment3, { children: [_jsxs8(Text9, { bold: true, color: "blue", children: ["Create New Project (", stepNumber, "/", totalSteps, ")"] }), _jsx9(Box7, { marginTop: 1, marginBottom: 1, children: _jsxs8(Text9, { color: "blue", children: [">", "  Project Name:"] }) }), _jsx9(Box7, { marginLeft: 2, marginBottom: 1, children: _jsxs8(Text9, { children: [state.projectName, _jsx9(Text9, { backgroundColor: "white", color: "black", children: "\u2588" })] }) }), state.projectSlug && _jsxs8(Box7, { marginBottom: 1, children: [_jsx9(Box7, { children: _jsx9(Text9, { color: "gray", children: "\u2713 Project Slug (auto-generated):" }) }), _jsx9(Box7, { marginLeft: 2, children: _jsx9(Text9, { children: state.projectSlug }) })] }), _jsx9(Box7, { marginTop: 2, children: _jsx9(Text9, { color: "gray", children: state.projectName.trim() ? "Enter to continue \u2022 esc to go back" : "Type project name \u2022 esc to go back" }) })] });
+      case "team-selection":
+        return _jsxs8(_Fragment3, { children: [_jsxs8(Text9, { bold: true, color: "blue", children: ["Create New Project (", stepNumber, "/", totalSteps, ")"] }), _jsxs8(Box7, { marginTop: 1, children: [_jsxs8(Text9, { color: "gray", children: ["\u2713 Project Name: ", state.projectName] }), _jsxs8(Text9, { color: "gray", children: ["\u2713 Project Slug: ", state.projectSlug] })] }), _jsx9(Box7, { marginTop: 1, marginBottom: 2, children: _jsx9(Text9, { children: "Select Team:" }) }), renderOptions(), _jsx9(Box7, { marginTop: 2, children: _jsx9(Text9, { color: "gray", children: "\u2191/\u2193 select \u2022 enter to continue \u2022 esc to go back" }) })] });
+      case "existing-selection":
+        return _jsxs8(_Fragment3, { children: [_jsxs8(Text9, { bold: true, color: "blue", children: ["Import Existing Project (", stepNumber, "/", totalSteps, ")"] }), _jsx9(Box7, { marginTop: 1, marginBottom: 2, children: _jsx9(Text9, { children: "Select Project:" }) }), renderOptions(), _jsx9(Box7, { marginTop: 2, children: _jsx9(Text9, { color: "gray", children: "\u2191/\u2193 select \u2022 enter to continue \u2022 esc to go back" }) })] });
+      case "config-template":
+        return _jsxs8(_Fragment3, { children: [_jsxs8(Text9, { bold: true, color: "blue", children: ["Configuration Setup (", stepNumber, "/", totalSteps, ")"] }), _jsx9(Box7, { marginTop: 1, marginBottom: 2, children: _jsx9(Text9, { children: "Choose config template:" }) }), renderOptions(), _jsx9(Box7, { marginTop: 2, children: _jsx9(Text9, { color: "gray", children: "\u2191/\u2193 select \u2022 enter to continue \u2022 esc to go back" }) })] });
+      case "confirmation":
+        return _jsxs8(_Fragment3, { children: [_jsxs8(Text9, { bold: true, color: "blue", children: ["Ready to ", state.source === "new" ? "Create" : "Import", " (", stepNumber, "/", totalSteps, ")"] }), _jsxs8(Box7, { marginTop: 1, marginBottom: 2, flexDirection: "column", children: [state.source === "new" ? _jsxs8(_Fragment3, { children: [_jsxs8(Text9, { children: ["\u2713 Project: ", state.projectName] }), _jsxs8(Text9, { children: ["\u2713 Team: ", getSelectedTeamName()] })] }) : _jsxs8(Text9, { children: ["\u2713 Project: ", getSelectedProjectName()] }), _jsxs8(Text9, { children: ["\u2713 Config: ", getSelectedTemplateName()] }), state.configTemplate !== "none" && _jsxs8(Text9, { children: ["\u2713 Location: ./", CONFIG_TEMPLATES[state.configTemplate].filename] })] }), renderOptions(), _jsx9(Box7, { marginTop: 2, children: _jsx9(Text9, { color: "gray", children: "\u2191/\u2193 select \u2022 enter to confirm \u2022 esc to go back" }) })] });
+      default:
+        return _jsx9(Text9, { children: "Unknown step" });
     }
+  }
+  function renderOptions() {
+    const options = getOptionsForCurrentStep();
+    return _jsx9(Box7, { flexDirection: "column", children: options.map((option, index) => _jsx9(Box7, { marginLeft: 2, children: _jsxs8(Text9, { color: index === selectedOptionIndex ? "blue" : "white", children: [index === selectedOptionIndex ? "\u25CF" : "\u25CB", " ", option.label] }) }, option.value)) });
+  }
+  function getStepNumber() {
+    const stepOrder = ["source", "project-details", "team-selection", "existing-selection", "config-template", "confirmation"];
+    return stepOrder.indexOf(state.step) + 1;
+  }
+  function getTotalSteps() {
+    return state.source === "new" ? 5 : 4;
+  }
+  function getSelectedTeamName() {
+    const team = state.availableTeams.find((t) => t.id === state.selectedTeamId);
+    return team ? team.name : "Unknown";
+  }
+  function getSelectedProjectName() {
+    const project = state.availableProjects.find((p) => p.id === state.selectedProjectId);
+    return project ? project.name : "Unknown";
+  }
+  function getSelectedTemplateName() {
+    return state.configTemplate ? CONFIG_TEMPLATES[state.configTemplate].name : "None";
+  }
+}
+var init_InitForm = __esm({
+  "dist/components/InitForm.js"() {
+    "use strict";
+    init_api();
+    init_platform();
+    init_config_templates();
+    init_Spinner();
+    init_TeamForm();
+  }
 });
-// Handle unknown commands
-program.on('command:*', (operands) => {
-    const unknownCommand = operands[0];
-    const suggestions = findSimilarCommands(unknownCommand);
-    console.error(`Unknown command: ${unknownCommand}\n`);
-    if (suggestions.length > 0) {
-        console.error('Did you mean:');
-        suggestions.forEach(suggestion => {
-            console.error(`  - ${suggestion}`);
+
+// dist/commands/init.js
+var init_exports = {};
+__export(init_exports, {
+  InitCommand: () => InitCommand
+});
+import { jsx as _jsx10, jsxs as _jsxs9 } from "react/jsx-runtime";
+import React7 from "react";
+import { render as render6, Box as Box8, Text as Text10 } from "ink";
+function InitApp({ options }) {
+  const [state, setState] = React7.useState({
+    loading: true,
+    error: null,
+    success: false
+  });
+  const [initialData, setInitialData] = React7.useState(null);
+  React7.useEffect(() => {
+    async function initialize() {
+      try {
+        if (!await isOnline()) {
+          setState({ loading: false, error: MESSAGES.OFFLINE, success: false });
+          return;
+        }
+        const authService = AuthService.getInstance();
+        const token = await authService.getToken();
+        if (!token) {
+          setState({ loading: false, error: MESSAGES.LOGGED_OUT, success: false });
+          return;
+        }
+        const existingConfigPath = await checkForExistingConfig();
+        if (existingConfigPath) {
+          const existingConfig = await readExistingConfig();
+          if (existingConfig?.projectId) {
+            setState({
+              loading: false,
+              error: `A basic.config already exists in this directory
+Project ID: ${existingConfig.projectId}
+
+To reinitialize, please remove the existing config file first.`,
+              success: false
+            });
+            return;
+          }
+        }
+        const parsedData = parseCliOptions(options);
+        setInitialData(parsedData);
+        setState({ loading: false, error: null, success: false });
+      } catch (error) {
+        setState({
+          loading: false,
+          error: error instanceof Error ? error.message : "Failed to initialize",
+          success: false
         });
-        console.error('');
+      }
     }
-    console.error("Use 'basic help' to see all commands.");
+    initialize();
+  }, [options]);
+  const handleSuccess = (result) => {
+    setState({ loading: false, error: null, success: true, result });
+    setTimeout(() => {
+      process.exit(0);
+    }, 2e3);
+  };
+  const handleCancel = () => {
+    process.exit(0);
+  };
+  if (state.loading) {
+    return _jsx10(Spinner, { text: "Initializing..." });
+  }
+  if (state.error) {
+    return _jsxs9(Box8, { flexDirection: "column", children: [_jsxs9(Text10, { color: "red", children: ["Error: ", state.error] }), _jsx10(Text10, { color: "gray", children: "Please resolve the issue and try again." })] });
+  }
+  if (state.success && state.result) {
+    return _jsxs9(Box8, { flexDirection: "column", children: [_jsx10(Text10, { color: "green", children: "\u2705 Project setup complete!" }), _jsx10(Text10, {}), _jsxs9(Text10, { children: ["Project: ", state.result.projectName] }), _jsxs9(Text10, { children: ["Project ID: ", state.result.projectId] }), state.result.configPath && _jsxs9(Text10, { children: ["Config file: ", state.result.configPath] }), _jsx10(Text10, {}), _jsx10(Text10, { color: "gray", children: "Visit https://docs.basic.tech for next steps." })] });
+  }
+  return _jsx10(InitForm, { onSuccess: handleSuccess, onCancel: handleCancel, initialData: initialData || void 0 });
+}
+function parseCliOptions(options) {
+  const result = {};
+  if (options.new) {
+    result.source = "new";
+  } else if (options.existing) {
+    result.source = "existing";
+  }
+  if (options.name) {
+    result.projectName = options.name;
+  }
+  if (options.project) {
+    result.projectId = options.project;
+    result.source = "existing";
+  }
+  if (options.ts) {
+    result.configTemplate = "typescript";
+  } else if (options.js) {
+    result.configTemplate = "javascript";
+  }
+  return result;
+}
+async function InitCommand(args = {}) {
+  render6(_jsx10(InitApp, { options: args }));
+}
+var init_init = __esm({
+  "dist/commands/init.js"() {
+    "use strict";
+    init_InitForm();
+    init_Spinner();
+    init_auth();
+    init_config_templates();
+    init_platform();
+    init_constants();
+  }
+});
+
+// dist/index.js
+init_constants();
+init_version();
+init_errors();
+init_platform();
+import { program } from "commander";
+process.on("uncaughtException", (error) => {
+  console.error("Fatal error:", error.message);
+  process.exit(1);
+});
+process.on("SIGINT", () => {
+  console.log("\nOperation cancelled");
+  process.exit(0);
+});
+program.name("basic").description("Basic CLI for creating & managing your projects").version(getVersion());
+program.command("login").description("Login to your Basic account").action(async () => {
+  try {
+    const { LoginCommand: LoginCommand2 } = await Promise.resolve().then(() => (init_login(), login_exports));
+    await LoginCommand2();
+    process.exit(0);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
     process.exit(1);
+  }
 });
-// Show welcome message if no command provided
-if (process.argv.length <= 2) {
-    console.log(MESSAGES.WELCOME);
+program.command("logout").description("Logout from your Basic account").action(async () => {
+  try {
+    const { LogoutCommand: LogoutCommand2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
+    await LogoutCommand2();
+    process.exit(0);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("account").description("Show account information").action(async () => {
+  try {
+    const { AccountCommand: AccountCommand2 } = await Promise.resolve().then(() => (init_account(), account_exports));
+    await AccountCommand2();
     process.exit(0);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("version").description("Show CLI version").action(async () => {
+  try {
+    const { VersionCommand: VersionCommand2 } = await Promise.resolve().then(() => (init_version2(), version_exports));
+    await VersionCommand2();
+    process.exit(0);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("update").description("Update CLI to the latest version").action(async () => {
+  try {
+    const { UpdateCommand: UpdateCommand2 } = await Promise.resolve().then(() => (init_update(), update_exports));
+    await UpdateCommand2();
+    process.exit(0);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("help").description("Show help information").action(() => {
+  program.help();
+});
+program.command("debug").description("Show Basic config directory location").action(async () => {
+  try {
+    const { DebugCommand: DebugCommand2 } = await Promise.resolve().then(() => (init_debug(), debug_exports));
+    await DebugCommand2();
+    process.exit(0);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("projects").description("List and browse your projects").action(async () => {
+  try {
+    const { ProjectsCommand: ProjectsCommand2 } = await Promise.resolve().then(() => (init_projects(), projects_exports));
+    await ProjectsCommand2();
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("teams").argument("[action]", "Teams action (new)", "list").description("List teams or create a new team").action(async (action) => {
+  try {
+    const { TeamsCommand: TeamsCommand2 } = await Promise.resolve().then(() => (init_teams(), teams_exports));
+    await TeamsCommand2(action);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("status").description("Show project status").action(async () => {
+  try {
+    const { StatusCommand: StatusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+    await StatusCommand2();
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("pull").description("Pull schema from remote").action(async () => {
+  try {
+    const { PullCommand: PullCommand2 } = await Promise.resolve().then(() => (init_pull(), pull_exports));
+    await PullCommand2();
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("push").description("Push schema to remote").action(async () => {
+  try {
+    const { PushCommand: PushCommand2 } = await Promise.resolve().then(() => (init_push(), push_exports));
+    await PushCommand2();
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.command("init").description("Create a new project or import an existing project").option("--new", "Create a new project (skip project type selection)").option("--existing", "Import an existing project").option("--name <name>", "Project name for new projects").option("--project <id>", "Project ID for existing projects").option("--ts", "Use TypeScript configuration template").option("--js", "Use JavaScript configuration template").action(async (options) => {
+  try {
+    const { InitCommand: InitCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    await InitCommand2(options);
+  } catch (error) {
+    const cliError = handleError(error);
+    console.error(formatError(cliError));
+    process.exit(1);
+  }
+});
+program.on("command:*", (operands) => {
+  const unknownCommand = operands[0];
+  const suggestions = findSimilarCommands(unknownCommand);
+  console.error(`Unknown command: ${unknownCommand}
+`);
+  if (suggestions.length > 0) {
+    console.error("Did you mean:");
+    suggestions.forEach((suggestion) => {
+      console.error(`  - ${suggestion}`);
+    });
+    console.error("");
+  }
+  console.error("Use 'basic help' to see all commands.");
+  process.exit(1);
+});
+if (process.argv.length <= 2) {
+  console.log(MESSAGES.WELCOME);
+  process.exit(0);
 }
-// Parse command line arguments
 program.parse();
-//# sourceMappingURL=index.js.map