@base44-preview/cli 0.0.15-pr.102.ec2ad29 → 0.0.15-pr.104.996eeac

package/README.md

@@ -70,91 +70,58 @@ base44 deploy
 |---------|-------------|
 | `base44 site deploy` | Deploy built site files to Base44 hosting |
 
-### Types
+### Connectors
+
+Manage OAuth integrations to connect your app with external services. Connectors are stored in the `connectors` property of your project's `config.jsonc` file.
 
 | Command | Description |
 |---------|-------------|
-| `base44 types` | Generate TypeScript types from entity schemas |
-
-**Options:**
-- `-o, --output <dir>` - Output directory (default: `src/base44`)
-- `--entities-only` - Only generate entity types, skip client types
-
-## TypeScript Type Generation
+| `base44 connectors add [type]` | Add and connect an OAuth integration |
+| `base44 connectors list` | List all connectors (local and connected) |
+| `base44 connectors push` | Sync connectors with backend (connect new, remove missing) |
+| `base44 connectors remove [type]` | Remove an integration |
+| `base44 connectors remove [type] --hard` | Permanently remove an integration |
 
-Generate fully-typed interfaces from your entity schemas for type-safe SDK usage.
-
-### Usage
+**Supported integrations:** Slack, Google Calendar, Google Drive, Gmail, Google Sheets, Google Docs, Google Slides, Notion, Salesforce, HubSpot, LinkedIn, TikTok
 
+**Example workflow:**
 ```bash
-# Generate types (outputs to src/base44/)
-base44 types
-
-# Custom output directory
-base44 types --output ./types
+# Add a connector interactively (saves to config.jsonc and opens OAuth)
+base44 connectors add slack
+
+# List connectors showing local vs connected status
+base44 connectors list
+# Output:
+# ● Slack - user@example.com
+# ○ Google Calendar (not connected)
+
+# Sync all connectors (connects new, removes missing from config)
+base44 connectors push
+# Output:
+# 1 connector to connect:
+#   + Google Calendar
+# 1 connector to remove:
+#   - Notion (user@example.com)
+# Apply 2 changes? (Y/n)
+
+# Remove a single connector
+base44 connectors remove slack
 ```
 
-### Generated Files
-
-| File | Contents |
-|------|----------|
-| `entities.ts` | Entity interfaces, CreateInput, UpdateInput, Filter types |
-| `client.ts` | Typed SDK client interface |
-| `index.ts` | Barrel exports |
-
-### Setup with @base44/sdk
-
-1. Generate types:
-   ```bash
-   base44 types
-   ```
-
-2. Add to `tsconfig.json`:
-   ```json
-   {
-     "include": ["src", "src/base44/entities.ts"]
-   }
-   ```
-
-3. Use in your code:
-   ```typescript
-   import { createClient } from '@base44/sdk';
-   import type { TypedBase44Client } from './base44/client';
-
-   const base44 = createClient({ appId: 'my-app' }) as TypedBase44Client;
-
-   // Fully typed!
-   const { items: tasks } = await base44.entities.Task.list();
-   await base44.entities.Task.create({ title: 'Buy milk' });
-   ```
-
-### Example
-
-Given an entity schema:
+**Configuration** (`base44/config.jsonc`):
 ```jsonc
-// base44/entities/task.jsonc
 {
-  "name": "Task",
-  "type": "object",
-  "properties": {
-    "title": { "type": "string", "description": "Task title" },
-    "completed": { "type": "boolean", "default": false }
-  },
-  "required": ["title"]
+  "name": "my-app",
+  "connectors": {
+    "slack": {},
+    "googlecalendar": { "scopes": ["calendar.readonly"] }
+  }
 }
 ```
 
-Generated types:
-```typescript
-export interface Task extends BaseEntity {
-  title: string;
-  completed?: boolean;
-}
-
-export interface TaskCreateInput {
-  title: string;
-  completed?: boolean;
-}
+Once connected, use the SDK's `connectors.getAccessToken()` to retrieve tokens:
+```javascript
+const token = await base44.connectors.getAccessToken("slack");
 ```
 
 ## Configuration
@@ -202,12 +169,7 @@ my-project/
 │       └── my-function/
 │           ├── config.jsonc
 │           └── index.js
-├── src/
-│   ├── base44/                # Generated types (from `base44 types`)
-│   │   ├── entities.ts
-│   │   ├── client.ts
-│   │   └── index.ts
-│   └── ...                    # Your frontend code
+├── src/                       # Your frontend code
 ├── dist/                      # Built site files (for deployment)
 └── package.json
 ```

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 import { EventEmitter, addAbortListener, on, once, setMaxListeners } from "node:events";
 import childProcess, { ChildProcess, execFile, spawn, spawnSync } from "node:child_process";
