@base44-preview/cli 0.0.15-pr.99.a46f627 → 0.0.15-pr.99.a90e72b

package/README.md

@@ -72,29 +72,45 @@ base44 deploy
 
 ### Connectors
 
-Manage OAuth integrations to connect your app with external services.
+Manage OAuth integrations to connect your app with external services. Connectors are tracked in a local `connectors.jsonc` file and synced with the backend.
 
 | Command | Description |
 |---------|-------------|
-| `base44 connectors:add [type]` | Connect an OAuth integration (opens browser for auth) |
-| `base44 connectors:list` | List all connected integrations |
-| `base44 connectors:remove [type]` | Disconnect an integration |
+| `base44 connectors:add [type]` | Add and connect an OAuth integration |
+| `base44 connectors:list` | List all connectors (local and connected) |
+| `base44 connectors:push` | Connect all pending integrations from local config |
+| `base44 connectors:remove [type]` | Remove an integration |
 | `base44 connectors:remove [type] --hard` | Permanently remove an integration |
 
 **Supported integrations:** Slack, Google Calendar, Google Drive, Gmail, Google Sheets, Google Docs, Google Slides, Notion, Salesforce, HubSpot, LinkedIn, TikTok
 
-**Example:**
+**Example workflow:**
 ```bash
-# Connect Slack (opens browser for OAuth)
+# Add connectors (saves to connectors.jsonc and opens OAuth)
 base44 connectors:add slack
+base44 connectors:add googlecalendar
 
-# List connected integrations
+# List connectors showing local vs connected status
 base44 connectors:list
+# Output:
+# ● Slack - user@example.com
+# ○ Google Calendar (not connected)
 
-# Disconnect Slack
+# Connect all pending integrations
+base44 connectors:push
+
+# Remove a connector
 base44 connectors:remove slack
 ```
 
