@base44-preview/cli 0.0.24-pr.146.e5ee77a → 0.0.25-pr.104.089a20e

package/README.md

@@ -53,6 +53,8 @@ The CLI will guide you through project setup. For step-by-step tutorials, see th
 | [`entities push`](https://docs.base44.com/developers/references/cli/commands/entities-push) | Push local entity schemas to Base44 |
 | [`functions deploy`](https://docs.base44.com/developers/references/cli/commands/functions-deploy) | Deploy local functions to Base44 |
 | [`site deploy`](https://docs.base44.com/developers/references/cli/commands/site-deploy) | Deploy built site files to Base44 hosting |
+| `connectors add [type]` | Connect an OAuth integration |
+| `connectors remove [type]` | Disconnect an integration |
 
 
 <!--| [`eject`](https://docs.base44.com/developers/references/cli/commands/eject) | Create a Base44 backend project from an existing Base44 app | -->

package/dist/index.js

@@ -16889,6 +16889,11 @@ async function writeAgents(agentsDir, remoteAgents) {
 //#endregion
 //#region src/core/resources/agent/api.ts
 async function pushAgents(agents) {
+	if (agents.length === 0) return {
+		created: [],
+		updated: [],
+		deleted: []
+	};
 	const response = await getAppClient().put("agent-configs", {
 		json: agents,
 		throwHttpErrors: false
@@ -30612,25 +30617,27 @@ async function createArchive(pathToArchive, targetArchivePath) {
 * Checks if there are any resources to deploy in the project.
 *
 * @param projectData - The project configuration and resources
-* @returns true if there are entities, functions, or a configured site to deploy
+* @returns true if there are entities, functions, agents, or a configured site to deploy
 */
 function hasResourcesToDeploy(projectData) {
-	const { project, entities, functions } = projectData;
+	const { project, entities, functions, agents } = projectData;
 	const hasSite = Boolean(project.site?.outputDirectory);
 	const hasEntities = entities.length > 0;
 	const hasFunctions = functions.length > 0;
-	return hasEntities || hasFunctions || hasSite;
+	const hasAgents = agents.length > 0;
+	return hasEntities || hasFunctions || hasAgents || hasSite;
 }
 /**
-* Deploys all project resources (entities, functions, and site) to Base44.
+* Deploys all project resources (entities, functions, agents, and site) to Base44.
 *
 * @param projectData - The project configuration and resources to deploy
 * @returns The deployment result including app URL if site was deployed
 */
 async function deployAll(projectData) {
-	const { project, entities, functions } = projectData;
+	const { project, entities, functions, agents } = projectData;
 	await entityResource.push(entities);
 	await functionResource.push(functions);
+	await agentResource.push(agents);
 	if (project.site?.outputDirectory) {
 		const { appUrl } = await deploySite(resolve(project.root, project.site.outputDirectory));
 		return { appUrl };
@@ -30642,11 +30649,31 @@ async function deployAll(projectData) {
 //#region src/core/project/app-config.ts
 let cache = null;
 /**
+* Load app config from BASE44_CLI_TEST_OVERRIDES env var.
+* @returns true if override was applied, false otherwise
+*/
+function loadFromTestOverrides() {
+	const overrides = process.env.BASE44_CLI_TEST_OVERRIDES;
+	if (!overrides) return false;
+	try {
+		const data = JSON.parse(overrides);
+		if (data.appConfig?.id && data.appConfig?.projectRoot) {
+			cache = {
+				id: data.appConfig.id,
+				projectRoot: data.appConfig.projectRoot
+			};
+			return true;
+		}
+	} catch {}
+	return false;
+}
+/**
 * Initialize app config by reading from .app.jsonc.
 * Must be called before using getAppConfig().
 * @throws Error if no project found or .app.jsonc missing
 */
 async function initAppConfig() {
+	if (loadFromTestOverrides()) return;
 	if (cache) return;
 	const projectRoot = await findProjectRoot();
 	if (!projectRoot) throw new Error("No Base44 project found. Run this command from a project directory with a config.jsonc file.");
@@ -31278,7 +31305,10 @@ const theme = {
 		base44OrangeBackground: source_default.bgHex("#E86B3C"),
 		shinyOrange: source_default.hex("#FFD700"),
 		links: source_default.hex("#00D4FF"),
-		white: source_default.white
+		white: source_default.white,
+		success: source_default.green,
+		warning: source_default.yellow,
+		error: source_default.red
 	},
 	styles: {
 		header: source_default.dim,
@@ -31595,7 +31625,8 @@ const logoutCommand = new Command("logout").description("Logout from current dev
 async function pushEntitiesAction() {
 	const { entities } = await readProjectConfig();
 	if (entities.length === 0) return { outroMessage: "No entities found in project" };
-	M.info(`Found ${entities.length} entities to push`);
+	const entityNames = entities.map((e$1) => e$1.name).join(", ");
+	M.info(`Found ${entities.length} entities to push: ${entityNames}`);
 	const result = await runTask("Pushing entities to Base44", async () => {
 		return await pushEntities(entities);
 	}, {
@@ -39058,7 +39089,7 @@ var open_default = open;
 //#region src/cli/commands/project/dashboard.ts
 async function openDashboard() {
 	const dashboardUrl = getDashboardUrl();
-	await open_default(dashboardUrl);
+	if (!process.env.CI) await open_default(dashboardUrl);
 	return { outroMessage: `Dashboard opened at ${dashboardUrl}` };
 }
 const dashboardCommand = new Command("dashboard").description("Open the app dashboard in your browser").action(async () => {
@@ -39070,10 +39101,11 @@ const dashboardCommand = new Command("dashboard").description("Open the app dash
 async function deployAction$1(options) {
 	const projectData = await readProjectConfig();
 	if (!hasResourcesToDeploy(projectData)) return { outroMessage: "No resources found to deploy" };
-	const { project, entities, functions } = projectData;
+	const { project, entities, functions, agents } = projectData;
 	const summaryLines = [];
 	if (entities.length > 0) summaryLines.push(`  - ${entities.length} ${entities.length === 1 ? "entity" : "entities"}`);
 	if (functions.length > 0) summaryLines.push(`  - ${functions.length} ${functions.length === 1 ? "function" : "functions"}`);
+	if (agents.length > 0) summaryLines.push(`  - ${agents.length} ${agents.length === 1 ? "agent" : "agents"}`);
 	if (project.site?.outputDirectory) summaryLines.push(`  - Site from ${project.site.outputDirectory}`);
 	if (!options.yes) {
 		M.warn(`This will update your Base44 app with:\n${summaryLines.join("\n")}`);
@@ -39090,7 +39122,7 @@ async function deployAction$1(options) {
 	if (result.appUrl) M.message(`${theme.styles.header("App URL")}: ${theme.colors.links(result.appUrl)}`);
 	return { outroMessage: "App deployed successfully" };
 }
-const deployCommand = new Command("deploy").description("Deploy all project resources (entities, functions, and site)").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
+const deployCommand = new Command("deploy").description("Deploy all project resources (entities, functions, agents, and site)").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
 	await runCommand(() => deployAction$1(options), { requireAuth: true });
 });
 
@@ -39235,9 +39267,329 @@ const siteDeployCommand = new Command("site").description("Manage site deploymen
 	await runCommand(() => deployAction(options), { requireAuth: true });
 }));
 
+//#endregion
+//#region src/core/connectors/schema.ts
+/**
+* Response from POST /api/apps/{app_id}/external-auth/initiate
+*/
+const InitiateResponseSchema = object({
+	redirect_url: string().nullish(),
+	connection_id: string().nullish(),
+	already_authorized: boolean().nullish(),
+	other_user_email: string().nullish(),
+	error: string().nullish()
+}).transform((data) => ({
+	redirectUrl: data.redirect_url,
+	connectionId: data.connection_id,
+	alreadyAuthorized: data.already_authorized,
+	otherUserEmail: data.other_user_email,
+	error: data.error
+}));
+/**
+* Response from GET /api/apps/{app_id}/external-auth/status
+*/
+const StatusResponseSchema = object({
+	status: _enum([
+		"ACTIVE",
+		"PENDING",
+		"FAILED"
+	]),
+	account_email: string().nullish(),
+	error: string().nullish()
+}).transform((data) => ({
+	status: data.status,
+	accountEmail: data.account_email,
+	error: data.error
+}));
+/**
+* A connected integration from the list endpoint
+*/
+const ConnectorSchema = object({
+	integration_type: string(),
+	status: string(),
+	connected_at: string().nullish(),
+	account_info: object({
+		email: string().nullish(),
+		name: string().nullish()
+	}).nullish()
+}).transform((data) => ({
+	integrationType: data.integration_type,
+	status: data.status,
+	connectedAt: data.connected_at,
+	accountInfo: data.account_info
+}));
+/**
+* Response from GET /api/apps/{app_id}/external-auth/list
+*/
+const ListResponseSchema = object({ integrations: array(ConnectorSchema) });
+
+//#endregion
+//#region src/core/connectors/api.ts
+/**
+* Initiates OAuth flow for a connector integration.
+* Returns a redirect URL to open in the browser.
+*/
+async function initiateOAuth(integrationType, scopes = null) {
+	const json = await (await getAppClient().post("external-auth/initiate", { json: {
+		integration_type: integrationType,
+		scopes
+	} })).json();
+	return InitiateResponseSchema.parse(json);
+}
+/**
+* Checks the status of an OAuth connection attempt.
+*/
+async function checkOAuthStatus(integrationType, connectionId) {
+	const json = await (await getAppClient().get("external-auth/status", { searchParams: {
+		integration_type: integrationType,
+		connection_id: connectionId
+	} })).json();
+	return StatusResponseSchema.parse(json);
+}
+/**
+* Lists all connected integrations for the current app.
+*/
+async function listConnectors() {
+	const json = await (await getAppClient().get("external-auth/list")).json();
+	return ListResponseSchema.parse(json).integrations;
+}
+/**
+* Disconnects (soft delete) a connector integration.
+*/
+async function disconnectConnector(integrationType) {
+	await getAppClient().delete(`external-auth/integrations/${integrationType}`);
+}
+/**
+* Removes (hard delete) a connector integration.
+* This permanently removes the connector and cannot be undone.
+*/
+async function removeConnector(integrationType) {
+	await getAppClient().delete(`external-auth/integrations/${integrationType}/remove`);
+}
+
+//#endregion
+//#region src/core/connectors/consts.ts
+/**
+* Supported OAuth connector integrations.
+* Based on apper/backend/app/external_auth/models/constants.py
+*/
+const SUPPORTED_INTEGRATIONS = [
+	"googlecalendar",
+	"googledrive",
+	"gmail",
+	"googlesheets",
+	"googledocs",
+	"googleslides",
+	"slack",
+	"notion",
+	"salesforce",
+	"hubspot",
+	"linkedin",
+	"tiktok"
+];
+/**
+* Display names for integrations (for CLI output)
+*/
+const INTEGRATION_DISPLAY_NAMES = {
+	googlecalendar: "Google Calendar",
+	googledrive: "Google Drive",
+	gmail: "Gmail",
+	googlesheets: "Google Sheets",
+	googledocs: "Google Docs",
+	googleslides: "Google Slides",
+	slack: "Slack",
+	notion: "Notion",
+	salesforce: "Salesforce",
+	hubspot: "HubSpot",
+	linkedin: "LinkedIn",
+	tiktok: "TikTok"
+};
+function isValidIntegration(type) {
+	return SUPPORTED_INTEGRATIONS.includes(type);
+}
+function getIntegrationDisplayName(type) {
+	return INTEGRATION_DISPLAY_NAMES[type] ?? type;
+}
+
+//#endregion
+//#region src/cli/commands/connectors/utils.ts
+const OAUTH_POLL_INTERVAL_MS = 2e3;
+const OAUTH_POLL_TIMEOUT_MS = 300 * 1e3;
+/**
+* Polls for OAuth completion status.
+* Returns when status becomes ACTIVE or FAILED, or times out.
+*/
+async function waitForOAuthCompletion(integrationType, connectionId, options) {
+	let accountEmail;
+	let error;
+	try {
+		await pWaitFor(async () => {
+			const status = await checkOAuthStatus(integrationType, connectionId);
+			if (status.status === "ACTIVE") {
+				accountEmail = status.accountEmail ?? void 0;
+				return true;
+			}
+			if (status.status === "FAILED") {
+				error = status.error || "Authorization failed";
+				throw new Error(error);
+			}
+			options?.onPending?.();
+			return false;
+		}, {
+			interval: OAUTH_POLL_INTERVAL_MS,
+			timeout: OAUTH_POLL_TIMEOUT_MS
+		});
+		return {
+			success: true,
+			accountEmail
+		};
+	} catch (err) {
+		if (err instanceof Error && err.message.includes("timed out")) return {
+			success: false,
+			error: "Authorization timed out. Please try again."
+		};
+		return {
+			success: false,
+			error: error || (err instanceof Error ? err.message : "Unknown error")
+		};
+	}
+}
+/**
+* Asserts that a string is a valid integration type, throwing if not.
+*/
+function assertValidIntegrationType(type, supportedIntegrations) {
+	if (!supportedIntegrations.includes(type)) {
+		const supportedList = supportedIntegrations.join(", ");
+		throw new Error(`Unsupported connector: ${type}\nSupported connectors: ${supportedList}`);
+	}
+}
+
+//#endregion
+//#region src/cli/commands/connectors/add.ts
+async function promptForIntegrationType() {
+	const selected = await ve({
+		message: "Select an integration to connect:",
+		options: Object.entries(INTEGRATION_DISPLAY_NAMES).map(([type, displayName]) => ({
+			value: type,
+			label: displayName
+		}))
+	});
+	if (pD(selected)) {
+		xe("Operation cancelled.");
+		process.exit(0);
+	}
+	return selected;
+}
+async function pollForOAuthCompletion(integrationType, connectionId) {
+	return await runTask("Waiting for authorization...", async () => {
+		return await waitForOAuthCompletion(integrationType, connectionId);
+	}, {
+		successMessage: "Authorization completed!",
+		errorMessage: "Authorization failed"
+	});
+}
+async function addConnector(integrationType) {
+	let selectedType;
+	if (integrationType) {
+		assertValidIntegrationType(integrationType, SUPPORTED_INTEGRATIONS);
+		selectedType = integrationType;
+	} else selectedType = await promptForIntegrationType();
+	const displayName = getIntegrationDisplayName(selectedType);
+	const initiateResponse = await runTask(`Initiating ${displayName} connection...`, async () => {
+		return await initiateOAuth(selectedType);
+	}, {
+		successMessage: `${displayName} OAuth initiated`,
+		errorMessage: `Failed to initiate ${displayName} connection`
+	});
+	if (initiateResponse.alreadyAuthorized) return { outroMessage: `Already connected to ${theme.styles.bold(displayName)}` };
+	if (initiateResponse.error === "different_user" && initiateResponse.otherUserEmail) throw new Error(`This app is already connected to ${displayName} by ${initiateResponse.otherUserEmail}`);
+	if (!initiateResponse.redirectUrl || !initiateResponse.connectionId) throw new Error("Invalid response from server: missing redirect URL or connection ID");
+	M.info(`Please authorize ${displayName} at:\n${theme.colors.links(initiateResponse.redirectUrl)}`);
+	const result = await pollForOAuthCompletion(selectedType, initiateResponse.connectionId);
+	if (!result.success) throw new Error(result.error || "Authorization failed");
+	const accountInfo = result.accountEmail ? ` as ${theme.styles.bold(result.accountEmail)}` : "";
+	return { outroMessage: `Successfully connected to ${theme.styles.bold(displayName)}${accountInfo}` };
+}
+const connectorsAddCommand = new Command("add").argument("[type]", "Integration type (e.g., slack, notion, googlecalendar)").description("Connect an OAuth integration").action(async (type) => {
+	await runCommand(() => addConnector(type), {
+		requireAuth: true,
+		requireAppConfig: true
+	});
+});
+
+//#endregion
+//#region src/cli/commands/connectors/remove.ts
+function mapBackendConnectors(connectors) {
+	return connectors.filter((c$1) => isValidIntegration(c$1.integrationType)).map((c$1) => ({
+		type: c$1.integrationType,
+		displayName: getIntegrationDisplayName(c$1.integrationType),
+		accountEmail: (c$1.accountInfo?.email || c$1.accountInfo?.name) ?? void 0
+	}));
+}
+function validateConnectorType(type, connectors) {
+	if (!isValidIntegration(type)) throw new Error(`Invalid connector type: ${type}`);
+	const connector = connectors.find((c$1) => c$1.type === type);
+	if (!connector) throw new Error(`No ${getIntegrationDisplayName(type)} connector found`);
+	return connector;
+}
+async function promptForConnectorToRemove(connectors) {
+	const selected = await ve({
+		message: "Select a connector to remove:",
+		options: connectors.map((c$1) => {
+			let label = c$1.displayName;
+			if (c$1.accountEmail) label += ` (${c$1.accountEmail})`;
+			return {
+				value: c$1.type,
+				label
+			};
+		})
+	});
+	if (pD(selected)) {
+		xe("Operation cancelled.");
+		process.exit(0);
+	}
+	return connectors.find((c$1) => c$1.type === selected);
+}
+async function removeConnectorCommand(integrationType, options = {}) {
+	const isHardDelete = options.hard === true;
+	const connectors = mapBackendConnectors(await runTask("Fetching connectors...", async () => listConnectors(), {
+		successMessage: "Connectors loaded",
+		errorMessage: "Failed to fetch connectors"
+	}));
+	if (connectors.length === 0) return { outroMessage: "No connectors to remove" };
+	const selectedConnector = integrationType ? validateConnectorType(integrationType, connectors) : await promptForConnectorToRemove(connectors);
+	const displayName = selectedConnector.displayName;
+	const accountInfo = selectedConnector.accountEmail ? ` (${selectedConnector.accountEmail})` : "";
+	if (!options.yes) {
+		const shouldRemove = await ye({ message: `${isHardDelete ? "Permanently remove" : "Remove"} ${displayName}${accountInfo}?` });
+		if (pD(shouldRemove) || !shouldRemove) {
+			xe("Operation cancelled.");
+			process.exit(0);
+		}
+	}
+	await runTask(`Removing ${displayName}...`, async () => {
+		if (isHardDelete) await removeConnector(selectedConnector.type);
+		else await disconnectConnector(selectedConnector.type);
+	}, {
+		successMessage: `${displayName} removed`,
+		errorMessage: `Failed to remove ${displayName}`
+	});
+	return { outroMessage: `Successfully removed ${theme.styles.bold(displayName)}` };
+}
+const connectorsRemoveCommand = new Command("remove").argument("[type]", "Integration type to remove (e.g., slack, notion)").option("--hard", "Permanently remove the connector (cannot be undone)").option("-y, --yes", "Skip confirmation prompt").description("Remove an OAuth integration").action(async (type, options) => {
+	await runCommand(() => removeConnectorCommand(type, options), {
+		requireAuth: true,
+		requireAppConfig: true
+	});
+});
+
+//#endregion
+//#region src/cli/commands/connectors/index.ts
+const connectorsCommand = new Command("connectors").description("Manage OAuth connectors").addCommand(connectorsAddCommand).addCommand(connectorsRemoveCommand);
+
 //#endregion
 //#region package.json
-var version = "0.0.24";
+var version = "0.0.25";
 
 //#endregion
 //#region src/cli/program.ts
@@ -39255,6 +39607,7 @@ program.addCommand(entitiesPushCommand);
 program.addCommand(agentsCommand);
 program.addCommand(functionsDeployCommand);
 program.addCommand(siteDeployCommand);
+program.addCommand(connectorsCommand);
 
 //#endregion
 export { CLIExitError, program };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.24-pr.146.e5ee77a",
+  "version": "0.0.25-pr.104.089a20e",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "dev": "./bin/dev.js",
     "start": "./bin/run.js",
     "clean": "rm -rf dist",
-    "lint": "eslint src",
+    "lint": "eslint src tests",
     "test": "vitest run",
     "test:watch": "vitest"
   },
@@ -52,9 +52,12 @@
     "json5": "^2.2.3",
     "ky": "^1.14.2",
     "lodash.kebabcase": "^4.1.1",
+    "msw": "^2.12.7",
     "open": "^11.0.0",
     "p-wait-for": "^6.0.0",
+    "strip-ansi": "^7.1.2",
     "tar": "^7.5.4",
+    "tmp-promise": "^3.0.3",
     "tsdown": "^0.12.4",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
@@ -64,5 +67,8 @@
   },
   "engines": {
     "node": ">=20.19.0"
+  },
+  "optionalDependencies": {
+    "@rollup/rollup-linux-x64-gnu": "^4.56.0"
   }
 }