@base44-preview/cli 0.0.1-pr.10.3124f70

package/README.md

@@ -0,0 +1,49 @@
+# Base44 CLI
+
+A unified command-line interface for managing Base44 applications, entities, functions, deployments, and related services.
+
+## Installation
+
+```bash
+# Using npm
+npm install
+
+# Build the project
+npm run build
+
+# Run the CLI
+npm start                     # Using node directly
+./dist/cli/index.js          # Run executable directly
+```
+
+## Development
+
+```bash
+# Run in development mode
+npm run dev
+
+# Build the project
+npm run build
+
+# Run the built CLI
+npm run start
+
+# Clean build artifacts
+npm run clean
+
+# Lint the code
+npm run lint
+
+```
+
+## Commands
+
+### Authentication
+
+- `base44 login` - Authenticate with Base44 using device code flow
+- `base44 whoami` - Display current authenticated user
+- `base44 logout` - Logout from current device
+
+### Project
+
+- `base44 show-project` - Display project configuration, entities, and functions

package/dist/cli/index.js

@@ -0,0 +1,631 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+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 chalk from "chalk";
+import { globby } from "globby";
+
+//#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
+var AuthApiError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "AuthApiError";
+	}
+};
+var AuthValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AuthValidationError";
+	}
+};
+
+//#endregion
+//#region src/core/consts.ts
+const PROJECT_SUBDIR = "base44";
+const FUNCTION_CONFIG_FILE = "function.jsonc";
+function getBase44Dir() {
+	return join(homedir(), ".base44");
+}
+function getAuthFilePath() {
+	return join(getBase44Dir(), "auth", "auth.json");
+}
+function getProjectConfigPatterns() {
+	return [
+		`${PROJECT_SUBDIR}/config.jsonc`,
+		`${PROJECT_SUBDIR}/config.json`,
+		"config.jsonc",
+		"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;
+}
+
+//#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/utils/fs.ts
+function pathExists(path) {
+	return access(path).then(() => true).catch(() => false);
+}
+async function readJsonFile(filePath) {
+	if (!await pathExists(filePath)) throw new Error(`File not found: ${filePath}`);
+	try {
+		const fileContent = await readFile(filePath, "utf-8");
+		const errors = [];
+		const result = parse(fileContent, errors, { allowTrailingComma: true });
+		if (errors.length > 0) {
+			const errorMessages = errors.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join(", ");
+			throw new Error(`File contains invalid JSONC: ${filePath} (${errorMessages})`);
+		}
+		return result;
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("invalid JSONC")) throw error;
+		throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function writeJsonFile(filePath, data) {
+	try {
+		const dir = dirname(filePath);
+		if (!await pathExists(dir)) await mkdir(dir, { recursive: true });
+		await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+	} catch (error) {
+		throw new Error(`Failed to write file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+async function deleteFile(filePath) {
+	if (!await pathExists(filePath)) return;
+	try {
+		await unlink(filePath);
+	} catch (error) {
+		throw new Error(`Failed to delete file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+
+//#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);
+	request.headers.set("Authorization", `Bearer ${newAccessToken}`);
+	return ky(request);
+}
+const httpClient = 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]
+	}
+});
+
+//#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;
+}
+
+//#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
+async function generateAndDisplayDeviceCode() {
+	const deviceCodeResponse = await runTask("Generating device code...", async () => {
+		return await generateDeviceCode();
+	}, {
+		successMessage: "Device code generated",
+		errorMessage: "Failed to generate device code"
+	});
+	log.info(`Please visit: ${deviceCodeResponse.verificationUriComplete}`);
+	return deviceCodeResponse;
+}
+async function waitForAuthentication(deviceCode, expiresIn, interval) {
+	let tokenResponse;
+	try {
+		await runTask("Waiting for you to complete authentication...", async () => {
+			await pWaitFor(async () => {
+				const result = await getTokenFromDeviceCode(deviceCode);
+				if (result !== null) {
+					tokenResponse = result;
+					return true;
+				}
+				return false;
+			}, {
+				interval: interval * 1e3,
+				timeout: expiresIn * 1e3
+			});
+		}, {
+			successMessage: "Authentication completed!",
+			errorMessage: "Authentication failed"
+		});
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("timed out")) throw new Error("Authentication timed out. Please try again.");
+		throw error;
+	}
+	if (tokenResponse === void 0) throw new Error("Failed to retrieve authentication token.");
+	return tokenResponse;
+}
+async function saveAuthData(response) {
+	const expiresAt = Date.now() + response.expiresIn * 1e3;
+	await writeAuth({
+		accessToken: response.accessToken,
+		refreshToken: response.refreshToken,
+		expiresAt,
+		email: "user@base44.com",
+		name: "Base44 User"
+	});
+}
+async function login() {
+	const deviceCodeResponse = await generateAndDisplayDeviceCode();
+	await saveAuthData(await waitForAuthentication(deviceCodeResponse.deviceCode, deviceCodeResponse.expiresIn, deviceCodeResponse.interval));
+	log.success("Successfully logged in!");
+}
+const loginCommand = new Command("login").description("Authenticate with Base44").action(async () => {
+	await runCommand(login);
+});
+
+//#endregion
+//#region src/cli/commands/auth/whoami.ts
+async function whoami() {
+	const auth = await readAuth();
+	log.info(`Logged in as: ${auth.name} (${auth.email})`);
+}
+const whoamiCommand = new Command("whoami").description("Display current authenticated user").action(async () => {
+	await runCommand(whoami);
+});
+
+//#endregion
+//#region src/cli/commands/auth/logout.ts
+async function logout() {
+	await deleteAuth();
+	log.info("Logged out successfully");
+}
+const logoutCommand = new Command("logout").description("Logout from current device").action(async () => {
+	await runCommand(logout);
+});
+
+//#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()
+});
+
+//#endregion
+//#region src/core/resources/entity/config.ts
+async function readEntityFile(entityPath) {
+	const parsed = await readJsonFile(entityPath);
+	const result = EntitySchema.safeParse(parsed);
+	if (!result.success) throw new Error(`Invalid entity configuration in ${entityPath}: ${result.error.issues.map((e) => e.message).join(", ")}`);
+	return result.data;
+}
+async function readAllEntities(entitiesDir) {
+	if (!await pathExists(entitiesDir)) return [];
+	const files = await globby("*.{json,jsonc}", {
+		cwd: entitiesDir,
+		absolute: true
+	});
+	return await Promise.all(files.map((filePath) => readEntityFile(filePath)));
+}
+
+//#endregion
+//#region src/core/resources/entity/resource.ts
+const entityResource = { readAll: readAllEntities };
+
+//#endregion
+//#region src/core/resources/function/schema.ts
+const HttpTriggerSchema = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	type: z.literal("http"),
+	path: z.string().min(1, "Path cannot be empty")
+});
+const ScheduleTriggerSchema = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	type: z.literal("schedule"),
+	scheduleMode: z.enum(["recurring", "once"]).optional(),
+	cron: z.string().min(1, "Cron expression cannot be empty"),
+	isActive: z.boolean().optional(),
+	timezone: z.string().optional()
+});
+const EventTriggerSchema = z.object({
+	id: z.string().optional(),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	type: z.literal("event"),
+	entity: z.string().min(1, "Entity name cannot be empty"),
+	event: z.string().min(1, "Event type cannot be empty")
+});
+const TriggerSchema = z.discriminatedUnion("type", [
+	HttpTriggerSchema,
+	ScheduleTriggerSchema,
+	EventTriggerSchema
+]);
+const FunctionConfigSchema = z.object({
+	entry: z.string().min(1, "Entry point cannot be empty"),
+	triggers: z.array(TriggerSchema).optional()
+});
+
+//#endregion
+//#region src/core/resources/function/config.ts
+async function readFunctionConfig(configPath) {
+	const parsed = await readJsonFile(configPath);
+	const result = FunctionConfigSchema.safeParse(parsed);
+	if (!result.success) throw new Error(`Invalid function configuration in ${configPath}: ${result.error.issues.map((e) => e.message).join(", ")}`);
+	return result.data;
+}
+async function readAllFunctions(functionsDir) {
+	if (!await pathExists(functionsDir)) return [];
+	const configFiles = await globby(`*/${FUNCTION_CONFIG_FILE}`, {
+		cwd: functionsDir,
+		absolute: true
+	});
+	return await Promise.all(configFiles.map((configPath) => readFunctionConfig(configPath)));
+}
+
+//#endregion
+//#region src/core/resources/function/resource.ts
+const functionResource = { readAll: readAllFunctions };
+
+//#endregion
+//#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")
+});
+async function findConfigInDir(dir) {
+	return (await globby(getProjectConfigPatterns(), {
+		cwd: dir,
+		absolute: true
+	}))[0] ?? null;
+}
+async function findProjectRoot(startPath) {
+	let current = startPath || process.cwd();
+	while (current !== dirname(current)) {
+		const configPath = await findConfigInDir(current);
+		if (configPath) return {
+			root: current,
+			configPath
+		};
+		current = dirname(current);
+	}
+	return null;
+}
+async function readProjectConfig(projectRoot) {
+	let found;
+	if (projectRoot) {
+		const configPath$1 = await findConfigInDir(projectRoot);
+		found = configPath$1 ? {
+			root: projectRoot,
+			configPath: configPath$1
+		} : null;
+	} else found = await findProjectRoot();
+	if (!found) throw new Error(`Project root not found. Please ensure config.jsonc or config.json exists in the project directory or ${PROJECT_SUBDIR}/ subdirectory.`);
+	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}`);
+	}
+	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))]);
+	return {
+		project: {
+			...project,
+			root,
+			configPath
+		},
+		entities,
+		functions
+	};
+}
+
+//#endregion
+//#region src/cli/commands/project/show-project.ts
+async function showProject() {
+	const projectData = await runTask("Reading project configuration", async () => {
+		return await readProjectConfig();
+	}, {
+		successMessage: "Project configuration loaded",
+		errorMessage: "Failed to load project configuration"
+	});
+	const jsonOutput = JSON.stringify(projectData, null, 2);
+	log.info(jsonOutput);
+}
+const showProjectCommand = new Command("show-project").description("Display project configuration, entities, and functions").action(async () => {
+	await runCommand(showProject);
+});
+
+//#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(version);
+program.addCommand(loginCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(logoutCommand);
+program.addCommand(showProjectCommand);
+program.parse();
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@base44-preview/cli",
+  "version": "0.0.1-pr.10.3124f70",
+  "description": "Base44 CLI - Unified interface for managing Base44 applications",
+  "type": "module",
+  "main": "./dist/cli/index.js",
+  "bin": "./dist/cli/index.js",
+  "exports": {
+    ".": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsx src/cli/index.ts",
+    "start": "node dist/cli/index.js",
+    "clean": "rm -rf dist",
+    "lint": "eslint src",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "base44",
+    "cli",
+    "command-line"
+  ],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/base44/cli"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "chalk": "^5.6.2",
+    "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"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^5.6.1",
+    "@types/node": "^22.10.5",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "tsdown": "^0.12.4",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.52.0",
+    "vitest": "^4.0.16"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  }
+}