@base44-preview/cli 0.0.1-pr.17.16cb029 → 0.0.1-pr.18.893dad9

package/README.md

@@ -5,45 +5,140 @@ A unified command-line interface for managing Base44 applications, entities, fun
 ## Installation
 
 ```bash
-# Using npm
-npm install
+# Using npm (globally)
+npm install -g base44
 
-# Build the project
-npm run build
+# Or run directly with npx
+npx base44 <command>
+```
+
+## Quick Start
+
+```bash
+# 1. Login to Base44
+base44 login
+
+# 2. Create a new project
+base44 create
+
+# 3. Push entities to Base44
+base44 entities push
+```
+
+## Commands
+
+### Authentication
+
+| Command | Description |
+|---------|-------------|
+| `base44 login` | Authenticate with Base44 using device code flow |
+| `base44 whoami` | Display current authenticated user |
+| `base44 logout` | Logout from current device |
+
+### Project Management
+
+| Command | Description |
+|---------|-------------|
+| `base44 create` | Create a new Base44 project from a template |
+
+### Entities
+
+| Command | Description |
+|---------|-------------|
+| `base44 entities push` | Push local entity schemas to Base44 |
 
-# Run the CLI
-npm start                     # Using node directly
-./dist/cli/index.js          # Run executable directly
+## Configuration
+
+### Project Configuration
+
+Base44 projects are configured via a `config.jsonc` (or `config.json`) file in the `base44/` subdirectory:
+
+```jsonc
+// base44/config.jsonc
+{
+  "id": "your-app-id",           // Set after project creation
+  "name": "My Project",
+  "entitiesDir": "./entities",   // Default: ./entities
+  "functionsDir": "./functions"  // Default: ./functions
+}
+```
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `BASE44_CLIENT_ID` | Your app ID | - |
+
+You can set these in a `.env.local` file in your `base44/` directory:
+
+```bash
+# base44/.env.local
+BASE44_CLIENT_ID=your-app-id
+```
+
+## Project Structure
+
+A typical Base44 project has this structure:
+
+```
+my-project/
+├── base44/
+│   ├── config.jsonc           # Project configuration
+│   ├── .env.local             # Environment variables (git-ignored)
+│   ├── entities/              # Entity schema files
+│   │   ├── user.jsonc
+│   │   └── product.jsonc
+├── src/                       # Your frontend code
+└── package.json
 ```
 
 ## Development
 
+### Prerequisites
+
+- Node.js >= 20.19.0
+- npm
+
+### Setup
+
 ```bash
-# Run in development mode
-npm run dev
+# Clone the repository
+git clone https://github.com/base44/cli.git
+cd cli
 
-# Build the project
-npm run build
+# Install dependencies
+npm install
 
-# Run the built CLI
-npm run start
+# Build
+npm run build
 
-# Clean build artifacts
-npm run clean
+# Run in development mode
+npm run dev -- <command>
+```
 
-# Lint the code
-npm run lint
+### Available Scripts
 
+```bash
+npm run build      # Build with tsdown
+npm run typecheck  # Type check with tsc
+npm run dev        # Run in development mode with tsx
+npm run lint       # Lint with ESLint
+npm test           # Run tests with Vitest
 ```
 
-## Commands
+### Running the Built CLI
 
-### Authentication
+```bash
+# After building
+npm start -- <command>
+
+# Or directly
+./dist/cli/index.js <command>
+```
+## Contributing
 
-- `base44 login` - Authenticate with Base44 using device code flow
-- `base44 whoami` - Display current authenticated user
-- `base44 logout` - Logout from current device
+See [AGENTS.md](./AGENTS.md) for development guidelines and architecture documentation.
 
-### Project
+## License
 
-- `base44 show-project` - Display project configuration, entities, and functions
+ISC

package/dist/cli/index.js

@@ -4,14 +4,14 @@ import chalk from "chalk";
 import { cancel, group, intro, log, select, spinner, text } from "@clack/prompts";
 import pWaitFor from "p-wait-for";
 import { z } from "zod";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import ky from "ky";