+**Local configuration** (`base44/connectors.jsonc`):
+```jsonc
+{
+  "slack": {},
+  "googlecalendar": { "scopes": ["calendar.readonly"] }
+}
+```
+
 Once connected, use the SDK's `connectors.getAccessToken()` to retrieve tokens:
 ```javascript
 const token = await base44.connectors.getAccessToken("slack");

package/dist/cli/index.js

@@ -5819,6 +5819,97 @@ function handleTupleResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject$1(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[key] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number")) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result$1) => {
+					if (result$1.issues.length) payload.issues.push(...prefixIssues(key, result$1.issues));
+					payload.value[keyResult.value] = result$1.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -7109,6 +7200,39 @@ const tupleProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 };
+const recordProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "object";
+	const keyType = def.keyType;
+	const patterns = keyType._zod.bag?.patterns;
+	if (def.mode === "loose" && patterns && patterns.size > 0) {
+		const valueSchema = process$2(def.valueType, ctx, {
+			...params,
+			path: [
+				...params.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		json.patternProperties = {};
+		for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
+	} else {
+		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$2(def.keyType, ctx, {
+			...params,
+			path: [...params.path, "propertyNames"]
+		});
+		json.additionalProperties = process$2(def.valueType, ctx, {
+			...params,
+			path: [...params.path, "additionalProperties"]
+		});
+	}
+	const keyValues = keyType._zod.values;
+	if (keyValues) {
+		const validKeyValues = [...keyValues].filter((v$1) => typeof v$1 === "string" || typeof v$1 === "number");
+		if (validKeyValues.length > 0) json.required = validKeyValues;
+	}
+};
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const inner = process$2(def.innerType, ctx, params);
@@ -7638,6 +7762,21 @@ function tuple(items, _paramsOrRest, _params) {
 		...normalizeParams(params)
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -39030,10 +39169,90 @@ function getIntegrationDisplayName(type) {
 	return type;
 }
 
+//#endregion
+//#region src/core/connectors/config.ts
+/**
+* Schema for a single connector configuration
+*/
+const ConnectorConfigSchema = object({ scopes: array(string()).optional() });
+/**
+* Schema for the connectors.jsonc file
+*/
+const ConnectorsFileSchema = record(string(), ConnectorConfigSchema);
+const CONNECTORS_FILE_PATTERNS = [`${PROJECT_SUBDIR}/connectors.${CONFIG_FILE_EXTENSION_GLOB}`, `connectors.${CONFIG_FILE_EXTENSION_GLOB}`];
+/**
+* Find the connectors config file in the project
+*/
+async function findConnectorsFile(startPath) {
+	return (await globby(CONNECTORS_FILE_PATTERNS, {
+		cwd: startPath || process.cwd(),
+		absolute: true
+	}))[0] ?? null;
+}
+/**
+* Get the default path for the connectors file
+*/
+function getDefaultConnectorsPath(projectRoot) {
+	return join(projectRoot || process.cwd(), PROJECT_SUBDIR, "connectors.jsonc");
+}
+/**
+* Read all connectors from the local config file
+*/
+async function readLocalConnectors(projectRoot) {
+	const filePath = await findConnectorsFile(projectRoot);
+	if (!filePath) return [];
+	const parsed = await readJsonFile(filePath);
+	const result = ConnectorsFileSchema.safeParse(parsed);
+	if (!result.success) throw new Error(`Invalid connectors configuration: ${result.error.message}`);
+	const connectors = [];
+	for (const [type, config$1] of Object.entries(result.data)) {
+		if (!isValidIntegration(type)) throw new Error(`Unknown connector type: ${type}`);
+		connectors.push({
+			type,
+			scopes: config$1.scopes
+		});
+	}
+	return connectors;
+}
+/**
+* Write connectors to the local config file
+*/
+async function writeLocalConnectors(connectors, projectRoot) {
+	let filePath = await findConnectorsFile(projectRoot);
+	if (!filePath) filePath = getDefaultConnectorsPath(projectRoot);
+	const data = {};
+	for (const connector of connectors) data[connector.type] = { ...connector.scopes && { scopes: connector.scopes } };
+	await writeJsonFile(filePath, data);
+	return filePath;
+}
+/**
+* Add a connector to the local config file
+*/
+async function addLocalConnector(type, scopes, projectRoot) {
+	const connectors = await readLocalConnectors(projectRoot);
+	const existing = connectors.find((c$1) => c$1.type === type);
+	if (existing) {
+		if (scopes) existing.scopes = scopes;
+	} else connectors.push({
+		type,
+		scopes
+	});
+	return await writeLocalConnectors(connectors, projectRoot);
+}
+/**
+* Remove a connector from the local config file
+*/
+async function removeLocalConnector(type, projectRoot) {
+	const connectors = await readLocalConnectors(projectRoot);
+	const filtered = connectors.filter((c$1) => c$1.type !== type);
+	if (filtered.length === connectors.length) return null;
+	return await writeLocalConnectors(filtered, projectRoot);
+}
+
 //#endregion
 //#region src/cli/commands/connectors/add.ts
-const POLL_INTERVAL_MS = 2e3;
-const POLL_TIMEOUT_MS = 300 * 1e3;
+const POLL_INTERVAL_MS$1 = 2e3;
+const POLL_TIMEOUT_MS$1 = 300 * 1e3;
 async function promptForIntegrationType() {
 	const selected = await ve({
 		message: "Select an integration to connect:",
@@ -39063,8 +39282,8 @@ async function waitForOAuthCompletion(integrationType, connectionId) {
 				updateMessage("Waiting for authorization in browser...");
 				return false;
 			}, {
-				interval: POLL_INTERVAL_MS,
-				timeout: POLL_TIMEOUT_MS
+				interval: POLL_INTERVAL_MS$1,
+				timeout: POLL_TIMEOUT_MS$1
 			});
 		}, {
 			successMessage: "Authorization completed!",
@@ -39105,13 +39324,17 @@ async function addConnector(integrationType) {
 		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.already_authorized) {
+		await addLocalConnector(selectedType);
+		return { outroMessage: `Already connected to ${theme.styles.bold(displayName)} (added to connectors.jsonc)` };
+	}
 	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");
+	await addLocalConnector(selectedType);
 	const accountInfo = result.accountEmail ? ` as ${theme.styles.bold(result.accountEmail)}` : "";
 	return { outroMessage: `Successfully connected to ${theme.styles.bold(displayName)}${accountInfo}` };
 }
@@ -39124,28 +39347,78 @@ const connectorsAddCommand = new Command("connectors:add").argument("[type]", "I
 
 //#endregion
 //#region src/cli/commands/connectors/list.ts
+function mergeConnectors(local, backend) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const connector of local) merged.set(connector.type, {
+		type: connector.type,
+		displayName: getIntegrationDisplayName(connector.type),
+		inLocal: true,
+		inBackend: false
+	});
+	for (const connector of backend) {
+		const existing = merged.get(connector.integrationType);
+		if (existing) {
+			existing.inBackend = true;
+			existing.status = connector.status;
+			existing.accountEmail = connector.accountInfo?.email || connector.accountInfo?.name;
+		} else merged.set(connector.integrationType, {
+			type: connector.integrationType,
+			displayName: getIntegrationDisplayName(connector.integrationType),
+			inLocal: false,
+			inBackend: true,
+			status: connector.status,
+			accountEmail: connector.accountInfo?.email || connector.accountInfo?.name
+		});
+	}
+	return Array.from(merged.values());
+}
 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})`) : ""}`;
+	const { displayName, inLocal, inBackend, status, accountEmail } = connector;
+	const isConnected$1 = inBackend && status?.toLowerCase() === "active";
+	const isPending = inLocal && !inBackend;
+	const isOrphaned = inBackend && !inLocal;
+	let bullet;
+	let statusText = "";
+	if (isConnected$1) {
+		bullet = theme.colors.success("●");
+		if (accountEmail) statusText = ` - ${accountEmail}`;
+	} else if (isPending) {
+		bullet = theme.colors.warning("○");
+		statusText = theme.styles.dim(" (not connected)");
+	} else if (isOrphaned) {
+		bullet = theme.colors.error("○");
+		statusText = theme.styles.dim(" (not in local config)");
+	} else {
+		bullet = theme.colors.error("○");
+		statusText = theme.styles.dim(` (${status || "disconnected"})`);
+	}
+	return `${bullet} ${displayName}${statusText}`;
 }
 async function listConnectorsCommand() {
-	const connectors = await runTask("Fetching connectors...", async () => {
-		return await listConnectors();
+	const [localConnectors, backendConnectors] = await runTask("Fetching connectors...", async () => {
+		const [local, backend] = await Promise.all([readLocalConnectors().catch(() => []), listConnectors().catch(() => [])]);
+		return [local, backend];
 	}, {
 		successMessage: "Connectors loaded",
 		errorMessage: "Failed to fetch connectors"
 	});
-	if (connectors.length === 0) {
+	const merged = mergeConnectors(localConnectors, backendConnectors);
+	if (merged.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));
+	for (const connector of merged) console.log(formatConnectorLine(connector));
 	console.log();
-	return { outroMessage: `${connectors.length} connector${connectors.length === 1 ? "" : "s"} configured` };
+	const connected = merged.filter((c$1) => c$1.inBackend && c$1.status?.toLowerCase() === "active").length;
+	const pending = merged.filter((c$1) => c$1.inLocal && !c$1.inBackend).length;
+	let summary = `${connected} connected`;
+	if (pending > 0) {
+		summary += `, ${pending} pending`;
+		M.info(`Run ${theme.styles.bold("base44 connectors:push")} to connect pending integrations.`);
+	}
+	return { outroMessage: summary };
 }
 const connectorsListCommand = new Command("connectors:list").description("List all connected OAuth integrations").action(async () => {
 	await runCommand(listConnectorsCommand, {
@@ -39154,56 +39427,195 @@ const connectorsListCommand = new Command("connectors:list").description("List a
 	});
 });
 
+//#endregion
+//#region src/cli/commands/connectors/push.ts
+const POLL_INTERVAL_MS = 2e3;
+const POLL_TIMEOUT_MS = 300 * 1e3;
+function findPendingConnectors(local, backend) {
+	const connectedTypes = new Set(backend.filter((c$1) => c$1.status.toLowerCase() === "active").map((c$1) => c$1.integrationType));
+	return local.filter((c$1) => !connectedTypes.has(c$1.type)).map((c$1) => ({
+		type: c$1.type,
+		displayName: getIntegrationDisplayName(c$1.type),
+		scopes: c$1.scopes
+	}));
+}
+async function connectSingleConnector(connector) {
+	const { type, displayName, scopes } = connector;
+	const initiateResponse = await initiateOAuth(type, scopes || null);
+	if (initiateResponse.already_authorized) return { success: true };
+	if (initiateResponse.error === "different_user") return {
+		success: false,
+		error: `Already connected by ${initiateResponse.other_user_email}`
+	};
+	if (!initiateResponse.redirect_url || !initiateResponse.connection_id) return {
+		success: false,
+		error: "Invalid response from server"
+	};
+	M.info(`Opening browser for ${displayName} authorization...`);
+	await open_default(initiateResponse.redirect_url);
+	let accountEmail;
+	try {
+		await pWaitFor(async () => {
+			const status = await checkOAuthStatus(type, initiateResponse.connection_id);
+			if (status.status === "ACTIVE") {
+				accountEmail = status.accountEmail;
+				return true;
+			}
+			if (status.status === "FAILED") throw new Error(status.error || "Authorization failed");
+			return false;
+		}, {
+			interval: POLL_INTERVAL_MS,
+			timeout: 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"
+		};
+		return {
+			success: false,
+			error: err instanceof Error ? err.message : "Unknown error"
+		};
+	}
+}
+async function pushConnectorsCommand() {
+	const [localConnectors, backendConnectors] = await runTask("Checking connector status...", async () => {
+		const [local, backend] = await Promise.all([readLocalConnectors(), listConnectors().catch(() => [])]);
+		return [local, backend];
+	}, {
+		successMessage: "Status checked",
+		errorMessage: "Failed to check status"
+	});
+	if (localConnectors.length === 0) {
+		M.info("No connectors defined in connectors.jsonc");
+		M.info(`Run ${theme.styles.bold("base44 connectors:add")} to add a connector.`);
+		return { outroMessage: "" };
+	}
+	const pending = findPendingConnectors(localConnectors, backendConnectors);
+	if (pending.length === 0) return { outroMessage: "All connectors are already connected" };
+	console.log();
+	M.info(`${pending.length} connector${pending.length === 1 ? "" : "s"} need${pending.length === 1 ? "s" : ""} to be connected:`);
+	for (const c$1 of pending) console.log(`  ${theme.colors.warning("○")} ${c$1.displayName}`);
+	console.log();
+	const shouldProceed = await ye({
+		message: `Connect ${pending.length} integration${pending.length === 1 ? "" : "s"}?`,
+		initialValue: true
+	});
+	if (pD(shouldProceed) || !shouldProceed) return { outroMessage: "Cancelled" };
+	let connected = 0;
+	let failed = 0;
+	for (const connector of pending) {
+		console.log();
+		M.info(`Connecting ${theme.styles.bold(connector.displayName)}...`);
+		const result = await connectSingleConnector(connector);
+		if (result.success) {
+			const accountInfo = result.accountEmail ? ` as ${result.accountEmail}` : "";
+			M.success(`${connector.displayName} connected${accountInfo}`);
+			connected++;
+		} else {
+			M.error(`${connector.displayName} failed: ${result.error}`);
+			failed++;
+		}
+	}
+	console.log();
+	if (failed === 0) return { outroMessage: `Successfully connected ${connected} integration${connected === 1 ? "" : "s"}` };
+	return { outroMessage: `Connected ${connected}, failed ${failed}` };
+}
+const connectorsPushCommand = new Command("connectors:push").description("Connect all pending integrations from connectors.jsonc").action(async () => {
+	await runCommand(pushConnectorsCommand, {
+		requireAuth: true,
+		requireAppConfig: true
+	});
+});
+
 //#endregion
 //#region src/cli/commands/connectors/remove.ts
+function mergeConnectorsForRemoval(local, backend) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const connector of local) merged.set(connector.type, {
+		type: connector.type,
+		displayName: getIntegrationDisplayName(connector.type),
+		inLocal: true,
+		inBackend: false
+	});
+	for (const connector of backend) {
+		if (!isValidIntegration(connector.integrationType)) continue;
+		const existing = merged.get(connector.integrationType);
+		if (existing) {
+			existing.inBackend = true;
+			existing.accountEmail = connector.accountInfo?.email || connector.accountInfo?.name;
+		} else merged.set(connector.integrationType, {
+			type: connector.integrationType,
+			displayName: getIntegrationDisplayName(connector.integrationType),
+			inLocal: false,
+			inBackend: true,
+			accountEmail: connector.accountInfo?.email || connector.accountInfo?.name
+		});
+	}
+	return Array.from(merged.values());
+}
 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})` : ""}`
-		}))
+		options: connectors.map((c$1) => {
+			let label = c$1.displayName;
+			if (c$1.accountEmail) label += ` (${c$1.accountEmail})`;
+			else if (c$1.inLocal && !c$1.inBackend) label += " (not connected)";
+			return {
+				value: c$1.type,
+				label
+			};
+		})
 	});
 	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();
+	const [localConnectors, backendConnectors] = await runTask("Fetching connectors...", async () => {
+		const [local, backend] = await Promise.all([readLocalConnectors().catch(() => []), listConnectors().catch(() => [])]);
+		return [local, backend];
 	}, {
 		successMessage: "Connectors loaded",
 		errorMessage: "Failed to fetch connectors"
 	});
-	if (connectors.length === 0) return { outroMessage: "No connectors to remove" };
+	const merged = mergeConnectorsForRemoval(localConnectors, backendConnectors);
+	if (merged.length === 0) return { outroMessage: "No connectors to remove" };
 	let selectedType;
+	let selectedConnector;
 	if (!integrationType) {
-		const prompted = await promptForConnectorToRemove(connectors);
+		const prompted = await promptForConnectorToRemove(merged);
 		if (!prompted) return { outroMessage: "Cancelled" };
 		selectedType = prompted;
+		selectedConnector = merged.find((c$1) => c$1.type === selectedType);
 	} 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`);
