@base44-preview/cli 0.0.19-pr.104.3636d73 → 0.0.19-pr.112.10b56a5

package/dist/index.js

@@ -10,7 +10,7 @@ import O from "node:readline";
 import Stream, { Duplex, PassThrough, Readable, Transform, Writable, getDefaultHighWaterMark } from "node:stream";
 import os, { constants, homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import fs$1, { access, constants as constants$1, copyFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import fs$1, { access, constants as constants$1, copyFile, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { finished } from "node:stream/promises";
 import path$1, { dirname as dirname$1, parse } from "path";
 import EE, { EventEmitter as EventEmitter$1 } from "events";
@@ -5818,97 +5818,6 @@ 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);
@@ -7199,39 +7108,6 @@ 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);
@@ -7761,21 +7637,6 @@ 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);
@@ -8042,6 +7903,7 @@ var AuthValidationError = class extends Error {
 //#endregion
 //#region src/core/consts.ts
 const PROJECT_SUBDIR = "base44";
+const CONFIG_FILE_EXTENSION = "jsonc";
 const CONFIG_FILE_EXTENSION_GLOB = "{json,jsonc}";
 const FUNCTION_CONFIG_FILE = `function.${CONFIG_FILE_EXTENSION_GLOB}`;
 const APP_CONFIG_PATTERN = `**/.app.${CONFIG_FILE_EXTENSION_GLOB}`;
@@ -9920,6 +9782,9 @@ async function deleteFile(filePath) {
 	if (!await pathExists(filePath)) return;
 	await unlink(filePath);
 }
+async function isDirEmpty(dir = process.cwd()) {
+	return (await readdir(dir)).length === 0;
+}
 
 //#endregion
 //#region src/core/auth/config.ts
@@ -16820,6 +16685,125 @@ const functionResource = {
 	push: pushFunctions
 };
 
+//#endregion
+//#region src/core/resources/agent/schema.ts
+const EntityToolConfigSchema = object({
+	entity_name: string().min(1),
+	allowed_operations: array(_enum([
+		"read",
+		"create",
+		"update",
+		"delete"
+	])).default([])
+});
+const BackendFunctionToolConfigSchema = object({
+	function_name: string().min(1),
+	description: string().default("agent backend function")
+});
+const ToolConfigSchema = union([EntityToolConfigSchema, BackendFunctionToolConfigSchema]);
+const AgentConfigSchema = object({
+	name: string().regex(/^[a-z0-9_]+$/, "Agent name must be lowercase alphanumeric with underscores").min(1).max(100),
+	description: string().min(1, "Agent description cannot be empty"),
+	instructions: string().min(1, "Agent instructions cannot be empty"),
+	tool_configs: array(ToolConfigSchema).default([]),
+	whatsapp_greeting: string().nullable().optional()
+});
+const SyncAgentsResponseSchema = object({
+	created: array(string()),
+	updated: array(string()),
+	deleted: array(string())
+});
+const AgentConfigApiResponseSchema = object({
+	name: string(),
+	description: string(),
+	instructions: string(),
+	tool_configs: array(ToolConfigSchema).default([]),
+	whatsapp_greeting: string().nullable().optional()
+});
+const ListAgentsResponseSchema = object({
+	items: array(AgentConfigApiResponseSchema),
+	total: number()
+});
+
+//#endregion
+//#region src/core/resources/agent/config.ts
+async function readAgentFile(agentPath) {
+	const parsed = await readJsonFile(agentPath);
+	const result = AgentConfigSchema.safeParse(parsed);
+	if (!result.success) throw new Error(`Invalid agent configuration in ${agentPath}: ${result.error.issues.map((e$1) => e$1.message).join(", ")}`);
+	return result.data;
+}
+async function readAllAgents(agentsDir) {
+	if (!await pathExists(agentsDir)) return [];
+	const files = await globby(`*.${CONFIG_FILE_EXTENSION_GLOB}`, {
+		cwd: agentsDir,
+		absolute: true
+	});
+	const agents = await Promise.all(files.map((filePath) => readAgentFile(filePath)));
+	const names = /* @__PURE__ */ new Set();
+	for (const agent of agents) {
+		if (names.has(agent.name)) throw new Error(`Duplicate agent name "${agent.name}"`);
+		names.add(agent.name);
+	}
+	return agents;
+}
+async function writeAgents(agentsDir, agents) {
+	const existingAgents = await readAllAgents(agentsDir);
+	const newNames = new Set(agents.map((a$1) => a$1.name));
+	const toDelete = existingAgents.filter((a$1) => !newNames.has(a$1.name));
+	for (const agent of toDelete) await deleteFile(join(agentsDir, `${agent.name}.${CONFIG_FILE_EXTENSION}`));
+	for (const agent of agents) await writeJsonFile(join(agentsDir, `${agent.name}.${CONFIG_FILE_EXTENSION}`), {
+		name: agent.name,
+		description: agent.description,
+		instructions: agent.instructions,
+		tool_configs: agent.tool_configs,
+		whatsapp_greeting: agent.whatsapp_greeting ?? null
+	});
+	return {
+		written: agents.map((a$1) => a$1.name),
+		deleted: toDelete.map((a$1) => a$1.name)
+	};
+}
+
+//#endregion
+//#region src/core/resources/agent/api.ts
+async function pushAgents(agents) {
+	const appClient = getAppClient();
+	const payload = { configs: agents.map((agent) => ({
+		name: agent.name,
+		description: agent.description,
+		instructions: agent.instructions,
+		tool_configs: agent.tool_configs,
+		whatsapp_greeting: agent.whatsapp_greeting ?? null
+	})) };
+	const response = await appClient.put("agent-configs", {
+		json: payload,
+		throwHttpErrors: false
+	});
+	if (!response.ok) {
+		const errorJson = await response.json();
+		const errorMessage = errorJson.detail || errorJson.message || "Unknown error";
+		throw new Error(`Error occurred while syncing agents: ${errorMessage}`);
+	}
+	return SyncAgentsResponseSchema.parse(await response.json());
+}
+async function fetchAgents() {
+	const response = await getAppClient().get("agent-configs", { throwHttpErrors: false });
+	if (!response.ok) {
+		const errorJson = await response.json();
+		const errorMessage = errorJson.detail || errorJson.message || "Unknown error";
+		throw new Error(`Error occurred while fetching agents: ${errorMessage}`);
+	}
+	return ListAgentsResponseSchema.parse(await response.json());
+}
+
+//#endregion
+//#region src/core/resources/agent/resource.ts
+const agentResource = {
+	readAll: readAllAgents,
+	push: pushAgents
+};
+
 //#endregion
 //#region src/core/project/schema.ts
 const TemplateSchema = object({
@@ -16835,15 +16819,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")
+	functionsDir: string().optional().default("functions"),
+	agentsDir: string().optional().default("agents")
 });
 const AppConfigSchema = object({ id: string().min(1, "id cannot be empty") });
 const CreateProjectResponseSchema = looseObject({ id: string() });
@@ -16915,7 +16897,11 @@ async function readProjectConfig(projectRoot) {
 	if (!result.success) throw new Error(`Invalid project configuration: ${result.error.message}`);
 	const project = result.data;
 	const configDir = dirname(configPath);
-	const [entities, functions] = await Promise.all([entityResource.readAll(join(configDir, project.entitiesDir)), functionResource.readAll(join(configDir, project.functionsDir))]);
+	const [entities, functions, agents] = await Promise.all([
+		entityResource.readAll(join(configDir, project.entitiesDir)),
+		functionResource.readAll(join(configDir, project.functionsDir)),
+		agentResource.readAll(join(configDir, project.agentsDir))
+	]);
 	return {
 		project: {
 			...project,
@@ -16923,38 +16909,10 @@ async function readProjectConfig(projectRoot) {
 			configPath
 		},
 		entities,
-		functions
+		functions,
+		agents
 	};
 }
-/**
-* Writes project configuration to the config file.
-* Updates the config file while preserving its location and format.
-*
-* @param updates - Partial project config to merge with existing config
-* @param projectRoot - Optional path to start searching from. Defaults to cwd.
-* @returns The path to the updated config file
-* @throws {Error} If no config file is found
-*
-* @example
-* await writeProjectConfig({ connectors: { slack: {} } });
-*/
-async function writeProjectConfig(updates, projectRoot) {
-	let found;
-	if (projectRoot) {
-		const configPath$1 = await findConfigInDir(projectRoot);
-		found = configPath$1 ? {
-			root: projectRoot,
-			configPath: configPath$1
-		} : null;
-	} else found = await findProjectRoot();
-	if (!found) throw new Error(`Project root not found. Please ensure config.jsonc or config.json exists in the project directory or ${PROJECT_SUBDIR}/ subdirectory.`);
-	const { configPath } = found;
-	await writeJsonFile(configPath, {
-		...await readJsonFile(configPath),
-		...updates
-	});
-	return configPath;
-}
 
 //#endregion
 //#region src/core/project/api.ts
@@ -31191,10 +31149,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,
@@ -31526,6 +31481,52 @@ const entitiesPushCommand = new Command("entities").description("Manage project
 	await runCommand(pushEntitiesAction, { requireAuth: true });
 }));
 
