@base44-preview/cli 0.0.15-pr.99.e192f83 → 0.0.16-pr.107.c96948c

package/README.md

@@ -43,9 +43,31 @@ base44 deploy
 | Command | Description |
 |---------|-------------|
 | `base44 create` | Create a new Base44 project from a template |
-| `base44 link` | Link an existing local project to Base44 |
+| `base44 link` | Link a local project to Base44 (create new or link existing) |
 | `base44 dashboard` | Open the app dashboard in your browser |
 
+#### Link Command Options
+
+The `link` command supports both creating new projects and linking to existing ones:
+
+```bash
+# Interactive mode - choose to create new or link existing
+base44 link
+
+# Create a new project (non-interactive)
+base44 link --create --name "my-app" --description "My app description"
+
+# Link to an existing project by ID (non-interactive)
+base44 link --projectId <app-id>
+```
+
+| Option | Description |
+|--------|-------------|
+| `-c, --create` | Create a new project (skip selection prompt) |
+| `-n, --name <name>` | Project name (required with --create) |
+| `-d, --description <desc>` | Project description (optional) |
+| `-p, --projectId <id>` | Link to an existing project by ID (skips selection prompt) |
+
 ### Deployment
 
 | Command | Description |

package/dist/cli/index.js

@@ -7900,19 +7900,6 @@ 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
@@ -16719,6 +16706,13 @@ const ProjectConfigSchema = object({
 });
 const AppConfigSchema = object({ id: string().min(1, "id cannot be empty") });
 const CreateProjectResponseSchema = looseObject({ id: string() });
+const ProjectSchema = object({
+	id: string(),
+	name: string(),
+	userDescription: string().optional(),
+	isManagedSourceCode: boolean().optional()
+});
+const ProjectsResponseSchema = array(ProjectSchema);
 
 //#endregion
 //#region src/core/project/config.ts
@@ -16803,6 +16797,13 @@ async function createProject(projectName, description) {
 	} });
 	return { projectId: CreateProjectResponseSchema.parse(await response.json()).id };
 }
+async function listProjects() {
+	const response = await base44Client.get(`api/apps`, { searchParams: {
+		"sort": "-updated_date",
+		"fields": "id,name,user_description,is_managed_source_code"
+	} });
+	return ProjectsResponseSchema.parse(await response.json());
+}
 
 //#endregion
 //#region node_modules/ejs/lib/utils.js
@@ -31005,10 +31006,7 @@ const theme = {
 		base44OrangeBackground: source_default.bgHex("#E86B3C"),
 		shinyOrange: source_default.hex("#FFD700"),
 		links: source_default.hex("#00D4FF"),
-		white: source_default.white,
-		success: source_default.green,
-		warning: source_default.yellow,
-		error: source_default.red
+		white: source_default.white
 	},
 	styles: {
 		header: source_default.dim,
@@ -38759,20 +38757,33 @@ 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, name: name$1 } = command.opts();
+	const { create: create$1, name: name$1, projectId } = command.opts();
+	if (create$1 && projectId) command.error("--create and --projectId cannot be used together");
 	if (create$1 && !name$1) command.error("--name is required when using --create");
 }
-async function promptForProjectDetails() {
+async function promptForLinkAction() {
 	const actionOptions = [{
 		value: "create",
 		label: "Create a new project",
 		hint: "Create a new Base44 project and link it"
 	}];
+	actionOptions.push({
+		value: "choose",
+		label: "Link an existing project",
+		hint: `Choose from one of your available projects previously created by the Base44 CLI`
+	});
+	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?",
@@ -38792,29 +38803,71 @@ async function promptForProjectDetails() {
 		description: result.description ? result.description.trim() : void 0
 	};
 }
+async function promptForExistingProject(linkableProjects) {
+	const selectedProject = await ve({
+		message: "Choose a project to link",
+		options: linkableProjects.map((project) => ({
+			value: project,
+			label: project.name
+		}))
+	});
+	if (pD(selectedProject)) {
+		xe("Operation cancelled.");
+		process.exit(0);
+	}
+	return selectedProject;
+}
 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.");
-	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);
-	}, {
-		successMessage: "Project created successfully",
-		errorMessage: "Failed to create project"
-	});
-	await writeAppConfig(projectRoot.root, projectId);
-	setAppConfig({
-		id: projectId,
-		projectRoot: projectRoot.root
-	});
-	M.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(projectId))}`);
+	let finalProjectId;
+	const action = options.projectId ? "choose" : options.create ? "create" : await promptForLinkAction();
+	if (action === "choose") {
+		const linkableProjects = (await runTask("Fetching projects...", async () => listProjects(), {
+			successMessage: "Projects fetched",
+			errorMessage: "Failed to fetch projects"
+		})).filter((p$1) => p$1.isManagedSourceCode !== true);
+		if (!linkableProjects.length) return { outroMessage: "No projects available for linking" };
+		let projectId;
+		if (options.projectId) {
+			if (!linkableProjects.find((p$1) => p$1.id === options.projectId)) throw new Error(`Project with ID "${options.projectId}" not found or not available for linking.`);
+			projectId = options.projectId;
+		} else projectId = (await promptForExistingProject(linkableProjects)).id;
+		await runTask("Linking project...", async () => {
+			await writeAppConfig(projectRoot.root, projectId);
+			setAppConfig({
+				id: projectId,
+				projectRoot: projectRoot.root
+			});
+		}, {
+			successMessage: "Project linked successfully",
+			errorMessage: "Failed to link project"
+		});
+		finalProjectId = projectId;
+	}
+	if (action === "create") {
+		const { name: name$1, description } = options.create ? {
+			name: options.name.trim(),
+			description: options.description?.trim()
+		} : await promptForNewProjectDetails();
+		const { projectId } = await runTask("Creating project on Base44...", async () => {
+			return await createProject(name$1, description);
+		}, {
+			successMessage: "Project created successfully",
+			errorMessage: "Failed to create project"
+		});
+		await writeAppConfig(projectRoot.root, projectId);
+		setAppConfig({
+			id: projectId,
+			projectRoot: projectRoot.root
+		});
+		finalProjectId = projectId;
+	}
+	M.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalProjectId))}`);
 	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("-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 (create new or link existing)").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").option("-p, --projectId <id>", "Project ID to link to an existing project (skips selection prompt)").hook("preAction", validateNonInteractiveFlags).action(async (options) => {
 	await runCommand(() => link(options), {
 		requireAuth: true,
 		requireAppConfig: false
@@ -38842,393 +38895,9 @@ 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";
+var version = "0.0.16";
 
 //#endregion
 //#region src/cli/index.ts
@@ -39245,9 +38914,6 @@ 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.99.e192f83",
+  "version": "0.0.16-pr.107.c96948c",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "main": "./dist/cli/index.js",