@base44-preview/cli 0.0.1-pr.11.ccd1624 → 0.0.1-pr.13.61a06bf

package/dist/cli/index.js

@@ -1,22 +1,60 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { intro, log, spinner } from "@clack/prompts";
 import chalk from "chalk";
+import { intro, log, spinner } from "@clack/prompts";
 import pWaitFor from "p-wait-for";
 import { z } from "zod";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+import ky from "ky";
 import { access, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import { globby } from "globby";
 
-//#region src/cli/utils/packageVersion.ts
-function getPackageVersion() {
-	const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-	return JSON.parse(readFileSync(packageJsonPath, "utf-8")).version;
-}
+//#region src/core/auth/schema.ts
+const AuthDataSchema = z.object({
+	accessToken: z.string().min(1, "Token cannot be empty"),
+	refreshToken: z.string().min(1, "Refresh token cannot be empty"),
+	expiresAt: z.number().int().positive("Expires at must be a positive integer"),
+	email: z.email(),
+	name: z.string().min(1, "Name cannot be empty")
+});
+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
+}));
+const TokenResponseSchema = z.object({
+	access_token: z.string().min(1, "Token cannot be empty"),
+	token_type: z.string().min(1, "Token type cannot be empty"),
+	expires_in: z.number().int().positive("Expires in must be a positive integer"),
+	refresh_token: z.string().min(1, "Refresh token cannot be empty"),
+	scope: z.string().optional()
+}).transform((data) => ({
+	accessToken: data.access_token,
+	tokenType: data.token_type,
+	expiresIn: data.expires_in,
+	refreshToken: data.refresh_token,
+	scope: data.scope
+}));
+const OAuthErrorSchema = z.object({
+	error: z.string(),
+	error_description: z.string().optional()
+});
+const UserInfoSchema = z.object({
+	email: z.email(),
+	name: z.string()
+});
 
 //#endregion
 //#region src/core/errors.ts