+//#endregion
+//#region src/cli/commands/agents/pull.ts
+async function pullAgentsAction() {
+	const { project } = await readProjectConfig();
+	const agentsDir = join(dirname(project.configPath), project.agentsDir);
+	const response = await runTask("Fetching agents from Base44", async () => {
+		return await fetchAgents();
+	}, {
+		successMessage: "Agents fetched successfully",
+		errorMessage: "Failed to fetch agents"
+	});
+	if (response.items.length === 0) return { outroMessage: "No agents found on Base44" };
+	const { written, deleted } = await runTask("Writing agent files", async () => {
+		return await writeAgents(agentsDir, response.items);
+	}, {
+		successMessage: "Agent files written successfully",
+		errorMessage: "Failed to write agent files"
+	});
+	if (written.length > 0) M.success(`Written: ${written.join(", ")}`);
+	if (deleted.length > 0) M.warn(`Deleted: ${deleted.join(", ")}`);
+	return { outroMessage: `Pulled ${response.total} agents to ${agentsDir}` };
+}
+const agentsPullCommand = new Command("pull").description("Pull agents from Base44 to local files (replaces all local agent configs)").action(async () => {
+	await runCommand(pullAgentsAction, { requireAuth: true });
+});
+
+//#endregion
+//#region src/cli/commands/agents/push.ts
+async function pushAgentsAction() {
+	const { agents } = await readProjectConfig();
+	M.info(agents.length === 0 ? "No local agents found - this will delete all remote agents" : `Found ${agents.length} agents to push`);
+	const result = await runTask("Pushing agents to Base44", async () => {
+		return await pushAgents(agents);
+	}, {
+		successMessage: "Agents pushed successfully",
+		errorMessage: "Failed to push agents"
+	});
+	if (result.created.length > 0) M.success(`Created: ${result.created.join(", ")}`);
+	if (result.updated.length > 0) M.success(`Updated: ${result.updated.join(", ")}`);
+	if (result.deleted.length > 0) M.warn(`Deleted: ${result.deleted.join(", ")}`);
+	return {};
+}
+const agentsCommand = new Command("agents").description("Manage project agents").addCommand(new Command("push").description("Push local agents to Base44 (replaces all remote agent configs)").action(async () => {
+	await runCommand(pushAgentsAction, { requireAuth: true });
+})).addCommand(agentsPullCommand);
+
 //#endregion
 //#region src/cli/commands/functions/deploy.ts
 async function deployFunctionsAction() {
@@ -38229,9 +38230,8 @@ async function getTemplateById(templateId) {
 	return template;
 }
 function validateNonInteractiveFlags$1(command) {
-	const { name: name$1, path: path$16 } = command.opts();
-	const providedCount = [name$1, path$16].filter(Boolean).length;
-	if (providedCount > 0 && providedCount < 2) command.error("Non-interactive mode requires all flags: --name, --path");
+	const { path: path$16 } = command.opts();
+	if (path$16 && !command.args.length) command.error("Non-interactive mode requires all flags: --name, --path");
 }
 async function chooseCreate(options) {
 	if (!!(options.name && options.path)) await runCommand(() => createNonInteractive(options), {
@@ -38255,19 +38255,18 @@ async function createInteractive(options) {
 			message: "Pick a template",
 			options: templateOptions
 		}),
-		name: () => he({
-			message: "What is the name of your project?",
-			placeholder: "my-app",
-			validate: (value) => {
-				if (!value || value.trim().length === 0) return "Every project deserves a name";
-			}
-		}),
-		description: () => he({
-			message: "Description (optional)",
-			placeholder: "A brief description of your project"
-		}),
+		name: () => {
+			return options.name ? Promise.resolve(options.name) : he({
+				message: "What is the name of your project?",
+				placeholder: basename(process.cwd()),
+				initialValue: basename(process.cwd()),
+				validate: (value) => {
+					if (!value || value.trim().length === 0) return "Every project deserves a name";
+				}
+			});
+		},
 		projectPath: async ({ results }) => {
-			const suggestedPath = `./${(0, import_lodash.default)(results.name)}`;
+			const suggestedPath = await isDirEmpty() ? `./` : `./${(0, import_lodash.default)(results.name)}`;
 			return he({
 				message: "Where should we create your project?",
 				placeholder: suggestedPath,
@@ -38278,7 +38277,6 @@ async function createInteractive(options) {
 	return await executeCreate({
 		template: result.template,
 		name: result.name,
-		description: result.description || void 0,
 		projectPath: result.projectPath,
 		deploy: options.deploy,
 		skills: options.skills,
@@ -38289,7 +38287,6 @@ async function createNonInteractive(options) {
 	return await executeCreate({
 		template: await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID),
 		name: options.name,
-		description: options.description,
 		projectPath: options.path,
 		deploy: options.deploy,
 		skills: options.skills,
@@ -38356,32 +38353,32 @@ async function executeCreate({ template, name: rawName, description, projectPath
 			finalAppUrl = appUrl;
 		}
 	}
-	let shouldAddSkills = false;
-	if (isInteractive) {
-		const result = await ye({ message: "Add AI agent skills?" });
-		shouldAddSkills = !pD(result) && result;
-	} else shouldAddSkills = !!skills;
-	if (shouldAddSkills) await runTask("Installing AI agent skills...", async () => {
-		await execa("npx", [
-			"-y",
-			"add-skill",
-			"base44/skills",
-			"-y"
-		], {
-			cwd: resolvedPath,
-			shell: true
+	if (skills ?? true) try {
+		await runTask("Installing AI agent skills...", async () => {
+			await execa("npx", [
+				"-y",
+				"add-skill",
+				"base44/skills",
+				"-y"
+			], {
+				cwd: resolvedPath,
+				shell: true
+			});
+		}, {
+			successMessage: theme.colors.base44Orange("AI agent skills added successfully"),
+			errorMessage: "Failed to add AI agent skills - you can add them later with: npx add-skill base44/skills"
 		});
-	}, {
-		successMessage: theme.colors.base44Orange("AI agent skills added successfully"),
-		errorMessage: "Failed to add AI agent skills - you can add them later with: npx add-skill base44/skills"
-	});
+	} catch {}
 	M.message(`${theme.styles.header("Project")}: ${theme.colors.base44Orange(name$1)}`);
 	M.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(projectId))}`);
 	if (finalAppUrl) M.message(`${theme.styles.header("Site")}: ${theme.colors.links(finalAppUrl)}`);
 	return { outroMessage: "Your project is set up and ready to use" };
 }
-const createCommand = new Command("create").description("Create a new Base44 project").option("-n, --name <name>", "Project name").option("-d, --description <description>", "Project description").option("-p, --path <path>", "Path where to create the project").option("-t, --template <id>", "Template ID (e.g., backend-only, backend-and-client)").option("--deploy", "Build and deploy the site").option("--skills", "Add AI agent skills").hook("preAction", validateNonInteractiveFlags$1).action(async (options) => {
-	await chooseCreate(options);
+const createCommand = new Command("create").description("Create a new Base44 project").addArgument(new Argument("name", "Project name").argOptional()).option("-p, --path <path>", "Path where to create the project").option("-t, --template <id>", "Template ID (e.g., backend-only, backend-and-client)").option("--deploy", "Build and deploy the site").option("--skills", "Add AI agent skills").hook("preAction", validateNonInteractiveFlags$1).action(async (name$1, options) => {
+	await chooseCreate({
+		name: name$1,
+		...options
+	});
 });
 
 //#endregion
@@ -39104,595 +39101,6 @@ 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()
-}).transform((data) => ({
-	redirectUrl: data.redirect_url,
-	connectionId: data.connection_id,
-	alreadyAuthorized: data.already_authorized,
-	otherUserEmail: data.other_user_email,
-	error: data.error
-}));
-/**
-* 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) });
-
-//#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 json = await (await getAppClient().post("external-auth/initiate", { json: {
-		integration_type: integrationType,
-		scopes
-	} })).json();
-	return InitiateResponseSchema.parse(json);
-}
-/**
-* Checks the status of an OAuth connection attempt.
-*/
-async function checkOAuthStatus(integrationType, connectionId) {
-	const json = await (await getAppClient().get("external-auth/status", { searchParams: {
-		integration_type: integrationType,
-		connection_id: connectionId
-	} })).json();
-	return StatusResponseSchema.parse(json);
-}
-/**
-* Lists all connected integrations for the current app.
-*/
-async function listConnectors() {
-	const json = await (await getAppClient().get("external-auth/list")).json();
-	return ListResponseSchema.parse(json).integrations;
-}
-/**
-* Disconnects (soft delete) a connector integration.
-*/
-async function disconnectConnector(integrationType) {
-	await getAppClient().delete(`external-auth/integrations/${integrationType}`);
-}
-/**
-* Removes (hard delete) a connector integration.
-* This permanently removes the connector and cannot be undone.
-*/
-async function removeConnector(integrationType) {
-	await getAppClient().delete(`external-auth/integrations/${integrationType}/remove`);
-}
-
-//#endregion
-//#region src/core/connectors/consts.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(integrationType) {
-	return INTEGRATION_DISPLAY_NAMES[integrationType] ?? integrationType;
-}
-
-//#endregion
-//#region src/core/connectors/config.ts
-/**
-* Read all connectors from the project config file
-*/
-async function readLocalConnectors(projectRoot) {
-	const { project } = await readProjectConfig(projectRoot);
-	const connectorsData = project.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 connectorsData = {};
-	for (const connector of connectors) connectorsData[connector.type] = { ...connector.scopes && { scopes: connector.scopes } };
-	return await writeProjectConfig({ connectors: Object.keys(connectorsData).length > 0 ? connectorsData : void 0 }, projectRoot);
-}
-/**
-* 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/core/connectors/state.ts
-/**
-* Fetches both local config and backend connectors in parallel.
-* Gracefully handles failures by returning empty arrays.
-*/
-async function fetchConnectorState() {
-	const [local, backend] = await Promise.all([readLocalConnectors().catch(() => []), listConnectors().catch(() => [])]);
-	return {
-		local,
-		backend
-	};
-}
-
-//#endregion
-//#region src/cli/commands/connectors/utils.ts
-/**
-* OAuth polling configuration
-*/
-const OAUTH_POLL_INTERVAL_MS = 2e3;
-const OAUTH_POLL_TIMEOUT_MS = 300 * 1e3;
-/**
-* Polls for OAuth completion status.
-* Returns when status becomes ACTIVE or FAILED, or times out.
-*/
-async function waitForOAuthCompletion(integrationType, connectionId, options) {
-	let accountEmail;
-	let error;
-	try {
-		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);
-			}
-			options?.onPending?.();
-			return false;
-		}, {
-			interval: OAUTH_POLL_INTERVAL_MS,
-			timeout: OAUTH_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. Please try again."
-		};
-		return {
-			success: false,
-			error: error || (err instanceof Error ? err.message : "Unknown error")
-		};
-	}
-}
-
-//#endregion
-//#region src/cli/commands/connectors/add.ts
-function assertValidIntegrationType(type) {
-	if (!isValidIntegration(type)) {
-		const supportedList = SUPPORTED_INTEGRATIONS.join(", ");
-		throw new Error(`Unsupported connector: ${type}\nSupported connectors: ${supportedList}`);
-	}
-}
-async function promptForIntegrationType() {
-	const selected = await ve({
-		message: "Select an integration to connect:",
-		options: Object.entries(INTEGRATION_DISPLAY_NAMES).map(([type, label]) => ({
-			value: type,
-			label
-		}))
-	});
-	if (pD(selected)) {
-		xe("Operation cancelled.");
-		process.exit(0);
-	}
-	return selected;
-}
-async function addConnector(integrationType) {
-	let selectedType;
-	if (integrationType) {
-		assertValidIntegrationType(integrationType);
-		selectedType = integrationType;
-	} else selectedType = await promptForIntegrationType();
-	const displayName = getIntegrationDisplayName(selectedType);
-	const result = await runTask(`Initiating ${displayName} connection...`, async (updateMessage) => {
-		const initiateResponse = await initiateOAuth(selectedType);
-		if (initiateResponse.alreadyAuthorized) {
-			await addLocalConnector(selectedType);
-			return { alreadyAuthorized: true };
-		}
-		if (initiateResponse.error === "different_user" && initiateResponse.otherUserEmail) throw new Error(`This app is already connected to ${displayName} by ${initiateResponse.otherUserEmail}`);
-		if (!initiateResponse.redirectUrl || !initiateResponse.connectionId) throw new Error("Invalid response from server: missing redirect URL or connection ID");
-		M.info(`Please authorize ${displayName} at:\n${theme.colors.links(initiateResponse.redirectUrl)}`);
-		updateMessage("Waiting for authorization...");
-		const oauthResult = await waitForOAuthCompletion(selectedType, initiateResponse.connectionId);
-		if (!oauthResult.success) throw new Error(oauthResult.error || "Authorization failed");
-		await addLocalConnector(selectedType);
-		return {
-			alreadyAuthorized: false,
-			accountEmail: oauthResult.accountEmail
-		};
-	}, {
-		successMessage: "Authorization completed!",
-		errorMessage: `Failed to connect ${displayName}`
-	});
-	if (result.alreadyAuthorized) return { outroMessage: `Already connected to ${theme.styles.bold(displayName)} (added to config)` };
-	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 { local: localConnectors, backend: backendConnectors } = await runTask("Fetching connectors...", fetchConnectorState, {
-		successMessage: "Connectors loaded",
-		errorMessage: "Failed to fetch connectors"
-	});
-	const merged = mergeConnectors(localConnectors, backendConnectors);
-	if (merged.length === 0) return { outroMessage: `No connectors configured. Run ${theme.styles.bold("base44 connectors add")} to connect an integration.` };
-	M.message("");
-	for (const connector of merged) M.message(formatConnectorLine(connector));
-	if (merged.filter((c$1) => c$1.inLocal && !c$1.inBackend).length > 0) return { outroMessage: `Run ${theme.styles.bold("base44 connectors push")} to connect pending integrations.` };
-	return { outroMessage: "" };
-}
-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;
-	return await runTask(`Initiating ${displayName} connection...`, async (updateMessage) => {
-		const initiateResponse = await initiateOAuth(type, scopes || null);
-		if (initiateResponse.alreadyAuthorized) return { success: true };
-		if (initiateResponse.error === "different_user") return {
-			success: false,
-			error: `Already connected by ${initiateResponse.otherUserEmail}`
-		};
-		if (!initiateResponse.redirectUrl || !initiateResponse.connectionId) return {
-			success: false,
-			error: "Invalid response from server"
-		};
-		M.info(`Please authorize ${displayName} at:\n${theme.colors.links(initiateResponse.redirectUrl)}`);
-		updateMessage("Waiting for authorization...");
-		return await waitForOAuthCompletion(type, initiateResponse.connectionId);
-	}, {
-		successMessage: "Authorization completed!",
-		errorMessage: "Authorization failed"
-	});
-}
-function buildSummaryMessage(connected, removed, failed) {
-	const parts = [];
-	if (connected > 0) parts.push(`${connected} connected`);
-	if (removed > 0) parts.push(`${removed} removed`);
-	if (failed > 0) parts.push(`${failed} failed`);
-	return parts.join(", ");
-}
-async function pushConnectorsCommand() {
-	const { local: localConnectors, backend: backendConnectors } = await runTask("Checking connector status...", fetchConnectorState, {
-		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" };
-	M.message("");
-	if (pending.length > 0) {
-		M.info(`${pending.length} connector${pending.length === 1 ? "" : "s"} to connect:`);
-		for (const c$1 of pending) M.message(`  ${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})` : "";
-			M.message(`  ${theme.colors.error("-")} ${c$1.displayName}${accountInfo}`);
-		}
-	}
-	M.message("");
-	const totalChanges = pending.length + orphaned.length;
-	const shouldProceed = await ye({ message: `Apply ${totalChanges} change${totalChanges === 1 ? "" : "s"}?` });
-	if (pD(shouldProceed) || !shouldProceed) return { outroMessage: "Cancelled" };
-	let connected = 0;
-	let removed = 0;
-	let failed = 0;
-	for (const connector of orphaned) try {
-		await runTask(`Removing ${connector.displayName}...`, () => disconnectConnector(connector.type), {
-			successMessage: `${connector.displayName} removed`,
-			errorMessage: `Failed to remove ${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) {
-		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++;
-		}
-	}
-	return { outroMessage: buildSummaryMessage(connected, removed, failed) };
-}
-const connectorsPushCommand = new Command("push").description("Sync connectors with backend").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());
-}
-function validateConnectorType(type, merged) {
-	if (!isValidIntegration(type)) throw new Error(`Invalid connector type: ${type}`);
-	const connector = merged.find((c$1) => c$1.type === type);
-	if (!connector) throw new Error(`No ${getIntegrationDisplayName(type)} connector found`);
-	return {
-		type,
-		connector
-	};
-}
-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)) {
-		xe("Operation cancelled.");
-		process.exit(0);
-	}
-	return {
-		type: selected,
-		connector: connectors.find((c$1) => c$1.type === selected)
-	};
-}
-async function removeConnectorCommand(integrationType, options = {}) {
-	const isHardDelete = options.hard === true;
-	const { local: localConnectors, backend: backendConnectors } = await runTask("Fetching connectors...", fetchConnectorState, {
-		successMessage: "Connectors loaded",
-		errorMessage: "Failed to fetch connectors"
-	});
-	const merged = mergeConnectorsForRemoval(localConnectors, backendConnectors);
-	if (merged.length === 0) return { outroMessage: "No connectors to remove" };
-	const { type: selectedType, connector: selectedConnector } = integrationType ? validateConnectorType(integrationType, merged) : await promptForConnectorToRemove(merged);
-	const displayName = getIntegrationDisplayName(selectedType);
-	const accountInfo = selectedConnector.accountEmail ? ` (${selectedConnector.accountEmail})` : "";
-	if (!options.yes) {
-		const shouldRemove = await ye({
-			message: `${isHardDelete ? "Permanently remove" : "Remove"} ${displayName}${accountInfo}?`,
-			initialValue: false
-		});
-		if (pD(shouldRemove) || !shouldRemove) {
-			xe("Operation cancelled.");
-			process.exit(0);
-		}
-	}
-	await runTask(`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)").option("-y, --yes", "Skip confirmation prompt").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.19";
@@ -39710,9 +39118,9 @@ program.addCommand(dashboardCommand);
 program.addCommand(deployCommand);
 program.addCommand(linkCommand);
 program.addCommand(entitiesPushCommand);
+program.addCommand(agentsCommand);
 program.addCommand(functionsDeployCommand);
 program.addCommand(siteDeployCommand);
-program.addCommand(connectorsCommand);
 
 //#endregion
 export { CLIExitError, program };

package/dist/templates/templates.json

@@ -1,16 +1,16 @@
 {
   "templates": [
-    {
-      "id": "backend-only",
-      "name": "Create a basic project",
-      "description": "Minimal Base44 backend for defining your data models and logic",
-      "path": "backend-only"
-    },
     {
       "id": "backend-and-client",
       "name": "Start from a template",
       "description": "Full-stack example with a Base44 backend and a Vite + React client application",
       "path": "backend-and-client"
+    },
+    {
+      "id": "backend-only",
+      "name": "Create a basic project",
+      "description": "Minimal Base44 backend for defining your data models and logic",
+      "path": "backend-only"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/cli",
-  "version": "0.0.19-pr.104.3636d73",
+  "version": "0.0.19-pr.112.10b56a5",
   "description": "Base44 CLI - Unified interface for managing Base44 applications",
   "type": "module",
   "bin": {