-import path, { basename, dirname, join, posix, relative, resolve, win32 } from "node:path";
+import path, { basename, dirname, join, posix, resolve, win32 } from "node:path";
 import fs, { appendFileSync, createReadStream, createWriteStream, readFileSync, statSync, writeFileSync } from "node:fs";
 import y, { execArgv, execPath, hrtime, platform, stdin, stdout } from "node:process";
 import { aborted, callbackify, debuglog, inspect, promisify, stripVTControlCharacters } from "node:util";
@@ -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;
@@ -5909,24 +5928,6 @@ const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 		return payload;
 	};
 });
-const $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
-	$ZodType.init(inst, def);
-	if (def.values.length === 0) throw new Error("Cannot create literal schema with no valid values");
-	const values = new Set(def.values);
-	inst._zod.values = values;
-	inst._zod.pattern = /* @__PURE__ */ new RegExp(`^(${def.values.map((o$2) => typeof o$2 === "string" ? escapeRegex(o$2) : o$2 ? escapeRegex(o$2.toString()) : String(o$2)).join("|")})$`);
-	inst._zod.parse = (payload, _ctx) => {
-		const input = payload.value;
-		if (values.has(input)) return payload;
-		payload.issues.push({
-			code: "invalid_value",
-			values: def.values,
-			input,
-			inst
-		});
-		return payload;
-	};
-});
 const $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -6488,6 +6489,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" });
 }
@@ -7058,6 +7066,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 = {};
 };
@@ -7069,27 +7080,6 @@ const enumProcessor = (schema, _ctx, json, _params) => {
 	if (values.every((v$1) => typeof v$1 === "string")) json.type = "string";
 	json.enum = values;
 };
-const literalProcessor = (schema, ctx, json, _params) => {
-	const def = schema._zod.def;
-	const vals = [];
-	for (const val of def.values) if (val === void 0) {
-		if (ctx.unrepresentable === "throw") throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-	} else if (typeof val === "bigint") if (ctx.unrepresentable === "throw") throw new Error("BigInt literals cannot be represented in JSON Schema");
-	else vals.push(Number(val));
-	else vals.push(val);
-	if (vals.length === 0) {} else if (vals.length === 1) {
-		const val = vals[0];
-		json.type = val === null ? "null" : typeof val;
-		if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") json.enum = [val];
-		else json.const = val;
-	} else {
-		if (vals.every((v$1) => typeof v$1 === "number")) json.type = "number";
-		if (vals.every((v$1) => typeof v$1 === "string")) json.type = "string";
-		if (vals.every((v$1) => typeof v$1 === "boolean")) json.type = "boolean";
-		if (vals.every((v$1) => v$1 === null)) json.type = "null";
-		json.enum = vals;
-	}
-};
 const customProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
 };
@@ -7635,6 +7625,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);
@@ -7816,23 +7814,6 @@ function _enum(values, params) {
 		...normalizeParams(params)
 	});
 }
-const ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
-	$ZodLiteral.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json, params);
-	inst.values = new Set(def.values);
-	Object.defineProperty(inst, "value", { get() {
-		if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
-		return def.values[0];
-	} });
-});
-function literal(value, params) {
-	return new ZodLiteral({
-		type: "literal",
-		values: Array.isArray(value) ? value : [value],
-		...normalizeParams(params)
-	});
-}
 const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
 	$ZodTransform.init(inst, def);
 	ZodType.init(inst, def);
