@base44-preview/cli 0.0.15-pr.98.72adf3c → 0.0.15-pr.99.05b68cd

package/dist/cli/index.js

@@ -4547,6 +4547,7 @@ const string$1 = (params) => {
 };
 const integer = /^-?\d+$/;
 const number$1 = /^-?\d+(?:\.\d+)?$/;
+const boolean$1 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 
@@ -5325,6 +5326,24 @@ const $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst,
 	$ZodCheckNumberFormat.init(inst, def);
 	$ZodNumber.init(inst, def);
 });
+const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.pattern = boolean$1;
+	inst._zod.parse = (payload, _ctx) => {
+		if (def.coerce) try {
+			payload.value = Boolean(payload.value);
+		} catch (_$2) {}
+		const input = payload.value;
+		if (typeof input === "boolean") return payload;
+		payload.issues.push({
+			expected: "boolean",
+			code: "invalid_type",
+			input,
+			inst
+		});
+		return payload;
+	};
+});
 const $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload) => payload;
@@ -6379,6 +6398,13 @@ function _int(Class, params) {
 	});
 }
 /* @__NO_SIDE_EFFECTS__ */
+function _boolean(Class, params) {
+	return new Class({
+		type: "boolean",
+		...normalizeParams(params)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _unknown(Class) {
 	return new Class({ type: "unknown" });
 }
@@ -6949,6 +6975,9 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 	}
 	if (typeof multipleOf === "number") json.multipleOf = multipleOf;
 };
+const booleanProcessor = (_schema, _ctx, json, _params) => {
+	json.type = "boolean";
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
@@ -7472,6 +7501,14 @@ const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, d
 function int(params) {
 	return _int(ZodNumberFormat, params);
 }
+const ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
+	$ZodBoolean.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
+});
+function boolean(params) {
+	return _boolean(ZodBoolean, params);
+}
 const ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
 	$ZodUnknown.init(inst, def);
 	ZodType.init(inst, def);
@@ -7863,6 +7900,19 @@ var AuthValidationError = class extends Error {
 		this.name = "AuthValidationError";
 	}
 };
+var ConnectorApiError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "ConnectorApiError";
+	}
+};
+var ConnectorValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ConnectorValidationError";
+	}
+};
 
 //#endregion
 //#region src/core/consts.ts