+		selectedConnector = merged.find((c$1) => c$1.type === integrationType);
+		if (!selectedConnector) throw new Error(`No ${getIntegrationDisplayName(integrationType)} connector found`);
 		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 accountInfo = selectedConnector?.accountEmail ? ` (${selectedConnector.accountEmail})` : "";
 	const shouldRemove = await ye({
-		message: `${isHardDelete ? "Permanently remove" : "Disconnect"} ${displayName}${accountInfo}?`,
+		message: `${isHardDelete ? "Permanently remove" : "Remove"} ${displayName}${accountInfo}?`,
 		initialValue: false
 	});
 	if (pD(shouldRemove) || !shouldRemove) return { outroMessage: "Cancelled" };
-	await runTask(isHardDelete ? `Removing ${displayName}...` : `Disconnecting ${displayName}...`, async () => {
-		if (isHardDelete) await removeConnector(selectedType);
+	await runTask(isHardDelete ? `Removing ${displayName}...` : `Removing ${displayName}...`, async () => {
+		if (selectedConnector?.inBackend) if (isHardDelete) await removeConnector(selectedType);
 		else await disconnectConnector(selectedType);
+		await removeLocalConnector(selectedType);
 	}, {
-		successMessage: isHardDelete ? `${displayName} removed` : `${displayName} disconnected`,
-		errorMessage: isHardDelete ? `Failed to remove ${displayName}` : `Failed to disconnect ${displayName}`
+		successMessage: `${displayName} removed`,
+		errorMessage: `Failed to remove ${displayName}`
 	});
-	return { outroMessage: `Successfully ${isHardDelete ? "removed" : "disconnected"} ${theme.styles.bold(displayName)}` };
+	return { outroMessage: `Successfully removed ${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) => {
+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("Remove an OAuth integration").action(async (type, options) => {
 	await runCommand(() => removeConnectorCommand(type, options), {
 		requireAuth: true,
 		requireAppConfig: true
@@ -39231,6 +39643,7 @@ program.addCommand(functionsDeployCommand);
 program.addCommand(siteDeployCommand);
 program.addCommand(connectorsAddCommand);
 program.addCommand(connectorsListCommand);
+program.addCommand(connectorsPushCommand);
 program.addCommand(connectorsRemoveCommand);
 program.parse();
 

package/package.json

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