+import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { config } from "dotenv";
 import { globby } from "globby";
 import { access, copyFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { parse, printParseErrorCode } from "jsonc-parser";
-import ky from "ky";
 import ejs from "ejs";
 import kebabCase from "lodash.kebabcase";
 
@@ -27,12 +27,14 @@ const DeviceCodeResponseSchema = z.object({
 	device_code: z.string().min(1, "Device code cannot be empty"),
 	user_code: z.string().min(1, "User code cannot be empty"),
 	verification_uri: z.url("Invalid verification URL"),
+	verification_uri_complete: z.url("Invalid complete verification URL"),
 	expires_in: z.number().int().positive("Expires in must be a positive integer"),
 	interval: z.number().int().positive("Interval in must be a positive integer")
 }).transform((data) => ({
 	deviceCode: data.device_code,
 	userCode: data.user_code,
 	verificationUri: data.verification_uri,
+	verificationUriComplete: data.verification_uri_complete,
 	expiresIn: data.expires_in,
 	interval: data.interval
 }));
@@ -74,6 +76,20 @@ var AuthValidationError = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/core/consts.ts
+const PROJECT_SUBDIR = "base44";
+const FUNCTION_CONFIG_FILE = "function.jsonc";
+function getProjectConfigPatterns() {
+	return [
+		`${PROJECT_SUBDIR}/config.jsonc`,
+		`${PROJECT_SUBDIR}/config.json`,
+		"config.jsonc",
+		"config.json"
+	];
+}
+const AUTH_CLIENT_ID = "base44_cli";
+
 //#endregion
 //#region src/core/utils/fs.ts
 async function pathExists(path) {
@@ -122,35 +138,7 @@ async function deleteFile(filePath) {
 
 //#endregion
 //#region src/core/resources/entity/schema.ts
-const EntityPropertySchema = z.object({
-	type: z.string(),
-	description: z.string().optional(),
-	enum: z.array(z.string()).optional(),
-	default: z.union([
-		z.string(),
-		z.number(),
-		z.boolean()
-	]).optional(),
-	format: z.string().optional(),
-	items: z.any().optional(),
-	relation: z.object({
-		entity: z.string(),
-		type: z.string()
-	}).optional()
-});
-const EntityPoliciesSchema = z.object({
-	read: z.string().optional(),
-	create: z.string().optional(),
-	update: z.string().optional(),
-	delete: z.string().optional()
-});
-const EntitySchema = z.object({
-	name: z.string().min(1, "Entity name cannot be empty"),
-	type: z.literal("object"),
-	properties: z.record(z.string(), EntityPropertySchema),
-	required: z.array(z.string()).optional(),
-	policies: EntityPoliciesSchema.optional()
-});
+const EntitySchema = z.object({ name: z.string().min(1, "Entity name cannot be empty") });
 const SyncEntitiesResponseSchema = z.object({
 	created: z.array(z.string()),
 	updated: z.array(z.string()),
@@ -174,114 +162,6 @@ async function readAllEntities(entitiesDir) {
 	return await Promise.all(files.map((filePath) => readEntityFile(filePath)));
 }
 
-//#endregion
-//#region src/core/auth/config.ts
-const TOKEN_REFRESH_BUFFER_MS = 60 * 1e3;
-let refreshPromise = null;
-async function readAuth() {
-	try {
-		const parsed = await readJsonFile(getAuthFilePath());
-		const result = AuthDataSchema.safeParse(parsed);
-		if (!result.success) throw new Error(`Invalid authentication data: ${result.error.issues.map((e) => e.message).join(", ")}`);
-		return result.data;
-	} catch (error) {
-		if (error instanceof Error && error.message.includes("Authentication")) throw error;
-		if (error instanceof Error && error.message.includes("File not found")) throw new Error("Authentication file not found. Please login first.");
-		throw new Error(`Failed to read authentication file: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-async function writeAuth(authData) {
-	const result = AuthDataSchema.safeParse(authData);
-	if (!result.success) throw new Error(`Invalid authentication data: ${result.error.issues.map((e) => e.message).join(", ")}`);
-	try {
-		await writeJsonFile(getAuthFilePath(), result.data);
-	} catch (error) {
-		throw new Error(`Failed to write authentication file: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-async function deleteAuth() {
-	try {
-		await deleteFile(getAuthFilePath());
-	} catch (error) {
-		throw new Error(`Failed to delete authentication file: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-/**
-* Checks if the access token is expired or about to expire.
-*/
-function isTokenExpired(auth) {
-	return Date.now() >= auth.expiresAt - TOKEN_REFRESH_BUFFER_MS;
-}
-/**
-* Refreshes the access token and saves the new tokens.
-* Returns the new access token, or null if refresh failed.
-* Uses a lock to prevent concurrent refresh requests.
-*/
-async function refreshAndSaveTokens() {
-	if (refreshPromise) return refreshPromise;
-	refreshPromise = (async () => {
-		try {
-			const auth = await readAuth();
-			const tokenResponse = await renewAccessToken(auth.refreshToken);
-			await writeAuth({
-				...auth,
-				accessToken: tokenResponse.accessToken,
-				refreshToken: tokenResponse.refreshToken,
-				expiresAt: Date.now() + tokenResponse.expiresIn * 1e3
-			});
-			return tokenResponse.accessToken;
-		} catch {
-			await deleteAuth();
-			return null;
-		} finally {
-			refreshPromise = null;
-		}
-	})();
-	return refreshPromise;
-}
-
-//#endregion
-//#region src/core/utils/httpClient.ts
-const retriedRequests = /* @__PURE__ */ new WeakSet();
-/**
-* Handles 401 responses by refreshing the token and retrying the request.
-* Only retries once per request to prevent infinite loops.
-*/
-async function handleUnauthorized(request, _options, response) {
-	if (response.status !== 401) return;
-	if (retriedRequests.has(request)) return;
-	const newAccessToken = await refreshAndSaveTokens();
-	if (!newAccessToken) return;
-	retriedRequests.add(request);
-	return ky(request, { headers: { Authorization: `Bearer ${newAccessToken}` } });
-}
-const base44Client = ky.create({
-	prefixUrl: getBase44ApiUrl(),
-	headers: { "User-Agent": "Base44 CLI" },
-	hooks: {
-		beforeRequest: [async (request) => {
-			try {
-				const auth = await readAuth();
-				if (isTokenExpired(auth)) {
-					const newAccessToken = await refreshAndSaveTokens();
-					if (newAccessToken) {
-						request.headers.set("Authorization", `Bearer ${newAccessToken}`);
-						return;
-					}
-				}
-				request.headers.set("Authorization", `Bearer ${auth.accessToken}`);
-			} catch {}
-		}],
-		afterResponse: [handleUnauthorized]
-	}
-});
-/**
-* Returns an HTTP client scoped to the current app.
-*/
-function getAppClient() {
-	return base44Client.extend({ prefixUrl: new URL(`/api/apps/${getBase44ClientId()}/`, getBase44ApiUrl()).href });
-}
-
 //#endregion
 //#region src/core/resources/entity/api.ts
 async function pushEntities(entities) {
@@ -365,18 +245,50 @@ async function readAllFunctions(functionsDir) {
 const functionResource = { readAll: readAllFunctions };
 
 //#endregion
-//#region src/core/project/config.ts
-const ProjectConfigSchema = z.looseObject({
-	name: z.string().min(1, "Project name cannot be empty"),
-	entitiesDir: z.string().default("./entities"),
-	functionsDir: z.string().default("./functions")
+//#region src/core/project/schema.ts
+const TemplateSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	path: z.string()
 });
+const TemplatesConfigSchema = z.object({ templates: z.array(TemplateSchema) });
+const SiteConfigSchema = z.object({
+	buildCommand: z.string().optional(),
+	serveCommand: z.string().optional(),
+	outputDirectory: z.string().optional(),
+	installCommand: z.string().optional()
+});
+const ProjectConfigSchema = z.object({
+	name: z.string().min(1, "App name cannot be empty"),
+	description: z.string().optional(),
+	site: SiteConfigSchema.optional(),
+	entitiesDir: z.string().optional().default("entities"),
+	functionsDir: z.string().optional().default("functions")
+});
+const CreateProjectResponseSchema = z.looseObject({ id: z.string() });
+
+//#endregion
+//#region src/core/project/config.ts
 async function findConfigInDir(dir) {
 	return (await globby(getProjectConfigPatterns(), {
 		cwd: dir,
 		absolute: true
 	}))[0] ?? null;
 }
+/**
+* Searches for a Base44 project root by looking for config files.
+* Walks up the directory tree from the starting path until it finds a config file.
+*
+* @param startPath - Directory to start searching from. Defaults to cwd.
+* @returns Project root info if found, null otherwise.
+*
+* @example
+* const found = await findProjectRoot();
+* if (found) {
+*   console.log(`Project found at: ${found.root}`);
+* }
+*/
 async function findProjectRoot(startPath) {
 	let current = startPath || process.cwd();
 	while (current !== dirname(current)) {
@@ -389,6 +301,17 @@ async function findProjectRoot(startPath) {
 	}
 	return null;
 }
+/**
+* Reads and validates a Base44 project configuration from the filesystem.
+* Also loads all entities and functions defined in the project.
+*
+* @param projectRoot - Optional path to start searching from. Defaults to cwd.
+* @returns Project configuration including entities and functions.
+* @throws {Error} If no config file is found or if the config is invalid.
+*
+* @example
+* const { project, entities, functions } = await readProjectConfig();
+*/
 async function readProjectConfig(projectRoot) {
 	let found;
 	if (projectRoot) {
@@ -402,10 +325,7 @@ async function readProjectConfig(projectRoot) {
 	const { root, configPath } = found;
 	const parsed = await readJsonFile(configPath);
 	const result = ProjectConfigSchema.safeParse(parsed);
-	if (!result.success) {
-		const errors = result.error.issues.map((e) => e.message).join(", ");
-		throw new Error(`Invalid project configuration: ${errors}`);
-	}
+	if (!result.success) throw new Error(`Invalid project configuration: ${result.error.message}`);
 	const project = result.data;
 	const configDir = dirname(configPath);
 	const [entities, functions] = await Promise.all([entityResource.readAll(join(configDir, project.entitiesDir)), functionResource.readAll(join(configDir, project.functionsDir))]);
@@ -420,29 +340,6 @@ async function readProjectConfig(projectRoot) {
 	};
 }
 
-//#endregion
-//#region src/core/project/schema.ts
-const TemplateSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	description: z.string(),
-	path: z.string()
-});
-const TemplatesConfigSchema = z.object({ templates: z.array(TemplateSchema) });
-const SiteConfigSchema = z.object({
-	buildCommand: z.string().optional(),
-	serveCommand: z.string().optional(),
-	outputDirectory: z.string().optional(),
-	installCommand: z.string().optional()
-});
-const AppConfigSchema = z.object({
-	name: z.string().min(1, "App name cannot be empty"),
-	description: z.string().optional(),
-	site: SiteConfigSchema.optional(),
-	domains: z.array(z.string()).optional()
-});
-const CreateProjectResponseSchema = z.looseObject({ id: z.string() });
-
 //#endregion
 //#region src/core/project/api.ts
 async function createProject(projectName, description) {
@@ -457,7 +354,7 @@ async function createProject(projectName, description) {
 //#endregion
 //#region src/core/project/template.ts
 async function listTemplates() {
-	const parsed = await readJsonFile(join(getTemplatesDir(), "templates.json"));
+	const parsed = await readJsonFile(getTemplatesIndexPath());
 	return TemplatesConfigSchema.parse(parsed).templates;
 }
 /**
@@ -466,7 +363,6 @@ async function listTemplates() {
 * - All other files are copied directly
 */
 async function renderTemplate(template, destPath, data) {
-	if (template.path.includes("..") || isAbsolute(template.path)) throw new Error(`Invalid template path: ${template.path}`);
 	const templateDir = join(getTemplatesDir(), template.path);
 	const files = await globby("**/*", {
 		cwd: templateDir,
@@ -506,30 +402,21 @@ async function createProjectFiles(options) {
 //#endregion
 //#region src/core/config.ts
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const PROJECT_SUBDIR = "base44";
-const FUNCTION_CONFIG_FILE = "function.jsonc";
-const AUTH_CLIENT_ID = "base44_cli";
-function getBase44Dir() {
+function getBase44GlobalDir() {
 	return join(homedir(), ".base44");
 }
 function getAuthFilePath() {
-	return join(getBase44Dir(), "auth", "auth.json");
+	return join(getBase44GlobalDir(), "auth", "auth.json");
 }
 function getTemplatesDir() {
 	return join(__dirname, "templates");
 }
-function getProjectConfigPatterns() {
-	return [
-		`${PROJECT_SUBDIR}/config.jsonc`,
-		`${PROJECT_SUBDIR}/config.json`,
-		"config.jsonc",
-		"config.json"
-	];
+function getTemplatesIndexPath() {
+	return join(getTemplatesDir(), "templates.json");
 }
 /**
 * Load .env.local from the project root if it exists.
 * Values won't override existing process.env variables.
-* Safe to call multiple times - only loads once.
 */
 async function loadProjectEnv(projectRoot) {
 	const found = projectRoot ? { root: projectRoot } : await findProjectRoot();
@@ -540,38 +427,154 @@ async function loadProjectEnv(projectRoot) {
 		quiet: true
 	});
 }
-/**
-* Get the Base44 API URL.
-* Priority: process.env.BASE44_API_URL > .env.local > default
-*/
 function getBase44ApiUrl() {
 	return process.env.BASE44_API_URL || "https://app.base44.com";
 }
-/**
-* Get the Base44 Client ID (app ID).
-* Priority: process.env.BASE44_CLIENT_ID > .env.local
-* Returns undefined if not set.
-*/
 function getBase44ClientId() {
 	return process.env.BASE44_CLIENT_ID;
 }
 
 //#endregion
-//#region src/core/auth/authClient.ts
+//#region src/core/clients/oauth-client.ts
 /**
-* Separate ky instance for OAuth endpoints.
-* These don't need Authorization headers (they use client_id + tokens in body).
+* HTTP client for OAuth endpoints.
+* Used only for the login flow (device code, token exchange).
+* These endpoints don't need Authorization headers - they use client_id + tokens in body.
 */
-const authClient = ky.create({
+const oauthClient = ky.create({
 	prefixUrl: getBase44ApiUrl(),
 	headers: { "User-Agent": "Base44 CLI" }
 });
-var authClient_default = authClient;
+
+//#endregion
+//#region src/core/auth/config.ts
+const TOKEN_REFRESH_BUFFER_MS = 60 * 1e3;
+let refreshPromise = null;
+/**
+* Reads and validates the stored authentication data.
+*
+* @returns The parsed authentication data (tokens, user info).
+* @throws {Error} If not logged in or if auth data is corrupted.
+*
+* @example
+* const auth = await readAuth();
+* console.log(`Logged in as: ${auth.email}`);
+*/
+async function readAuth() {
+	try {
+		const parsed = await readJsonFile(getAuthFilePath());
+		const result = AuthDataSchema.safeParse(parsed);
+		if (!result.success) throw new Error(`Invalid authentication data: ${result.error.issues.map((e) => e.message).join(", ")}`);
+		return result.data;
+	} catch (error) {
+		throw new Error(`Failed to read authentication file: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function writeAuth(authData) {
+	const result = AuthDataSchema.safeParse(authData);
+	if (!result.success) throw new Error(`Invalid authentication data: ${result.error.issues.map((e) => e.message).join(", ")}`);
+	try {
+		await writeJsonFile(getAuthFilePath(), result.data);
+	} catch (error) {
+		throw new Error(`Failed to write authentication file: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function deleteAuth() {
+	try {
+		await deleteFile(getAuthFilePath());
+	} catch (error) {
+		throw new Error(`Failed to delete authentication file: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+function isTokenExpired(auth) {
+	return Date.now() >= auth.expiresAt - TOKEN_REFRESH_BUFFER_MS;
+}
+async function refreshAndSaveTokens() {
+	if (refreshPromise) return refreshPromise;
+	refreshPromise = (async () => {
+		try {
+			const auth = await readAuth();
+			const tokenResponse = await renewAccessToken(auth.refreshToken);
+			await writeAuth({
+				...auth,
+				accessToken: tokenResponse.accessToken,
+				refreshToken: tokenResponse.refreshToken,
+				expiresAt: Date.now() + tokenResponse.expiresIn * 1e3
+			});
+			return tokenResponse.accessToken;
+		} catch {
+			await deleteAuth();
+			return null;
+		} finally {
+			refreshPromise = null;
+		}
+	})();
+	return refreshPromise;
+}
+
+//#endregion
+//#region src/core/clients/base44-client.ts
+/**
+* Authenticated HTTP client for Base44 API.
+* Automatically handles token refresh and retry on 401 responses.
+*/
+const retriedRequests = /* @__PURE__ */ new WeakSet();
+/**
+* Handles 401 responses by refreshing the token and retrying the request.
+* Only retries once per request to prevent infinite loops.
+*/
+async function handleUnauthorized(request, _options, response) {
+	if (response.status !== 401) return;
+	if (retriedRequests.has(request)) return;
+	const newAccessToken = await refreshAndSaveTokens();
+	if (!newAccessToken) return;
+	retriedRequests.add(request);
+	return ky(request, { headers: { Authorization: `Bearer ${newAccessToken}` } });
+}
+/**
+* Base44 API client with automatic authentication.
+* Use this for general API calls that require authentication.
+*/
+const base44Client = ky.create({
+	prefixUrl: getBase44ApiUrl(),
+	headers: { "User-Agent": "Base44 CLI" },
+	hooks: {
+		beforeRequest: [async (request) => {
+			try {
+				const auth = await readAuth();
+				if (isTokenExpired(auth)) {
+					const newAccessToken = await refreshAndSaveTokens();
+					if (newAccessToken) {
+						request.headers.set("Authorization", `Bearer ${newAccessToken}`);
+						return;
+					}
+				}
+				request.headers.set("Authorization", `Bearer ${auth.accessToken}`);
+			} catch {}
+		}],
+		afterResponse: [handleUnauthorized]
+	}
+});
+/**
+* Returns an HTTP client scoped to the current app.
+* Use this for API calls to app-specific endpoints (entities, functions, etc.).
+*
+* @throws {Error} If BASE44_CLIENT_ID environment variable is not set.
+*
+* @example
+* const appClient = getAppClient();
+* const response = await appClient.get("entities");
+*/
+function getAppClient() {
+	const clientId = getBase44ClientId();
+	if (!clientId) throw new Error("BASE44_CLIENT_ID environment variable is required. Set it in your .env.local file.");
+	return base44Client.extend({ prefixUrl: new URL(`/api/apps/${clientId}/`, getBase44ApiUrl()).href });
+}
 
 //#endregion
 //#region src/core/auth/api.ts
 async function generateDeviceCode() {
-	const response = await authClient_default.post("oauth/device/code", {
+	const response = await oauthClient.post("oauth/device/code", {
 		json: {
 			client_id: AUTH_CLIENT_ID,
 			scope: "apps:read apps:write"
@@ -588,7 +591,7 @@ async function getTokenFromDeviceCode(deviceCode) {
 	searchParams.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
 	searchParams.set("device_code", deviceCode);
 	searchParams.set("client_id", AUTH_CLIENT_ID);
-	const response = await authClient_default.post("oauth/token", {
+	const response = await oauthClient.post("oauth/token", {
 		body: searchParams.toString(),
 		headers: { "Content-Type": "application/x-www-form-urlencoded" },
 		throwHttpErrors: false
@@ -610,7 +613,7 @@ async function renewAccessToken(refreshToken) {
 	searchParams.set("grant_type", "refresh_token");
 	searchParams.set("refresh_token", refreshToken);
 	searchParams.set("client_id", AUTH_CLIENT_ID);
-	const response = await authClient_default.post("oauth/token", {
+	const response = await oauthClient.post("oauth/token", {
 		body: searchParams.toString(),
 		headers: { "Content-Type": "application/x-www-form-urlencoded" },
 		throwHttpErrors: false
@@ -627,25 +630,49 @@ async function renewAccessToken(refreshToken) {
 	return result.data;
 }
 async function getUserInfo(accessToken) {
-	const response = await authClient_default.get("oauth/userinfo", { headers: { Authorization: `Bearer ${accessToken}` } });
+	const response = await oauthClient.get("oauth/userinfo", { headers: { Authorization: `Bearer ${accessToken}` } });
 	if (!response.ok) throw new AuthApiError(`Failed to fetch user info: ${response.status}`);
 	const result = UserInfoSchema.safeParse(await response.json());
 	if (!result.success) throw new AuthValidationError(`Invalid UserInfo response from server: ${result.error.message}`);
 	return result.data;
 }
 
+//#endregion
+//#region src/cli/utils/banner.ts
+const orange = chalk.hex("#E86B3C");
+const BANNER = `
+${orange("██████╗  █████╗ ███████╗███████╗ ██╗  ██╗██╗  ██╗")}
+${orange("██╔══██╗██╔══██╗██╔════╝██╔════╝ ██║  ██║██║  ██║")}
+${orange("██████╔╝███████║███████╗█████╗   ███████║███████║")}
+${orange("██╔══██╗██╔══██║╚════██║██╔══╝   ╚════██║╚════██║")}
+${orange("██████╔╝██║  ██║███████║███████╗      ██║     ██║")}
+${orange("╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝      ╚═╝     ╚═╝")}
+`;
+function printBanner() {
+	console.log(BANNER);
+}
+
 //#endregion
 //#region src/cli/utils/runCommand.ts
 const base44Color = chalk.bgHex("#E86B3C");
 /**
-* Wraps a command function with the Base44 intro banner.
+* Wraps a command function with the Base44 intro banner and error handling.
 * All CLI commands should use this utility to ensure consistent branding.
 * Also loads .env.local from the project root if available.
 *
 * @param commandFn - The async function to execute as the command
+* @param options - Optional configuration for the command wrapper
+*
+* @example
+* // Standard command with simple intro
+* export const myCommand = new Command("my-command")
+*   .action(async () => {
+*     await runCommand(myAction);
+*   });
 */
-async function runCommand(commandFn) {
-	intro(base44Color(" Base 44 "));
+async function runCommand(commandFn, options) {
+	if (options?.fullBanner) printBanner();
+	else intro(base44Color(" Base 44 "));
 	await loadProjectEnv();
 	try {
 		await commandFn();
@@ -664,8 +691,21 @@ async function runCommand(commandFn) {
 *
 * @param startMessage - Message to show when spinner starts
 * @param operation - The async operation to execute
-* @param options - Optional configuration
+* @param options - Optional configuration for success/error messages
 * @returns The result of the operation
+*
+* @example
+* const data = await runTask(
+*   "Fetching data...",
+*   async () => {
+*     const response = await fetch(url);
+*     return response.json();
+*   },
+*   {
+*     successMessage: "Data fetched successfully",
+*     errorMessage: "Failed to fetch data",
+*   }
+* );
 */
 async function runTask(startMessage, operation, options) {
 	const s = spinner();
@@ -691,21 +731,6 @@ const onPromptCancel = () => {
 	process.exit(0);
 };
 
-//#endregion
-//#region src/cli/utils/banner.ts
-const orange = chalk.hex("#E86B3C");
-const BANNER = `
-${orange("██████╗  █████╗ ███████╗███████╗ ██╗  ██╗██╗  ██╗")}
-${orange("██╔══██╗██╔══██╗██╔════╝██╔════╝ ██║  ██║██║  ██║")}
-${orange("██████╔╝███████║███████╗█████╗   ███████║███████║")}
-${orange("██╔══██╗██╔══██║╚════██║██╔══╝   ╚════██║╚════██║")}
-${orange("██████╔╝██║  ██║███████║███████╗      ██║     ██║")}
-${orange("╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝      ╚═╝     ╚═╝")}
-`;
-function printBanner() {
-	console.log(BANNER);
-}
-
 //#endregion
 //#region src/cli/commands/auth/login.ts
 async function generateAndDisplayDeviceCode() {
@@ -715,13 +740,13 @@ async function generateAndDisplayDeviceCode() {
 		successMessage: "Device code generated",
 		errorMessage: "Failed to generate device code"
 	});
-	log.info(`Verification code: ${chalk.bold(deviceCodeResponse.userCode)}\nPlease confirm this code at: ${deviceCodeResponse.verificationUri}`);
+	log.info(`Your code is: ${chalk.bold(deviceCodeResponse.userCode)}\nPlease visit: ${deviceCodeResponse.verificationUriComplete}`);
 	return deviceCodeResponse;
 }
 async function waitForAuthentication(deviceCode, expiresIn, interval) {
 	let tokenResponse;
 	try {
-		await runTask("Waiting for authentication...", async () => {
+		await runTask("Waiting for you to complete authentication...", async () => {
 			await pWaitFor(async () => {
 				const result = await getTokenFromDeviceCode(deviceCode);
 				if (result !== null) {
@@ -828,8 +853,6 @@ const entitiesPushCommand = new Command("entities").description("Manage project
 //#endregion
 //#region src/cli/commands/project/create.ts
 async function create() {
-	printBanner();
-	await loadProjectEnv();
 	const templateOptions = (await listTemplates()).map((t) => ({
 		value: t,
 		label: t.name,
@@ -875,13 +898,7 @@ async function create() {
 	log.success(`Project ${chalk.bold(name)} has been initialized!`);
 }
 const createCommand = new Command("create").description("Create a new Base44 project").action(async () => {
-	try {
-		await create();
-	} catch (e) {
-		if (e instanceof Error) log.error(e.stack ?? e.message);
-		else log.error(String(e));
-		process.exit(1);
-	}
+	await runCommand(create, { fullBanner: true });
 });
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.1-pr.17.16cb029",
+  "version": "0.0.1-pr.18.893dad9",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "main": "./dist/cli/index.js",