@@ -30955,7 +31005,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,
@@ -38789,6 +38842,374 @@ 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().optional(),
+	connection_id: string().optional(),
+	already_authorized: boolean().optional(),
+	other_user_email: string().optional(),
+	error: string().optional()
+});
+/**
+* Response from GET /api/apps/{app_id}/external-auth/status
+*/
+const StatusResponseSchema = object({
+	status: _enum([
+		"ACTIVE",
+		"PENDING",
+		"FAILED"
+	]),
+	account_email: string().optional(),
+	error: string().optional()
+}).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().optional(),
+	account_info: object({
+		email: string().optional(),
+		name: string().optional()
+	}).optional()
+}).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) });
+/**
+* Generic API error response
+*/
+const ApiErrorSchema = object({
+	error: string(),
+	detail: string().optional()
+});
+
+//#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 response = await getAppClient().post("external-auth/initiate", {
+		json: {
+			integration_type: integrationType,
+			scopes
+		},
+		throwHttpErrors: false
+	});
+	const json = await response.json();
+	if (!response.ok) {
+		const errorResult = ApiErrorSchema.safeParse(json);
+		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
+		throw new ConnectorApiError(`Failed to initiate OAuth: ${response.status} ${response.statusText}`);
+	}
+	const result = InitiateResponseSchema.safeParse(json);
+	if (!result.success) throw new ConnectorValidationError(`Invalid initiate response from server: ${result.error.message}`);
+	return result.data;
+}
+/**
+* Checks the status of an OAuth connection attempt.
+*/
+async function checkOAuthStatus(integrationType, connectionId) {
+	const response = await getAppClient().get("external-auth/status", {
+		searchParams: {
+			integration_type: integrationType,
+			connection_id: connectionId
+		},
+		throwHttpErrors: false
+	});
+	const json = await response.json();
+	if (!response.ok) {
+		const errorResult = ApiErrorSchema.safeParse(json);
+		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
+		throw new ConnectorApiError(`Failed to check OAuth status: ${response.status} ${response.statusText}`);
+	}
+	const result = StatusResponseSchema.safeParse(json);
+	if (!result.success) throw new ConnectorValidationError(`Invalid status response from server: ${result.error.message}`);
+	return result.data;
+}
+/**
+* Lists all connected integrations for the current app.
+*/
+async function listConnectors() {
+	const response = await getAppClient().get("external-auth/list", { throwHttpErrors: false });
+	const json = await response.json();
+	if (!response.ok) {
+		const errorResult = ApiErrorSchema.safeParse(json);
+		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
+		throw new ConnectorApiError(`Failed to list connectors: ${response.status} ${response.statusText}`);
+	}
+	const result = ListResponseSchema.safeParse(json);
+	if (!result.success) throw new ConnectorValidationError(`Invalid list response from server: ${result.error.message}`);
+	return result.data.integrations;
+}
+/**
+* Disconnects (soft delete) a connector integration.
+*/
+async function disconnectConnector(integrationType) {
+	const response = await getAppClient().delete(`external-auth/integrations/${integrationType}`, { throwHttpErrors: false });
+	if (!response.ok) {
+		const json = await response.json();
+		const errorResult = ApiErrorSchema.safeParse(json);
+		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
+		throw new ConnectorApiError(`Failed to disconnect connector: ${response.status} ${response.statusText}`);
+	}
+}
+/**
+* Removes (hard delete) a connector integration.
+* This permanently removes the connector and cannot be undone.
+*/
+async function removeConnector(integrationType) {
+	const response = await getAppClient().delete(`external-auth/integrations/${integrationType}/remove`, { throwHttpErrors: false });
+	if (!response.ok) {
+		const json = await response.json();
+		const errorResult = ApiErrorSchema.safeParse(json);
+		if (errorResult.success) throw new ConnectorApiError(errorResult.data.error);
+		throw new ConnectorApiError(`Failed to remove connector: ${response.status} ${response.statusText}`);
+	}
+}
+
+//#endregion
+//#region src/core/connectors/constants.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) {
+	if (isValidIntegration(type)) return INTEGRATION_DISPLAY_NAMES[type];
+	return type;
+}
+
+//#endregion
+//#region src/cli/commands/connectors/add.ts
+const POLL_INTERVAL_MS = 2e3;
+const POLL_TIMEOUT_MS = 300 * 1e3;
+async function promptForIntegrationType() {
+	const selected = await ve({
+		message: "Select an integration to connect:",
+		options: SUPPORTED_INTEGRATIONS.map((type) => ({
+			value: type,
+			label: getIntegrationDisplayName(type)
+		}))
+	});
+	if (pD(selected)) return null;
+	return selected;
+}
+async function waitForOAuthCompletion(integrationType, connectionId) {
+	let accountEmail;
+	let error;
+	try {
+		await runTask("Waiting for authorization...", async (updateMessage) => {
+			await pWaitFor(async () => {
+				const status = await checkOAuthStatus(integrationType, connectionId);
+				if (status.status === "ACTIVE") {
+					accountEmail = status.accountEmail;
+					return true;
+				}
+				if (status.status === "FAILED") {
+					error = status.error || "Authorization failed";
+					throw new Error(error);
+				}
+				updateMessage("Waiting for authorization in browser...");
+				return false;
+			}, {
+				interval: POLL_INTERVAL_MS,
+				timeout: POLL_TIMEOUT_MS
+			});
+		}, {
+			successMessage: "Authorization completed!",
+			errorMessage: "Authorization failed"
+		});
+		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")
+		};
+	}
+}
+async function addConnector(integrationType) {
+	let selectedType;
+	if (!integrationType) {
+		const prompted = await promptForIntegrationType();
+		if (!prompted) return { outroMessage: "Cancelled" };
+		selectedType = prompted;
+	} else {
+		if (!isValidIntegration(integrationType)) {
+			const supportedList = SUPPORTED_INTEGRATIONS.join(", ");
+			throw new Error(`Unsupported connector: ${integrationType}\nSupported connectors: ${supportedList}`);
+		}
+		selectedType = integrationType;
+	}
+	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.already_authorized) return { outroMessage: `Already connected to ${theme.styles.bold(displayName)}` };
+	if (initiateResponse.error === "different_user" && initiateResponse.other_user_email) throw new Error(`This app is already connected to ${displayName} by ${initiateResponse.other_user_email}`);
+	if (!initiateResponse.redirect_url || !initiateResponse.connection_id) throw new Error("Invalid response from server: missing redirect URL or connection ID");
+	M.info(`Opening browser for ${displayName} authorization...`);
+	await open_default(initiateResponse.redirect_url);
+	const result = await waitForOAuthCompletion(selectedType, initiateResponse.connection_id);
+	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("connectors: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/list.ts
+function formatConnectorLine(connector) {
+	const name$1 = getIntegrationDisplayName(connector.integrationType);
+	const account = connector.accountInfo?.email || connector.accountInfo?.name;
+	const status = connector.status.toLowerCase();
+	return `${status === "active" ? theme.colors.success("●") : theme.colors.error("○")} ${name$1}${account ? ` - ${account}` : ""}${status !== "active" ? theme.styles.dim(` (${status})`) : ""}`;
+}
+async function listConnectorsCommand() {
+	const connectors = await runTask("Fetching connectors...", async () => {
+		return await listConnectors();
+	}, {
+		successMessage: "Connectors loaded",
+		errorMessage: "Failed to fetch connectors"
+	});
+	if (connectors.length === 0) {
+		M.info("No connectors configured for this app.");
+		M.info(`Run ${theme.styles.bold("base44 connectors:add")} to connect an integration.`);
+		return { outroMessage: "" };
+	}
+	console.log();
+	for (const connector of connectors) console.log(formatConnectorLine(connector));
+	console.log();
+	return { outroMessage: `${connectors.length} connector${connectors.length === 1 ? "" : "s"} configured` };
+}
+const connectorsListCommand = new Command("connectors:list").description("List all connected OAuth integrations").action(async () => {
+	await runCommand(listConnectorsCommand, {
+		requireAuth: true,
+		requireAppConfig: true
+	});
+});
+
+//#endregion
+//#region src/cli/commands/connectors/remove.ts
+async function promptForConnectorToRemove(connectors) {
+	const selected = await ve({
+		message: "Select a connector to remove:",
+		options: connectors.map((c$1) => ({
+			value: c$1.integrationType,
+			label: `${getIntegrationDisplayName(c$1.integrationType)}${c$1.accountInfo?.email ? ` (${c$1.accountInfo.email})` : ""}`
+		}))
+	});
+	if (pD(selected)) return null;
+	return selected;
+}
+async function removeConnectorCommand(integrationType, options = {}) {
+	const isHardDelete = options.hard === true;
+	const connectors = await runTask("Fetching connectors...", async () => {
+		return await listConnectors();
+	}, {
+		successMessage: "Connectors loaded",
+		errorMessage: "Failed to fetch connectors"
+	});
+	if (connectors.length === 0) return { outroMessage: "No connectors to remove" };
+	let selectedType;
+	if (!integrationType) {
+		const prompted = await promptForConnectorToRemove(connectors);
+		if (!prompted) return { outroMessage: "Cancelled" };
+		selectedType = prompted;
+	} else {
+		if (!isValidIntegration(integrationType)) throw new Error(`Invalid connector type: ${integrationType}`);
+		if (!connectors.some((c$1) => c$1.integrationType === integrationType)) throw new Error(`No ${getIntegrationDisplayName(integrationType)} connector found for this app`);
+		selectedType = integrationType;
+	}
+	const displayName = getIntegrationDisplayName(selectedType);
+	const connector = connectors.find((c$1) => c$1.integrationType === selectedType);
+	const accountInfo = connector?.accountInfo?.email ? ` (${connector.accountInfo.email})` : "";
+	const shouldRemove = await ye({
+		message: `${isHardDelete ? "Permanently remove" : "Disconnect"} ${displayName}${accountInfo}?`,
+		initialValue: false
+	});
+	if (pD(shouldRemove) || !shouldRemove) return { outroMessage: "Cancelled" };
+	await runTask(isHardDelete ? `Removing ${displayName}...` : `Disconnecting ${displayName}...`, async () => {
+		if (isHardDelete) await removeConnector(selectedType);
+		else await disconnectConnector(selectedType);
+	}, {
+		successMessage: isHardDelete ? `${displayName} removed` : `${displayName} disconnected`,
+		errorMessage: isHardDelete ? `Failed to remove ${displayName}` : `Failed to disconnect ${displayName}`
+	});
+	return { outroMessage: `Successfully ${isHardDelete ? "removed" : "disconnected"} ${theme.styles.bold(displayName)}` };
+}
+const connectorsRemoveCommand = new Command("connectors:remove").argument("[type]", "Integration type to remove (e.g., slack, notion)").option("--hard", "Permanently remove the connector (cannot be undone)").description("Disconnect an OAuth integration").action(async (type, options) => {
+	await runCommand(() => removeConnectorCommand(type, options), {
+		requireAuth: true,
+		requireAppConfig: true
+	});
+});
+
 //#endregion
 //#region package.json
 var version = "0.0.15";
@@ -38808,6 +39229,9 @@ program.addCommand(linkCommand);
 program.addCommand(entitiesPushCommand);
 program.addCommand(functionsDeployCommand);
 program.addCommand(siteDeployCommand);
+program.addCommand(connectorsAddCommand);
+program.addCommand(connectorsListCommand);
+program.addCommand(connectorsRemoveCommand);
 program.parse();
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.15-pr.98.72adf3c",
+  "version": "0.0.15-pr.99.05b68cd",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "main": "./dist/cli/index.js",