@@ -8058,6 +8039,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
@@ -13782,10 +13776,10 @@ var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.removeDuplicateSlashes = removeDuplicateSlashes;
 	function partitionAbsoluteAndRelative(patterns) {
 		const absolute = [];
-		const relative$1 = [];
+		const relative = [];
 		for (const pattern of patterns) if (isAbsolute(pattern)) absolute.push(pattern);
-		else relative$1.push(pattern);
-		return [absolute, relative$1];
+		else relative.push(pattern);
+		return [absolute, relative];
 	}
 	exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
 	function isAbsolute(pattern) {
@@ -16855,10 +16849,13 @@ const SiteConfigSchema = object({
 	outputDirectory: string().optional(),
 	installCommand: string().optional()
 });
+const ConnectorConfigSchema = object({ scopes: array(string()).optional() });
+const ConnectorsConfigSchema = record(string(), ConnectorConfigSchema);
 const ProjectConfigSchema = object({
 	name: string().min(1, "App name cannot be empty"),
 	description: string().optional(),
 	site: SiteConfigSchema.optional(),
+	connectors: ConnectorsConfigSchema.optional(),
 	entitiesDir: string().optional().default("entities"),
 	functionsDir: string().optional().default("functions")
 });
@@ -28210,7 +28207,7 @@ const FILE$1 = Symbol("file");
 const DIRECTORY$1 = Symbol("directory");
 const SYMLINK$1 = Symbol("symlink");
 const HARDLINK$1 = Symbol("hardlink");
-const HEADER$1 = Symbol("header");
+const HEADER = Symbol("header");
 const READ = Symbol("read");
 const LSTAT = Symbol("lstat");
 const ONLSTAT = Symbol("onlstat");
@@ -28329,7 +28326,7 @@ var WriteEntry = class extends Minipass {
 	[PREFIX](path$16) {
 		return prefixPath(path$16, this.prefix);
 	}
-	[HEADER$1]() {
+	[HEADER]() {
 		/* c8 ignore start */
 		if (!this.stat) throw new Error("cannot write header before stat");
 		/* c8 ignore stop */
@@ -28374,7 +28371,7 @@ var WriteEntry = class extends Minipass {
 		/* c8 ignore stop */
 		if (this.path.slice(-1) !== "/") this.path += "/";
 		this.stat.size = 0;
-		this[HEADER$1]();
+		this[HEADER]();
 		this.end();
 	}
 	[SYMLINK$1]() {
@@ -28385,7 +28382,7 @@ var WriteEntry = class extends Minipass {
 	}
 	[ONREADLINK](linkpath) {
 		this.linkpath = normalizeWindowsPath(linkpath);
-		this[HEADER$1]();
+		this[HEADER]();
 		this.end();
 	}
 	[HARDLINK$1](linkpath) {
@@ -28395,7 +28392,7 @@ var WriteEntry = class extends Minipass {
 		this.type = "Link";
 		this.linkpath = normalizeWindowsPath(path$1.relative(this.cwd, linkpath));
 		this.stat.size = 0;
-		this[HEADER$1]();
+		this[HEADER]();
 		this.end();
 	}
 	[FILE$1]() {
@@ -28408,7 +28405,7 @@ var WriteEntry = class extends Minipass {
 			if (linkpath?.indexOf(this.cwd) === 0) return this[HARDLINK$1](linkpath);
 			this.linkCache.set(linkKey, this.absolute);
 		}
-		this[HEADER$1]();
+		this[HEADER]();
 		if (this.stat.size === 0) return this.end();
 		this[OPENFILE]();
 	}
@@ -31150,7 +31147,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,
@@ -31461,237 +31461,6 @@ const logoutCommand = new Command("logout").description("Logout from current dev
 	await runCommand(logout, { requireAppConfig: false });
 });
 
-//#endregion
-//#region src/core/types/schema.ts
-/**
-* Schema for a full entity definition
-* Uses loose validation to allow JSON Schema flexibility
-*/
-const EntityDefinitionSchema = object({
-	name: string().min(1, "Entity name cannot be empty"),
-	type: literal("object").optional(),
-	properties: record(string(), unknown()).optional(),
-	required: array(string()).optional()
-}).passthrough();
-
-//#endregion
-//#region src/core/types/generator.ts
-const HEADER = `// Auto-generated by Base44 CLI - DO NOT EDIT
-// Regenerate with: base44 types
-`;
-/**
-* Convert a JSON Schema type to TypeScript type
-*/
-function fieldToTypeScript(field, required$1) {
-	let tsType;
-	if (field.enum && field.enum.length > 0) tsType = field.enum.map((v$1) => `'${v$1}'`).join(" | ");
-	else switch (field.type) {
-		case "string":
-			tsType = "string";
-			break;
-		case "number":
-			tsType = "number";
-			break;
-		case "boolean":
-			tsType = "boolean";
-			break;
-		case "array":
-			if (field.items) tsType = `${fieldToTypeScript(field.items, true)}[]`;
-			else tsType = "unknown[]";
-			break;
-		case "object":
-			if (field.properties) tsType = `{ ${Object.entries(field.properties).map(([name$1, prop]) => {
-				const isRequired = field.required?.includes(name$1) ?? false;
-				const propType = fieldToTypeScript(prop, isRequired);
-				return `${name$1}${isRequired ? "" : "?"}: ${propType}`;
-			}).join("; ")} }`;
-			else tsType = "Record<string, unknown>";
-			break;
-		default: tsType = "unknown";
-	}
-	return tsType;
-}
-/**
-* Generate interface fields for an entity
-*/
-function generateInterfaceFields(entity, options = {}) {
-	if (!entity.properties) return "";
-	const requiredFields = new Set(entity.required ?? []);
-	return Object.entries(entity.properties).map(([fieldName, field]) => {
-		const isRequired = options.allOptional ? false : requiredFields.has(fieldName);
-		const tsType = fieldToTypeScript(field, isRequired);
-		const optional$1 = isRequired ? "" : "?";
-		return `${field.description ? `  /** ${field.description} */\n` : ""}  ${fieldName}${optional$1}: ${tsType};`;
-	}).join("\n");
-}
-/**
-* Generate TypeScript interfaces for a single entity
-*/
-function generateEntityTypes(entity) {
-	const name$1 = entity.name;
-	return `
-/** ${name$1} entity */
-export interface ${name$1} extends BaseEntity {
-${generateInterfaceFields(entity)}
-}
-
-/** Input for creating a ${name$1} */
-export interface ${name$1}CreateInput {
-${generateInterfaceFields(entity)}
-}
-
-/** Input for updating a ${name$1} (all fields optional) */
-export interface ${name$1}UpdateInput {
-${generateInterfaceFields(entity, { allOptional: true })}
-}
-
-/** Filter query for ${name$1} */
-export interface ${name$1}Filter {
-${generateInterfaceFields(entity, { allOptional: true })}
-}
-`;
-}
-/**
-* Generate the entities.ts file content
-*/
-function generateEntitiesFile(entities) {
-	const baseEntity = `
-/** System fields present on all entities */
-export interface BaseEntity {
-  id: string;
-  created_date: string;
-  updated_date: string;
-}
-`;
-	const entityTypes = entities.map(generateEntityTypes).join("\n");
-	const entityNames = entities.map((e$1) => `'${e$1.name}'`).join(" | ");
-	const entityNamesType = entities.length > 0 ? `\n/** All entity names in this project */\nexport type EntityName = ${entityNames};\n` : "";
-	return HEADER + baseEntity + entityTypes + entityNamesType;
-}
-/**
-* Generate the client.ts file content with typed SDK wrapper
-*/
-function generateClientFile(entities) {
-	if (entities.length === 0) return HEADER + "\n// No entities found\nexport {};\n";
-	return `${HEADER}
-import type {
-  ${entities.map((e$1) => `${e$1.name}, ${e$1.name}CreateInput, ${e$1.name}UpdateInput, ${e$1.name}Filter`).join(",\n  ")}
-} from './entities.js';
-
-/** Response for list/filter operations */
-export interface ListResponse<T> {
-  items: T[];
-  total: number;
-}
-
-/** Real-time subscription event */
-export interface RealtimeEvent<T> {
-  type: 'create' | 'update' | 'delete';
-  data: T;
-  id: string;
-  timestamp: string;
-}
-
-/** Entity handler with CRUD operations */
-export interface EntityHandler<T, TCreate, TUpdate, TFilter> {
-  /** Get all records with optional pagination */
-  list(sort?: string, limit?: number, skip?: number, fields?: (keyof T)[]): Promise<ListResponse<T>>;
-  /** Get records matching filter criteria */
-  filter(query: TFilter, sort?: string, limit?: number, skip?: number, fields?: (keyof T)[]): Promise<ListResponse<T>>;
-  /** Get a single record by ID */
-  get(id: string): Promise<T>;
-  /** Create a new record */
-  create(data: TCreate): Promise<T>;
-  /** Update an existing record */
-  update(id: string, data: TUpdate): Promise<T>;
-  /** Delete a record */
-  delete(id: string): Promise<void>;
-  /** Delete multiple records matching filter */
-  deleteMany(query: TFilter): Promise<void>;
-  /** Create multiple records at once */
-  bulkCreate(data: TCreate[]): Promise<T[]>;
-  /** Subscribe to real-time updates */
-  subscribe(callback: (event: RealtimeEvent<T>) => void): () => void;
-}
-
-/** Typed entities interface for Base44 SDK */
-export interface TypedEntities {
-${entities.map((e$1) => `  ${e$1.name}: EntityHandler<${e$1.name}, ${e$1.name}CreateInput, ${e$1.name}UpdateInput, ${e$1.name}Filter>;`).join("\n")}
-}
-
-/**
- * Typed Base44 client interface.
- * Use with the Base44 SDK for type-safe entity access.
- *
- * @example
- * import { createClient } from '@base44/sdk';
- * import type { TypedBase44Client } from './base44/client';
- *
- * const base44 = createClient({ appId: 'your-app-id' }) as TypedBase44Client;
- * const tasks = await base44.entities.Task.list();
- */
-export interface TypedBase44Client {
-  entities: TypedEntities;
-}
-`;
-}
-/**
-* Generate the index.ts barrel file
-*/
-function generateIndexFile() {
-	return `${HEADER}
-export * from './entities.js';
-export * from './client.js';
-`;
-}
-
-//#endregion
-//#region src/core/types/types.ts
-/**
-* Parse entities into EntityDefinition format for type generation
-*/
-function parseEntities(entities) {
-	return entities.map((entity) => {
-		const result = EntityDefinitionSchema.safeParse(entity);
-		if (result.success) return result.data;
-		const entityName = entity.name ?? "unknown";
-		console.warn(`Skipping invalid entity "${entityName}": ${result.error.issues.map((i$1) => `${i$1.path.join(".")}: ${i$1.message}`).join(", ")}`);
-		return null;
-	}).filter((e$1) => e$1 !== null);
-}
-/**
-* Generate TypeScript types from local entity schemas
-*/
-async function generateTypes(options = {}) {
-	const { output = "src/base44", entitiesOnly = false } = options;
-	const projectRoot = await findProjectRoot();
-	if (!projectRoot) throw new Error("Project root not found. Please run this command from within a Base44 project.");
-	const { entities } = await readProjectConfig(projectRoot.root);
-	const parsedEntities = parseEntities(entities);
-	const outputDir = join(projectRoot.root, output);
-	await mkdir(outputDir, { recursive: true });
-	const files = [];
-	const entitiesContent = generateEntitiesFile(parsedEntities);
-	const entitiesPath = join(outputDir, "entities.ts");
-	await writeFile(entitiesPath, entitiesContent, "utf-8");
-	files.push(entitiesPath);
-	if (!entitiesOnly) {
-		const clientContent = generateClientFile(parsedEntities);
-		const clientPath = join(outputDir, "client.ts");
-		await writeFile(clientPath, clientContent, "utf-8");
-		files.push(clientPath);
-		const indexContent = generateIndexFile();
-		const indexPath = join(outputDir, "index.ts");
-		await writeFile(indexPath, indexContent, "utf-8");
-		files.push(indexPath);
-	}
-	return {
-		entityCount: parsedEntities.length,
-		files,
-		outputDir
-	};
-}
-
 //#endregion
 //#region src/cli/commands/entities/push.ts
 async function pushEntitiesAction() {
@@ -31737,35 +31506,6 @@ const functionsDeployCommand = new Command("functions").description("Manage proj
 	await runCommand(deployFunctionsAction, { requireAuth: true });
 }));
 
-//#endregion
-//#region src/cli/commands/types/generate.ts
-async function generateTypesAction(options) {
-	const result = await runTask("Generating TypeScript types", async () => {
-		return await generateTypes({
-			output: options.output,
-			entitiesOnly: options.entitiesOnly
-		});
-	}, {
-		successMessage: "Types generated successfully",
-		errorMessage: "Failed to generate types"
-	});
-	if (result.entityCount === 0) {
-		M.warn("No entities found in project");
-		return { outroMessage: "No types generated" };
-	}
-	M.info(`Generated types for ${result.entityCount} entities`);
-	M.info(`Output directory: ${result.outputDir}`);
-	const fileList = result.files.map((f) => `  - ${relative(process.cwd(), f)}`).join("\n");
-	M.info(`Files:\n${fileList}`);
-	return { outroMessage: "Types generated successfully!" };
-}
-const typesGenerateCommand = new Command("types").description("Generate TypeScript types from entity schemas").option("-o, --output <dir>", "Output directory", "src/base44").option("--entities-only", "Only generate entity types, skip client types").action(async (options) => {
-	await runCommand(() => generateTypesAction(options), {
-		requireAuth: false,
-		requireAppConfig: false
-	});
-});
-
 //#endregion
 //#region node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
@@ -39244,6 +38984,664 @@ 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()
+});
+/**
+* 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) });
+/**
+* Generic API error response
+*/
+const ApiErrorSchema = object({
+	error: string(),
+	detail: string().nullish()
+});
+
+//#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
+/**
+* OAuth polling configuration
+*/
+const OAUTH_POLL_INTERVAL_MS = 2e3;
+const OAUTH_POLL_TIMEOUT_MS = 300 * 1e3;
+/**
+* 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/core/connectors/config.ts
+/**
+* Read all connectors from the project config file
+*/
+async function readLocalConnectors(projectRoot) {
+	const found = await findProjectRoot(projectRoot);
+	if (!found) return [];
+	const connectorsData = (await readJsonFile(found.configPath)).connectors;
+	if (!connectorsData) return [];
+	const connectors = [];
+	for (const [type, config$1] of Object.entries(connectorsData)) {
+		if (!isValidIntegration(type)) throw new Error(`Unknown connector type: ${type}`);
+		connectors.push({
+			type,
+			scopes: config$1.scopes
+		});
+	}
+	return connectors;
+}
+/**
+* Write connectors to the project config file
+*/
+async function writeLocalConnectors(connectors, projectRoot) {
+	const found = await findProjectRoot(projectRoot);
+	if (!found) throw new Error("Project config not found. Run this command from a Base44 project directory.");
+	const existingConfig = await readJsonFile(found.configPath);
+	const connectorsData = {};
+	for (const connector of connectors) connectorsData[connector.type] = { ...connector.scopes && { scopes: connector.scopes } };
+	const updatedConfig = {
+		...existingConfig,
+		connectors: Object.keys(connectorsData).length > 0 ? connectorsData : void 0
+	};
+	if (!updatedConfig.connectors) delete updatedConfig.connectors;
+	await writeJsonFile(found.configPath, updatedConfig);
+	return found.configPath;
+}
+/**
+* Add a connector to the project 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 project 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
+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 ?? void 0;
+					return true;
+				}
+				if (status.status === "FAILED") {
+					error = status.error || "Authorization failed";
+					throw new Error(error);
+				}
+				updateMessage("Waiting for authorization in browser...");
+				return false;
+			}, {
+				interval: OAUTH_POLL_INTERVAL_MS,
+				timeout: OAUTH_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) {
+		await addLocalConnector(selectedType);
+		return { outroMessage: `Already connected to ${theme.styles.bold(displayName)} (added to config)` };
+	}
+	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(`Please authorize ${displayName} at:\n${theme.colors.links(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}` };
+}
+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/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);
+		const accountEmail = (connector.accountInfo?.email || connector.accountInfo?.name) ?? void 0;
+		if (existing) {
+			existing.inBackend = true;
+			existing.status = connector.status;
+			existing.accountEmail = accountEmail;
+		} else merged.set(connector.integrationType, {
+			type: connector.integrationType,
+			displayName: getIntegrationDisplayName(connector.integrationType),
+			inLocal: false,
+			inBackend: true,
+			status: connector.status,
+			accountEmail
+		});
+	}
+	return Array.from(merged.values());
+}
+function formatConnectorLine(connector) {
+	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 [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"
+	});
+	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 merged) console.log(formatConnectorLine(connector));
+	console.log();
+	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("list").description("List all connected OAuth integrations").action(async () => {
+	await runCommand(listConnectorsCommand, {
+		requireAuth: true,
+		requireAppConfig: true
+	});
+});
+
+//#endregion
+//#region src/cli/commands/connectors/push.ts
+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
+	}));
+}
+function findOrphanedConnectors(local, backend) {
+	const localTypes = new Set(local.map((c$1) => c$1.type));
+	return backend.filter((c$1) => c$1.status.toLowerCase() === "active").filter((c$1) => !localTypes.has(c$1.integrationType)).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
+	}));
+}
+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(`Please authorize ${displayName} at:\n${theme.colors.links(initiateResponse.redirect_url)}`);
+	let accountEmail;
+	try {
+		await runTask("Waiting for authorization...", async () => {
+			await pWaitFor(async () => {
+				const status = await checkOAuthStatus(type, initiateResponse.connection_id);
+				if (status.status === "ACTIVE") {
+					accountEmail = status.accountEmail ?? void 0;
+					return true;
+				}
+				if (status.status === "FAILED") throw new Error(status.error || "Authorization failed");
+				return false;
+			}, {
+				interval: OAUTH_POLL_INTERVAL_MS,
+				timeout: OAUTH_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: 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"
+	});
+	const pending = findPendingConnectors(localConnectors, backendConnectors);
+	const orphaned = findOrphanedConnectors(localConnectors, backendConnectors);
+	if (pending.length === 0 && orphaned.length === 0) return { outroMessage: "All connectors are in sync" };
+	console.log();
+	if (pending.length > 0) {
+		M.info(`${pending.length} connector${pending.length === 1 ? "" : "s"} to connect:`);
+		for (const c$1 of pending) console.log(`  ${theme.colors.success("+")} ${c$1.displayName}`);
+	}
+	if (orphaned.length > 0) {
+		M.info(`${orphaned.length} connector${orphaned.length === 1 ? "" : "s"} to remove:`);
+		for (const c$1 of orphaned) {
+			const accountInfo = c$1.accountEmail ? ` (${c$1.accountEmail})` : "";
+			console.log(`  ${theme.colors.error("-")} ${c$1.displayName}${accountInfo}`);
+		}
+	}
+	console.log();
+	const totalChanges = pending.length + orphaned.length;
+	const shouldProceed = await ye({
+		message: `Apply ${totalChanges} change${totalChanges === 1 ? "" : "s"}?`,
+		initialValue: true
+	});
+	if (pD(shouldProceed) || !shouldProceed) return { outroMessage: "Cancelled" };
+	let connected = 0;
+	let removed = 0;
+	let failed = 0;
+	for (const connector of orphaned) try {
+		await disconnectConnector(connector.type);
+		M.success(`Removed ${connector.displayName}`);
+		removed++;
+	} catch (err) {
+		M.error(`Failed to remove ${connector.displayName}: ${err instanceof Error ? err.message : "Unknown error"}`);
+		failed++;
+	}
+	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();
+	const parts = [];
+	if (connected > 0) parts.push(`${connected} connected`);
+	if (removed > 0) parts.push(`${removed} removed`);
+	if (failed > 0) parts.push(`${failed} failed`);
+	return { outroMessage: parts.join(", ") };
+}
+const connectorsPushCommand = new Command("push").description("Sync connectors with backend (connect new, remove missing)").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);
+		const accountEmail = (connector.accountInfo?.email || connector.accountInfo?.name) ?? void 0;
+		if (existing) {
+			existing.inBackend = true;
+			existing.accountEmail = accountEmail;
+		} else merged.set(connector.integrationType, {
+			type: connector.integrationType,
+			displayName: getIntegrationDisplayName(connector.integrationType),
+			inLocal: false,
+			inBackend: true,
+			accountEmail
+		});
+	}
+	return Array.from(merged.values());
+}
+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})`;
+			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 [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"
+	});
+	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(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}`);
+		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 accountInfo = selectedConnector?.accountEmail ? ` (${selectedConnector.accountEmail})` : "";
+	const shouldRemove = await ye({
+		message: `${isHardDelete ? "Permanently remove" : "Remove"} ${displayName}${accountInfo}?`,
+		initialValue: false
+	});
+	if (pD(shouldRemove) || !shouldRemove) return { outroMessage: "Cancelled" };
+	await runTask(isHardDelete ? `Removing ${displayName}...` : `Removing ${displayName}...`, async () => {
+		if (selectedConnector?.inBackend) if (isHardDelete) await removeConnector(selectedType);
+		else await disconnectConnector(selectedType);
+		await removeLocalConnector(selectedType);
+	}, {
+		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)").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(connectorsListCommand).addCommand(connectorsPushCommand).addCommand(connectorsRemoveCommand);
+
 //#endregion
 //#region package.json
 var version = "0.0.15";
@@ -39262,8 +39660,8 @@ program.addCommand(deployCommand);
 program.addCommand(linkCommand);
 program.addCommand(entitiesPushCommand);
 program.addCommand(functionsDeployCommand);
-program.addCommand(typesGenerateCommand);
 program.addCommand(siteDeployCommand);
+program.addCommand(connectorsCommand);
 program.parse();
 
 //#endregion

package/package.json

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