@base44-preview/cli 0.0.15-pr.97.e56bc81 → 0.0.15-pr.99.e192f83

package/dist/cli/index.js

@@ -7900,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
@@ -16706,12 +16719,6 @@ const ProjectConfigSchema = object({
 });
 const AppConfigSchema = object({ id: string().min(1, "id cannot be empty") });
 const CreateProjectResponseSchema = looseObject({ id: string() });
-const AppSchema = looseObject({
-	id: string(),
-	name: string(),
-	has_source_code: boolean()
-});
-const AppsResponseSchema = array(AppSchema);
 
 //#endregion
 //#region src/core/project/config.ts
@@ -16796,13 +16803,6 @@ async function createProject(projectName, description) {
 	} });
 	return { projectId: CreateProjectResponseSchema.parse(await response.json()).id };
 }
-async function fetchApps() {
-	const response = await base44Client.get("api/apps");
-	return AppsResponseSchema.parse(await response.json());
-}
-async function fetchLinkableApps() {
-	return (await fetchApps()).filter((app) => !app.has_source_code);
-}
 
 //#endregion
 //#region node_modules/ejs/lib/utils.js
@@ -31005,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,
@@ -38756,33 +38759,20 @@ const deployCommand = new Command("deploy").description("Deploy all project reso
 //#endregion
 //#region src/cli/commands/project/link.ts
 function validateNonInteractiveFlags(command) {
-	const { create: create$1, existing, name: name$1 } = command.opts();
-	if (create$1 && existing) command.error("--create and --existing cannot be used together");
+	const { create: create$1, name: name$1 } = command.opts();
 	if (create$1 && !name$1) command.error("--name is required when using --create");
 }
-async function promptForLinkAction(linkableApps) {
+async function promptForProjectDetails() {
 	const actionOptions = [{
 		value: "create",
 		label: "Create a new project",
 		hint: "Create a new Base44 project and link it"
 	}];
-	if (linkableApps.length > 0) actionOptions.push({
-		value: "choose",
-		label: "Link an existing project",
-		hint: `Choose from ${linkableApps.length} available project${linkableApps.length === 1 ? "" : "s"}`
-	});
-	const action = await ve({
-		message: "How would you like to link this project?",
-		options: actionOptions
-	});
-	if (pD(action)) {
-		xe("Operation cancelled.");
-		process.exit(0);
-	}
-	return action;
-}
-async function promptForNewProjectDetails() {
 	const result = await Ce({
+		action: () => ve({
+			message: "How would you like to link this project?",
+			options: actionOptions
+		}),
 		name: () => {
 			return he({
 				message: "What is the name of your project?",
@@ -38802,63 +38792,14 @@ async function promptForNewProjectDetails() {
 		description: result.description ? result.description.trim() : void 0
 	};
 }
-async function promptForExistingApp(linkableApps) {
-	const selectedApp = await ve({
-		message: "Choose a project to link",
-		options: linkableApps.map((app) => ({
-			value: app,
-			label: app.name
-		}))
-	});
-	if (pD(selectedApp)) {
-		xe("Operation cancelled.");
-		process.exit(0);
-	}
-	return selectedApp;
-}
 async function link(options) {
 	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.");
 	if (await appConfigExists(projectRoot.root)) throw new Error("Project is already linked. An .app.jsonc file with the appId already exists.");
-	if (options.existing) {
-		await writeAppConfig(projectRoot.root, options.existing);
-		setAppConfig({
-			id: options.existing,
-			projectRoot: projectRoot.root
-		});
-		M.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(options.existing))}`);
-		return { outroMessage: "Project linked" };
-	}
-	if (options.create) {
-		const { projectId: projectId$1 } = await runTask("Creating project on Base44...", async () => {
-			return await createProject(options.name.trim(), options.description?.trim());
-		}, {
-			successMessage: "Project created successfully",
-			errorMessage: "Failed to create project"
-		});
-		await writeAppConfig(projectRoot.root, projectId$1);
-		setAppConfig({
-			id: projectId$1,
-			projectRoot: projectRoot.root
-		});
-		M.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(projectId$1))}`);
-		return { outroMessage: "Project linked" };
-	}
-	const linkableApps = await runTask("Fetching your projects...", async () => fetchLinkableApps(), {
-		successMessage: `Found ${theme.colors.base44Orange("projects")} available for linking`,
-		errorMessage: "Failed to fetch projects"
-	});
-	if (await promptForLinkAction(linkableApps) === "choose") {
-		const selectedApp = await promptForExistingApp(linkableApps);
-		await writeAppConfig(projectRoot.root, selectedApp.id);
-		setAppConfig({
-			id: selectedApp.id,
-			projectRoot: projectRoot.root
-		});
-		M.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(selectedApp.id))}`);
-		return { outroMessage: "Project linked" };
-	}
-	const { name: name$1, description } = await promptForNewProjectDetails();
+	const { name: name$1, description } = options.create ? {
+		name: options.name.trim(),
+		description: options.description?.trim()
+	} : await promptForProjectDetails();
 	const { projectId } = await runTask("Creating project on Base44...", async () => {
 		return await createProject(name$1, description);
 	}, {
@@ -38873,7 +38814,7 @@ async function link(options) {
 	M.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(projectId))}`);
 	return { outroMessage: "Project linked" };
 }
-const linkCommand = new Command("link").description("Link a local project to a Base44 project").option("-c, --create", "Create a new project (skip selection prompt)").option("-e, --existing <id>", "Link to an existing project by ID (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").hook("preAction", validateNonInteractiveFlags).action(async (options) => {
+const linkCommand = new Command("link").description("Link a local project to a Base44 project").option("-c, --create", "Create a new project (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").hook("preAction", validateNonInteractiveFlags).action(async (options) => {
 	await runCommand(() => link(options), {
 		requireAuth: true,
 		requireAppConfig: false
@@ -38901,6 +38842,390 @@ 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()
+});
+/**
+* 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}`);
+	}
+}
+
+//#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.account_email;
+					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 formatDate(dateString) {
+	if (!dateString) return "-";
+	try {
+		return new Date(dateString).toLocaleDateString("en-US", {
+			year: "numeric",
+			month: "short",
+			day: "numeric"
+		});
+	} catch {
+		return dateString;
+	}
+}
+function formatStatus(status) {
+	const normalized = status.toLowerCase();
+	if (normalized === "active" || normalized === "connected") return theme.colors.success("● active");
+	if (normalized === "expired") return theme.colors.warning("● expired");
+	if (normalized === "failed" || normalized === "disconnected") return theme.colors.error("● disconnected");
+	return 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();
+	console.log(theme.styles.bold("Connected Integrations:"));
+	console.log();
+	const headers = [
+		"Type",
+		"Account",
+		"Status",
+		"Connected"
+	];
+	const colWidths = [
+		20,
+		30,
+		15,
+		15
+	];
+	const headerRow = headers.map((h$2, i$1) => h$2.padEnd(colWidths[i$1])).join(" ");
+	console.log(theme.styles.dim(headerRow));
+	console.log(theme.styles.dim("─".repeat(headerRow.length)));
+	for (const connector of connectors) {
+		const type = getIntegrationDisplayName(connector.integrationType).padEnd(colWidths[0]);
+		const account = (connector.accountInfo?.email || connector.accountInfo?.name || "-").padEnd(colWidths[1]);
+		const status = formatStatus(connector.status);
+		const connected = formatDate(connector.connectedAt).padEnd(colWidths[3]);
+		console.log(`${type} ${account} ${status.padEnd(colWidths[2] + 10)} ${connected}`);
+	}
+	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) {
+	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 shouldRemove = await ye({
+		message: `Disconnect ${displayName}${connector?.accountInfo?.email ? ` (${connector.accountInfo.email})` : ""}?`,
+		initialValue: false
+	});
+	if (pD(shouldRemove) || !shouldRemove) return { outroMessage: "Cancelled" };
+	await runTask(`Disconnecting ${displayName}...`, async () => {
+		await disconnectConnector(selectedType);
+	}, {
+		successMessage: `${displayName} disconnected`,
+		errorMessage: `Failed to disconnect ${displayName}`
+	});
+	return { outroMessage: `Successfully disconnected ${theme.styles.bold(displayName)}` };
+}
+const connectorsRemoveCommand = new Command("connectors:remove").argument("[type]", "Integration type to remove (e.g., slack, notion)").description("Disconnect an OAuth integration").action(async (type) => {
+	await runCommand(() => removeConnectorCommand(type), {
+		requireAuth: true,
+		requireAppConfig: true
+	});
+});
+
 //#endregion
 //#region package.json
 var version = "0.0.15";
@@ -38920,6 +39245,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.97.e56bc81",
+  "version": "0.0.15-pr.99.e192f83",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "main": "./dist/cli/index.js",