@@ -28,134 +66,12 @@ var AuthApiError = class extends Error {
 	}
 };
 var AuthValidationError = class extends Error {
-	constructor(message, issues) {
+	constructor(message) {
 		super(message);
-		this.issues = issues;
 		this.name = "AuthValidationError";
 	}
 };
 
-//#endregion
-//#region src/cli/utils/runCommand.ts
-const base44Color = chalk.bgHex("#E86B3C");
-/**
-* Wraps a command function with the Base44 intro banner.
-* All CLI commands should use this utility to ensure consistent branding.
-*
-* @param commandFn - The async function to execute as the command
-*/
-async function runCommand(commandFn) {
-	intro(base44Color(" Base 44 "));
-	try {
-		await commandFn();
-	} catch (e) {
-		if (e instanceof AuthValidationError) {
-			const issues = e.issues.map((i) => i.message).join(", ");
-			log.error(`Invalid response from server: ${issues}`);
-		} else if (e instanceof AuthApiError || e instanceof Error) log.error(e.message);
-		else log.error(String(e));
-		process.exit(1);
-	}
-}
-
-//#endregion
-//#region src/cli/utils/runTask.ts
-/**
-* Wraps an async operation with automatic spinner management.
-* The spinner is automatically started, and stopped on both success and error.
-*
-* @param startMessage - Message to show when spinner starts
-* @param operation - The async operation to execute
-* @param options - Optional configuration
-* @returns The result of the operation
-*/
-async function runTask(startMessage, operation, options) {
-	const s = spinner();
-	s.start(startMessage);
-	try {
-		const result = await operation();
-		s.stop(options?.successMessage || startMessage);
-		return result;
-	} catch (error) {
-		s.stop(options?.errorMessage || "Failed");
-		throw error;
-	}
-}
-
-//#endregion
-//#region src/core/auth/schema.ts
-const AuthDataSchema = z.object({
-	token: z.string().min(1, "Token cannot be empty"),
-	email: z.email(),
-	name: z.string().min(1, "Name cannot be empty")
-});
-const DeviceCodeResponseSchema = z.object({
-	deviceCode: z.string().min(1, "Device code cannot be empty"),
-	userCode: z.string().min(1, "User code cannot be empty"),
-	verificationUrl: z.url("Invalid verification URL"),
-	expiresIn: z.number().int().positive("Expires in must be a positive integer")
-});
-const TokenResponseSchema = z.object({
-	token: z.string().min(1, "Token cannot be empty"),
-	email: z.email("Invalid email address"),
-	name: z.string().min(1, "Name cannot be empty")
-});
-
-//#endregion
-//#region src/core/auth/api.ts
-async function delay(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-const deviceCodeToTokenMap = /* @__PURE__ */ new Map();
-async function generateDeviceCode() {
-	try {
-		await delay(1e3);
-		const deviceCode = `device-code-${Date.now()}`;
-		deviceCodeToTokenMap.set(deviceCode, {
-			startTime: Date.now(),
-			readyAfter: 5e3
-		});
-		const mockResponse = {
-			deviceCode,
-			userCode: "ABCD-1234",
-			verificationUrl: "https://app.base44.com/verify",
-			expiresIn: 600
-		};
-		const result = DeviceCodeResponseSchema.safeParse(mockResponse);
-		if (!result.success) throw new AuthValidationError("Invalid device code response from server", result.error.issues.map((issue) => ({
-			message: issue.message,
-			path: issue.path.map(String)
-		})));
-		return result.data;
-	} catch (error) {
-		if (error instanceof AuthValidationError) throw error;
-		throw new AuthApiError("Failed to generate device code", error instanceof Error ? error : new Error(String(error)));
-	}
-}
-async function getTokenFromDeviceCode(deviceCode) {
-	try {
-		await delay(1e3);
-		const deviceInfo = deviceCodeToTokenMap.get(deviceCode);
-		if (!deviceInfo) return null;
-		if (Date.now() - deviceInfo.startTime < deviceInfo.readyAfter) return null;
-		const mockResponse = {
-			token: `mock-token-${Date.now()}`,
-			email: "shahart@base44.com",
-			name: "Shahar Talmi"
-		};
-		const result = TokenResponseSchema.safeParse(mockResponse);
-		if (!result.success) throw new AuthValidationError("Invalid token response from server", result.error.issues.map((issue) => ({
-			message: issue.message,
-			path: issue.path.map(String)
-		})));
-		deviceCodeToTokenMap.delete(deviceCode);
-		return result.data;
-	} catch (error) {
-		if (error instanceof AuthValidationError || error instanceof AuthApiError) throw error;
-		throw new AuthApiError("Failed to retrieve token from device code", error instanceof Error ? error : new Error(String(error)));
-	}
-}
-
 //#endregion
 //#region src/core/consts.ts
 const PROJECT_SUBDIR = "base44";
@@ -174,6 +90,94 @@ function getProjectConfigPatterns() {
 		"config.json"
 	];
 }
+const AUTH_CLIENT_ID = "base44_cli";
+const DEFAULT_API_URL = "https://app.base44.com";
+function getBase44ApiUrl() {
+	return process.env.BASE44_API_URL || DEFAULT_API_URL;
+}
+function getAppId() {
+	const appId = process.env.BASE44_CLIENT_ID;
+	if (!appId) throw new Error("BASE44_CLIENT_ID environment variable is not set");
+	return appId;
+}
+
+//#endregion
+//#region src/core/auth/authClient.ts
+/**
+* Separate ky instance for OAuth endpoints.
+* These don't need Authorization headers (they use client_id + tokens in body).
+*/
+const authClient = ky.create({
+	prefixUrl: getBase44ApiUrl(),
+	headers: { "User-Agent": "Base44 CLI" }
+});
+var authClient_default = authClient;
+
+//#endregion
+//#region src/core/auth/api.ts
+async function generateDeviceCode() {
+	const response = await authClient_default.post("oauth/device/code", {
+		json: {
+			client_id: AUTH_CLIENT_ID,
+			scope: "apps:read apps:write"
+		},
+		throwHttpErrors: false
+	});
+	if (!response.ok) throw new AuthApiError(`Failed to generate device code: ${response.status} ${response.statusText}`);
+	const result = DeviceCodeResponseSchema.safeParse(await response.json());
+	if (!result.success) throw new AuthValidationError(`Invalid device code response from server: ${result.error.message}`);
+	return result.data;
+}
+async function getTokenFromDeviceCode(deviceCode) {
+	const searchParams = new URLSearchParams();
+	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", {
+		body: searchParams.toString(),
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		throwHttpErrors: false
+	});
+	const json = await response.json();
+	if (!response.ok) {
+		const errorResult = OAuthErrorSchema.safeParse(json);
+		if (!errorResult.success) throw new AuthValidationError(`Token request failed: ${errorResult.error.message}`);
+		const { error, error_description } = errorResult.data;
+		if (error === "authorization_pending" || error === "slow_down") return null;
+		throw new AuthApiError(error_description ?? `OAuth error: ${error}`);
+	}
+	const result = TokenResponseSchema.safeParse(json);
+	if (!result.success) throw new AuthValidationError(`Invalid token response from server: ${result.error.message}`);
+	return result.data;
+}
+async function renewAccessToken(refreshToken) {
+	const searchParams = new URLSearchParams();
+	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", {
+		body: searchParams.toString(),
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		throwHttpErrors: false
+	});
+	const json = await response.json();
+	if (!response.ok) {
+		const errorResult = OAuthErrorSchema.safeParse(json);
+		if (!errorResult.success) throw new AuthApiError(`Token refresh failed: ${response.statusText}`);
+		const { error, error_description } = errorResult.data;
+		throw new AuthApiError(error_description ?? `OAuth error: ${error}`);
+	}
+	const result = TokenResponseSchema.safeParse(json);
+	if (!result.success) throw new AuthValidationError(`Invalid token response from server: ${result.error.message}`);
+	return result.data;
+}
+async function getUserInfo(accessToken) {
+	const response = await authClient_default.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/core/utils/fs.ts
@@ -216,6 +220,8 @@ async function deleteFile(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());
@@ -244,6 +250,83 @@ async function deleteAuth() {
 		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/cli/utils/runCommand.ts
+const base44Color = chalk.bgHex("#E86B3C");
+/**
+* Wraps a command function with the Base44 intro banner.
+* All CLI commands should use this utility to ensure consistent branding.
+*
+* @param commandFn - The async function to execute as the command
+*/
+async function runCommand(commandFn) {
+	intro(base44Color(" Base 44 "));
+	try {
+		await commandFn();
+	} catch (e) {
+		if (e instanceof Error) log.error(e.stack ?? e.message);
+		else log.error(String(e));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/cli/utils/runTask.ts
+/**
+* Wraps an async operation with automatic spinner management.
+* The spinner is automatically started, and stopped on both success and error.
+*
+* @param startMessage - Message to show when spinner starts
+* @param operation - The async operation to execute
+* @param options - Optional configuration
+* @returns The result of the operation
+*/
+async function runTask(startMessage, operation, options) {
+	const s = spinner();
+	s.start(startMessage);
+	try {
+		const result = await operation();
+		s.stop(options?.successMessage || startMessage);
+		return result;
+	} catch (error) {
+		s.stop(options?.errorMessage || "Failed");
+		throw error;
+	}
+}
 
 //#endregion
 //#region src/cli/commands/auth/login.ts
@@ -254,10 +337,10 @@ async function generateAndDisplayDeviceCode() {
 		successMessage: "Device code generated",
 		errorMessage: "Failed to generate device code"
 	});
-	log.info(`Please visit: ${deviceCodeResponse.verificationUrl}\nEnter your device code: ${deviceCodeResponse.userCode}`);
+	log.info(`Your code is: ${chalk.bold(deviceCodeResponse.userCode)}\nPlease visit: ${deviceCodeResponse.verificationUriComplete}`);
 	return deviceCodeResponse;
 }
-async function waitForAuthentication(deviceCode, expiresIn) {
+async function waitForAuthentication(deviceCode, expiresIn, interval) {
 	let tokenResponse;
 	try {
 		await runTask("Waiting for you to complete authentication...", async () => {
@@ -269,7 +352,7 @@ async function waitForAuthentication(deviceCode, expiresIn) {
 				}
 				return false;
 			}, {
-				interval: 2e3,
+				interval: interval * 1e3,
 				timeout: expiresIn * 1e3
 			});
 		}, {
@@ -283,18 +366,22 @@ async function waitForAuthentication(deviceCode, expiresIn) {
 	if (tokenResponse === void 0) throw new Error("Failed to retrieve authentication token.");
 	return tokenResponse;
 }
-async function saveAuthData(token) {
+async function saveAuthData(response, userInfo) {
+	const expiresAt = Date.now() + response.expiresIn * 1e3;
 	await writeAuth({
-		token: token.token,
-		email: token.email,
-		name: token.name
+		accessToken: response.accessToken,
+		refreshToken: response.refreshToken,
+		expiresAt,
+		email: userInfo.email,
+		name: userInfo.name
 	});
 }
 async function login() {
 	const deviceCodeResponse = await generateAndDisplayDeviceCode();
-	const token = await waitForAuthentication(deviceCodeResponse.deviceCode, deviceCodeResponse.expiresIn);
-	await saveAuthData(token);
-	log.success(`Logged in as ${token.name}`);
+	const token = await waitForAuthentication(deviceCodeResponse.deviceCode, deviceCodeResponse.expiresIn, deviceCodeResponse.interval);
+	const userInfo = await getUserInfo(token.accessToken);
+	await saveAuthData(token, userInfo);
+	log.success(`Successfully logged in as ${chalk.bold(userInfo.email)}`);
 }
 const loginCommand = new Command("login").description("Authenticate with Base44").action(async () => {
 	await runCommand(login);
@@ -351,6 +438,11 @@ const EntitySchema = z.object({
 	required: z.array(z.string()).optional(),
 	policies: EntityPoliciesSchema.optional()
 });
+const SyncEntitiesResponseSchema = z.object({
+	created: z.array(z.string()),
+	updated: z.array(z.string()),
+	deleted: z.array(z.string())
+});
 
 //#endregion
 //#region src/core/resources/entity/config.ts
@@ -369,9 +461,71 @@ async function readAllEntities(entitiesDir) {
 	return await Promise.all(files.map((filePath) => readEntityFile(filePath)));
 }
 
+//#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/${getAppId()}/`, getBase44ApiUrl()).href });
+}
+
+//#endregion
+//#region src/core/resources/entity/api.ts
+async function pushEntities(entities) {
+	const appClient = getAppClient();
+	const schemaSyncPayload = Object.fromEntries(entities.map((entity) => [entity.name, entity]));
+	const response = await appClient.put("entities-schemas/sync-all", {
+		json: { entityNameToSchema: schemaSyncPayload },
+		throwHttpErrors: false
+	});
+	if (!response.ok) {
+		const errorJson = await response.json();
+		if (response.status === 428) throw new Error(`Failed to delete entity: ${errorJson.message}`);
+		throw new Error(`Error occurred while syncing entities ${errorJson.message}`);
+	}
+	return SyncEntitiesResponseSchema.parse(await response.json());
+}
+
 //#endregion
 //#region src/core/resources/entity/resource.ts
-const entityResource = { readAll: readAllEntities };
+const entityResource = {
+	readAll: readAllEntities,
+	push: pushEntities
+};
 
 //#endregion
 //#region src/core/resources/function/schema.ts
@@ -435,8 +589,8 @@ const functionResource = { readAll: readAllFunctions };
 //#region src/core/config/project.ts
 const ProjectConfigSchema = z.looseObject({
 	name: z.string().min(1, "Project name cannot be empty"),
-	entitySrc: z.string().default("./entities"),
-	functionSrc: z.string().default("./functions")
+	entitiesDir: z.string().default("./entities"),
+	functionsDir: z.string().default("./functions")
 });
 async function findConfigInDir(dir) {
 	return (await globby(getProjectConfigPatterns(), {
@@ -475,7 +629,7 @@ async function readProjectConfig(projectRoot) {
 	}
 	const project = result.data;
 	const configDir = dirname(configPath);
-	const [entities, functions] = await Promise.all([entityResource.readAll(join(configDir, project.entitySrc)), functionResource.readAll(join(configDir, project.functionSrc))]);
+	const [entities, functions] = await Promise.all([entityResource.readAll(join(configDir, project.entitiesDir)), functionResource.readAll(join(configDir, project.functionsDir))]);
 	return {
 		project: {
 			...project,
@@ -503,14 +657,58 @@ const showProjectCommand = new Command("show-project").description("Display proj
 	await runCommand(showProject);
 });
 
+//#endregion
+//#region src/core/config/app.ts
+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()
+});
+
+//#endregion
+//#region src/cli/commands/entities/push.ts
+async function pushEntitiesAction() {
+	const { entities } = await readProjectConfig();
+	if (entities.length === 0) {
+		log.warn("No entities found in project");
+		return;
+	}
+	log.info(`Found ${entities.length} entities to push`);
+	const result = await runTask("Pushing entities to Base44", async () => {
+		return await pushEntities(entities);
+	}, {
+		successMessage: "Entities pushed successfully",
+		errorMessage: "Failed to push entities"
+	});
+	if (result.created.length > 0) log.success(`Created: ${result.created.join(", ")}`);
+	if (result.updated.length > 0) log.success(`Updated: ${result.updated.join(", ")}`);
+	if (result.deleted.length > 0) log.warn(`Deleted: ${result.deleted.join(", ")}`);
+	if (result.created.length === 0 && result.updated.length === 0 && result.deleted.length === 0) log.info("No changes detected");
+}
+const entitiesPushCommand = new Command("entities").description("Manage project entities").addCommand(new Command("push").description("Push local entities to Base44").action(async () => {
+	await runCommand(pushEntitiesAction);
+}));
+
+//#endregion
+//#region package.json
+var version = "0.0.1";
+
 //#endregion
 //#region src/cli/index.ts
 const program = new Command();
-program.name("base44").description("Base44 CLI - Unified interface for managing Base44 applications").version(getPackageVersion());
+program.name("base44").description("Base44 CLI - Unified interface for managing Base44 applications").version(version);
 program.addCommand(loginCommand);
 program.addCommand(whoamiCommand);
 program.addCommand(logoutCommand);
 program.addCommand(showProjectCommand);
+program.addCommand(entitiesPushCommand);
 program.parse();
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.1-pr.11.ccd1624",
+  "version": "0.0.1-pr.13.61a06bf",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "main": "./dist/cli/index.js",
@@ -38,6 +38,7 @@
     "commander": "^12.1.0",
     "globby": "^16.1.0",
     "jsonc-parser": "^3.3.1",
+    "ky": "^1.14.2",
     "p-wait-for": "^6.0.0",
     "zod": "^4.3.5"
   },